ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-07-09 19:11:38 -07:00
Code Issues Packages Projects Releases Wiki Activity

type decoration to explicitly disable string visualization; use in registers & padding members; eliminate dead code

Browse Source
This commit is contained in:
Ryan Fleury
2025-04-10 14:28:45 -07:00
parent c05c21cfa4
commit 4a69b8e57a
7 changed files with 35 additions and 573 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/eval/eval_core.h
+3 -91
View File
@@ -301,8 +301,9 @@ enum
E_TypeFlag_IsPlainText = (1<<2),
E_TypeFlag_IsCodeText = (1<<3),
E_TypeFlag_IsPathText = (1<<4),
E_TypeFlag_EditableChildren = (1<<5),
E_TypeFlag_InheritedOnAccess = (1<<6),
E_TypeFlag_IsNotText = (1<<5),
E_TypeFlag_EditableChildren = (1<<6),
E_TypeFlag_InheritedOnAccess = (1<<7),
};
typedef struct E_Member E_Member;
@@ -493,95 +494,6 @@ struct E_String2ExprMap
E_String2ExprMapSlot *slots;
};
////////////////////////////////
//~ rjf: Member/Index Lookup Hooks
#if 0 // TODO(rjf): @eval
typedef struct E_LookupInfo E_LookupInfo;
struct E_LookupInfo
{
void *user_data;
U64 named_expr_count;
U64 idxed_expr_count;
};
typedef struct E_LookupAccess E_LookupAccess;
struct E_LookupAccess
{
E_IRTreeAndType irtree_and_type;
};
#define E_LOOKUP_INFO_FUNCTION_SIG(name) E_LookupInfo name(Arena *arena, E_IRTreeAndType *lhs, E_Expr *tag, String8 filter)
#define E_LOOKUP_INFO_FUNCTION_NAME(name) e_lookup_info_##name
#define E_LOOKUP_INFO_FUNCTION_DEF(name) internal E_LOOKUP_INFO_FUNCTION_SIG(E_LOOKUP_INFO_FUNCTION_NAME(name))
typedef E_LOOKUP_INFO_FUNCTION_SIG(E_LookupInfoFunctionType);
E_LOOKUP_INFO_FUNCTION_DEF(default);
#define E_LOOKUP_ACCESS_FUNCTION_SIG(name) E_LookupAccess name(Arena *arena, E_ExprKind kind, E_Expr *lhs, E_Expr *rhs, E_Expr *tag, void *user_data)
#define E_LOOKUP_ACCESS_FUNCTION_NAME(name) e_lookup_access_##name
#define E_LOOKUP_ACCESS_FUNCTION_DEF(name) internal E_LOOKUP_ACCESS_FUNCTION_SIG(E_LOOKUP_ACCESS_FUNCTION_NAME(name))
typedef E_LOOKUP_ACCESS_FUNCTION_SIG(E_LookupAccessFunctionType);
E_LOOKUP_ACCESS_FUNCTION_DEF(default);
#define E_LOOKUP_RANGE_FUNCTION_SIG(name) void name(Arena *arena, E_Expr *lhs, E_Expr *tag, String8 filter, Rng1U64 idx_range, E_Expr **exprs, String8 *exprs_strings, void *user_data)
#define E_LOOKUP_RANGE_FUNCTION_NAME(name) e_lookup_range_##name
#define E_LOOKUP_RANGE_FUNCTION_DEF(name) internal E_LOOKUP_RANGE_FUNCTION_SIG(E_LOOKUP_RANGE_FUNCTION_NAME(name))
typedef E_LOOKUP_RANGE_FUNCTION_SIG(E_LookupRangeFunctionType);
E_LOOKUP_RANGE_FUNCTION_DEF(default);
#define E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(name) U64 name(U64 num, void *user_data)
#define E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name) e_lookup_id_from_num_##name
#define E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(name) internal E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name))
typedef E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LookupIDFromNumFunctionType);
E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default);
#define E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(name) U64 name(U64 id, void *user_data)
#define E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name) e_lookup_num_from_id_##name
#define E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(name) internal E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name))
typedef E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LookupNumFromIDFunctionType);
E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(default);
typedef struct E_LookupRule E_LookupRule;
struct E_LookupRule
{
String8 name;
E_LookupInfoFunctionType *info;
E_LookupAccessFunctionType *access;
E_LookupRangeFunctionType *range;
E_LookupIDFromNumFunctionType *id_from_num;
E_LookupNumFromIDFunctionType *num_from_id;
};
typedef struct E_LookupRuleNode E_LookupRuleNode;
struct E_LookupRuleNode
{
E_LookupRuleNode *next;
E_LookupRule v;
};
typedef struct E_LookupRuleSlot E_LookupRuleSlot;
struct E_LookupRuleSlot
{
E_LookupRuleNode *first;
E_LookupRuleNode *last;
};
typedef struct E_LookupRuleMap E_LookupRuleMap;
struct E_LookupRuleMap
{
E_LookupRuleSlot *slots;
U64 slots_count;
};
typedef struct E_LookupRuleExprPair E_LookupRuleExprPair;
struct E_LookupRuleExprPair
{
E_LookupRule *rule;
E_Expr *expr;
};
#endif
////////////////////////////////
//~ rjf: Type Pattern -> Hook Key Data Structure (Auto View Rules)
src/eval/eval_types.c
+2 -2
View File
@@ -1159,7 +1159,7 @@ e_type_from_key(Arena *arena, E_TypeKey key)
E_Member *mem = &n->v;
mem->kind = E_MemberKind_DataField;
mem->name = str8_lit("u8s");
mem->type_key = e_type_key_cons_array(e_type_key_basic(E_TypeKind_U8), reg_byte_count, 0);
mem->type_key = e_type_key_cons_array(e_type_key_basic(E_TypeKind_U8), reg_byte_count, E_TypeFlag_IsNotText);
}
if(type->byte_size > 4 && type->byte_size%4 == 0)
{
@@ -1628,7 +1628,7 @@ e_type_data_members_from_key(Arena *arena, E_TypeKey key)
E_Member *padding_member = &new_members.v[n->prev_member_idx+padding_idx+1];
MemoryZeroStruct(padding_member);
padding_member->kind = E_MemberKind_Padding;
padding_member->type_key = e_type_key_cons_array(e_type_key_basic(E_TypeKind_U8), n->size, 0);
padding_member->type_key = e_type_key_cons_array(e_type_key_basic(E_TypeKind_U8), n->size, E_TypeFlag_IsNotText);
padding_member->off = n->off;
padding_member->name = push_str8f(arena, "[padding %I64u]", padding_idx);
padding_idx += 1;
src/eval_visualization/eval_visualization_core.c
+18 -5
View File
@@ -1559,6 +1559,14 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string)
E_Value value = e_value_from_expr(type->args[0]);
lens_params.min_digits = value.u64;
}
else if(str8_match(type->name, str8_lit("no_string"), 0))
{
lens_params.flags |= EV_StringFlag_DisableStrings;
}
else if(str8_match(type->name, str8_lit("no_addr"), 0))
{
lens_params.flags |= EV_StringFlag_DisableAddresses;
}
else
{
lens_applied = 0;
@@ -1673,7 +1681,8 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string)
case 0:
{
// rjf: try strings
if(!ptr_data->did_prefix_content && ptr_data->ptee_has_string &&
if(!(ptr_data->type->flags & E_TypeFlag_IsNotText) &&
!ptr_data->did_prefix_content && ptr_data->ptee_has_string &&
!(params->flags & EV_StringFlag_DisableStrings) &&
(type_kind == E_TypeKind_Array ||
params->flags & EV_StringFlag_ReadOnlyDisplayRules))
@@ -1897,15 +1906,19 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string)
//
// rjf: [read only] if we did prefix content, do a parenthesized pointer value
if(params->flags & EV_StringFlag_ReadOnlyDisplayRules && ptr_data->did_prefix_content)
if(!(params->flags & EV_StringFlag_DisableAddresses) && params->flags & EV_StringFlag_ReadOnlyDisplayRules && ptr_data->did_prefix_content)
{
*out_string = push_str8f(arena, " (%S)", ptr_value_string);
}
// rjf: [read only] if we did *not* do any prefix content, do "<pointer value> -> " then descend
// rjf: [read only] if we did *not* do any prefix content, but we have content,
// do "<pointer value> -> " then descend
else if(params->flags & EV_StringFlag_ReadOnlyDisplayRules && !ptr_data->did_prefix_content && ptr_data->ptee_has_content)
{
*out_string = push_str8f(arena, "%S -> ", ptr_value_string);
if(!(params->flags & EV_StringFlag_DisableAddresses))
{
*out_string = push_str8f(arena, "%S -> ", ptr_value_string);
}
// rjf: single-length pointers -> just gen new task for deref'd expr
if(ptr_data->type->count == 1)
@@ -1926,7 +1939,7 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string)
}
// rjf: [writeable, catchall] if we did *not* do any prefix content, do "<pointer value>"
else
else if(!ptr_data->did_prefix_content)
{
*out_string = push_str8_copy(arena, ptr_value_string);
}
src/raddbg/raddbg_core.c
+4 -468
View File
@@ -5604,7 +5604,7 @@ rd_window_frame(void)
if(eval.irtree.mode != E_Mode_Null)
{
EV_StringParams string_params = {.flags = EV_StringFlag_ReadOnlyDisplayRules, .radix = 10};
String8 value_string = rd_value_string_from_eval_NEW(scratch.arena, str8_zero(), &string_params, ui_top_font(), ui_top_font_size(), ui_top_font_size()*20.f, eval);
String8 value_string = rd_value_string_from_eval(scratch.arena, str8_zero(), &string_params, ui_top_font(), ui_top_font_size(), ui_top_font_size()*20.f, eval);
rd_code_label(1.f, 0, ui_color_from_name(str8_lit("text")), value_string);
}
}
@@ -9170,474 +9170,8 @@ rd_window_frame(void)
////////////////////////////////
//~ rjf: Eval Visualization
#if 0 // TODO(rjf): @eval
internal F32
rd_append_value_strings_from_eval(Arena *arena, String8 filter, EV_StringFlags flags, U32 default_radix, FNT_Tag font, F32 font_size, F32 max_size, S32 depth, E_Eval root_eval, E_Eval eval, String8List *out)
{
ProfBeginFunction();
Temp scratch = scratch_begin(&arena, 1);
F32 space_taken = 0;
//- rjf: unpack view rules
U32 radix = default_radix;
U32 min_digits = 0;
B32 no_addr = 0;
B32 no_string = 0;
for(E_Expr *tag = root_eval.exprs.last->first_tag; tag != &e_expr_nil; tag = tag->next)
{
if(0){}
else if(str8_match(tag->string, str8_lit("dec"), 0)) {radix = 10;}
else if(str8_match(tag->string, str8_lit("hex"), 0)) {radix = 16;}
else if(str8_match(tag->string, str8_lit("bin"), 0)) {radix = 2; }
else if(str8_match(tag->string, str8_lit("oct"), 0)) {radix = 8; }
else if(str8_match(tag->string, str8_lit("no_addr"), 0)) {no_addr = 1;}
else if(str8_match(tag->string, str8_lit("no_string"), 0)) {no_string = 1;}
else if(str8_match(tag->string, str8_lit("digits"), 0))
{
E_Expr *num_expr = tag->first->next;
E_Eval num_eval = e_eval_from_expr(scratch.arena, num_expr);
E_Eval num_value_eval = e_value_eval_from_eval(num_eval);
min_digits = (U32)num_value_eval.value.u64;
}
}
//- rjf: force no_addr in non-address-spaces
if(eval.space.kind == RD_EvalSpaceKind_MetaCtrlEntity ||
eval.space.kind == RD_EvalSpaceKind_MetaCfg)
{
no_addr = 1;
}
//- rjf: force no_string, if we are looking at padding members
if(eval.expr->kind == E_ExprKind_MemberAccess)
{
E_IRTreeAndType irtree = e_irtree_and_type_from_expr(scratch.arena, eval.expr->first);
E_TypeKey struct_type = irtree.type_key;
for(B32 done = 0; !done;)
{
E_TypeKind kind = e_type_kind_from_key(struct_type);
if(kind == E_TypeKind_Null ||
kind == E_TypeKind_Struct ||
kind == E_TypeKind_Union ||
kind == E_TypeKind_Class)
{
done = 1;
}
else if(e_type_kind_is_pointer_or_ref(kind))
{
struct_type = e_type_direct_from_key(struct_type);
}
else
{
break;
}
}
E_Member member = e_type_member_from_key_name__cached(struct_type, eval.expr->first->next->string);
if(member.kind == E_MemberKind_Padding)
{
no_string = 1;
}
}
//- rjf: type evaluations -> display type string
if(eval.irtree.mode == E_Mode_Null && !e_type_key_match(e_type_key_zero(), eval.irtree.type_key))
{
String8 string = e_type_string_from_key(arena, eval.irtree.type_key);
str8_list_push(arena, out, string);
}
//- rjf: value/offset evaluations
else if(max_size > 0)
{
E_TypeKey type_key = e_type_unwrap(eval.irtree.type_key);
E_TypeKind kind = e_type_kind_from_key(type_key);
switch(kind)
{
//- rjf: default - leaf cases
default:
{
E_Eval value_eval = e_value_eval_from_eval(eval);
String8 string = {0}; // ev_string_from_simple_typed_eval(arena, flags, radix, min_digits, value_eval);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, string).x;
str8_list_push(arena, out, string);
}break;
//- rjf: pointers
case E_TypeKind_Function:
case E_TypeKind_Ptr:
case E_TypeKind_LRef:
case E_TypeKind_RRef:
{
// rjf: unpack type info
E_TypeKey type_key = e_type_unwrap(eval.irtree.type_key);
E_Type *type = e_type_from_key__cached(type_key);
E_TypeKind type_kind = type->kind;
E_TypeKey direct_type_key = e_type_unwrap(e_type_ptee_from_key(type_key));
E_TypeKind direct_type_kind = e_type_kind_from_key(direct_type_key);
// rjf: unpack info about pointer destination
E_Eval value_eval = e_value_eval_from_eval(eval);
B32 ptee_has_content = (direct_type_kind != E_TypeKind_Null && direct_type_kind != E_TypeKind_Void);
B32 ptee_has_string = ((E_TypeKind_Char8 <= direct_type_kind && direct_type_kind <= E_TypeKind_UChar32) ||
direct_type_kind == E_TypeKind_S8 ||
direct_type_kind == E_TypeKind_U8);
E_Space space = value_eval.space;
CTRL_Entity *entity = rd_ctrl_entity_from_eval_space(space);
CTRL_Entity *process = ctrl_process_from_entity(entity);
if(process == &ctrl_entity_nil)
{
CTRL_Entity *thread = ctrl_entity_from_handle(d_state->ctrl_entity_store, rd_regs()->thread);
process = ctrl_process_from_entity(thread);
}
String8 symbol_name = d_symbol_name_from_process_vaddr(arena, process, value_eval.value.u64, type->depth, 1);
// rjf: special case: push strings for textual string content
B32 did_content = 0;
B32 did_string = 0;
if(!did_content && ptee_has_string && !no_string)
{
did_content = 1;
did_string = 1;
U64 string_memory_addr = value_eval.value.u64;
U64 element_size = e_type_byte_size_from_key(direct_type_key);
U64 string_buffer_size = 1024;
U8 *string_buffer = push_array(arena, U8, string_buffer_size);
for(U64 try_size = string_buffer_size; try_size >= 16; try_size /= 2)
{
B32 read_good = e_space_read(eval.space, string_buffer, r1u64(string_memory_addr, string_memory_addr+try_size));
if(read_good)
{
break;
}
}
string_buffer[string_buffer_size-1] = 0;
String8 string = {0};
switch(element_size)
{
default:{string = str8_cstring((char *)string_buffer);}break;
case 2: {string = str8_from_16(arena, str16_cstring((U16 *)string_buffer));}break;
case 4: {string = str8_from_32(arena, str32_cstring((U32 *)string_buffer));}break;
}
String8 string_escaped = string;
if(!no_addr || depth > 0)
{
string_escaped = ev_escaped_from_raw_string(arena, string);
}
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, string_escaped).x;
space_taken += 2*fnt_dim_from_tag_size_string(font, font_size, 0, 0, str8_lit("\"")).x;
if(!no_addr || depth > 0)
{
str8_list_push(arena, out, str8_lit("\""));
}
str8_list_push(arena, out, string_escaped);
if(!no_addr || depth > 0)
{
str8_list_push(arena, out, str8_lit("\""));
}
}
// rjf: special case: push strings for symbols
if(value_eval.value.u64 != 0 &&
!did_content && symbol_name.size != 0 &&
flags & EV_StringFlag_ReadOnlyDisplayRules &&
((type_kind == E_TypeKind_Ptr && direct_type_kind == E_TypeKind_Void) ||
(type_kind == E_TypeKind_Ptr && direct_type_kind == E_TypeKind_Function) ||
(type_kind == E_TypeKind_Function)))
{
did_content = 1;
str8_list_push(arena, out, symbol_name);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, symbol_name).x;
}
// rjf: special case: need symbol name, don't have one
if(value_eval.value.u64 != 0 &&
!did_content && symbol_name.size == 0 &&
flags & EV_StringFlag_ReadOnlyDisplayRules &&
((type_kind == E_TypeKind_Ptr && direct_type_kind == E_TypeKind_Function) ||
(type_kind == E_TypeKind_Function)) &&
(flags & EV_StringFlag_ReadOnlyDisplayRules))
{
did_content = 1;
String8 string = str8_lit("???");
str8_list_push(arena, out, string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, string).x;
}
// rjf: push pointer value
B32 did_ptr_value = 0;
if(!no_addr || value_eval.value.u64 == 0)
{
did_ptr_value = 1;
if(did_content)
{
String8 left_paren = str8_lit(" (");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, left_paren).x;
str8_list_push(arena, out, left_paren);
}
String8 string = {0}; // ev_string_from_simple_typed_eval(arena, flags, radix, min_digits, value_eval);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, string).x;
str8_list_push(arena, out, string);
if(did_content)
{
String8 right_paren = str8_lit(")");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, right_paren).x;
str8_list_push(arena, out, right_paren);
}
}
// rjf: descend for all other cases
B32 did_arrow = 0;
if(value_eval.value.u64 != 0 && !did_content && ptee_has_content && (flags & EV_StringFlag_ReadOnlyDisplayRules))
{
if(did_ptr_value && !did_arrow)
{
did_arrow = 1;
String8 arrow = str8_lit(" -> ");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, arrow).x;
str8_list_push(arena, out, arrow);
}
did_content = 1;
if(depth < 4)
{
if(type->count == 1)
{
E_Expr *deref_expr = e_expr_ref_deref(scratch.arena, eval.expr);
E_Eval deref_eval = e_eval_from_expr(scratch.arena, deref_expr);
space_taken += rd_append_value_strings_from_eval(arena, filter, flags, radix, font, font_size, max_size-space_taken, depth+1, root_eval, deref_eval, out);
}
else
{
// rjf: unpack
E_IRTreeAndType irtree = eval.irtree;
E_LookupRule *lookup_rule = &e_lookup_rule__default;
E_Expr *lookup_rule_tag = &e_expr_nil;
E_LookupRule *lookup_rule = eval.lookup_rule_tag.rule;
E_Expr *lookup_rule_tag = eval.lookup_rule_tag.tag;
if(lookup_rule == &e_lookup_rule__default)
{
lookup_rule = root_eval.lookup_rule_tag.rule;
lookup_rule_tag = root_eval.lookup_rule_tag.tag;
}
E_LookupInfo lookup_info = lookup_rule->info(arena, &irtree, lookup_rule_tag, filter);
U64 total_possible_child_count = Max(lookup_info.idxed_expr_count, lookup_info.named_expr_count);
String8 opener_string = str8_lit("[");
String8 closer_string = str8_lit("]");
// rjf: opener ({, [)
{
str8_list_push(arena, out, opener_string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, opener_string).x;
}
// rjf: contents
{
B32 is_first = 1;
for(U64 idx = 0; idx < total_possible_child_count && max_size > space_taken; idx += 1)
{
E_Expr *expr = &e_expr_nil;
String8 expr_string = {0};
lookup_rule->range(scratch.arena, eval.exprs.last, lookup_rule_tag, filter, r1u64(idx, idx+1), &expr, &expr_string, lookup_info.user_data);
if(expr != &e_expr_nil)
{
if(!is_first)
{
String8 comma = str8_lit(", ");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, comma).x;
str8_list_push(arena, out, comma);
}
is_first = 0;
E_Eval child_eval = e_eval_from_expr(scratch.arena, expr);
space_taken += rd_append_value_strings_from_eval(arena, filter, flags, radix, font, font_size, max_size-space_taken, depth+1, root_eval, child_eval, out);
if(space_taken > max_size && idx+1 < total_possible_child_count)
{
String8 ellipses = str8_lit(", ...");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, ellipses).x;
str8_list_push(arena, out, ellipses);
}
}
}
}
// rjf: closer (}, ])
{
str8_list_push(arena, out, closer_string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, closer_string).x;
}
}
}
else
{
String8 ellipses = str8_lit("...");
str8_list_push(arena, out, ellipses);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, ellipses).x;
}
}
}break;
//- rjf: arrays
case E_TypeKind_Array:
{
// rjf: unpack type info
E_Type *eval_type = e_type_from_key__cached(e_type_unwrap(eval.irtree.type_key));
E_TypeKey direct_type_key = e_type_unwrap(eval_type->direct_type_key);
E_TypeKind direct_type_kind = e_type_kind_from_key(direct_type_key);
U64 array_count = eval_type->count;
// rjf: get pointed-at type
B32 array_is_string = ((E_TypeKind_Char8 <= direct_type_kind && direct_type_kind <= E_TypeKind_UChar32) ||
direct_type_kind == E_TypeKind_S8 ||
direct_type_kind == E_TypeKind_U8);
// rjf: special case: push strings for textual string content
B32 did_content = 0;
if(!did_content && array_is_string && !no_string)
{
U64 element_size = e_type_byte_size_from_key(direct_type_key);
did_content = 1;
U64 string_buffer_size = Clamp(1, array_count, 1024);
U8 *string_buffer = push_array(arena, U8, string_buffer_size);
switch(eval.irtree.mode)
{
default:{}break;
case E_Mode_Offset:
{
U64 string_memory_addr = eval.value.u64;
B32 read_good = e_space_read(eval.space, string_buffer, r1u64(string_memory_addr, string_memory_addr+string_buffer_size));
}break;
case E_Mode_Value:
{
MemoryCopy(string_buffer, &eval.value.u512.u64[0], Min(string_buffer_size, sizeof(eval.value)));
}break;
}
String8 string = {0};
switch(element_size)
{
default:{string = str8_cstring_capped(string_buffer, string_buffer + string_buffer_size);}break;
case 2: {string = str8_from_16(arena, str16_cstring_capped(string_buffer, string_buffer + string_buffer_size));}break;
case 4: {string = str8_from_32(arena, str32_cstring((U32 *)string_buffer));}break;
}
String8 string_escaped = ev_escaped_from_raw_string(arena, string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, string_escaped).x;
space_taken += 2*fnt_dim_from_tag_size_string(font, font_size, 0, 0, str8_lit("\"")).x;
if(!no_addr || depth > 0)
{
str8_list_push(arena, out, str8_lit("\""));
}
str8_list_push(arena, out, string_escaped);
if(!no_addr || depth > 0)
{
str8_list_push(arena, out, str8_lit("\""));
}
}
// rjf: if we did not do any special content, then go to the regular arrays/structs/sets case
if(!did_content)
{
goto arrays_and_sets_and_structs;
}
}break;
//- rjf: non-string-arrays/structs/sets
case E_TypeKind_Struct:
case E_TypeKind_Union:
case E_TypeKind_Class:
case E_TypeKind_IncompleteStruct:
case E_TypeKind_IncompleteUnion:
case E_TypeKind_IncompleteClass:
case E_TypeKind_Set:
arrays_and_sets_and_structs:
{
// rjf: unpack
E_IRTreeAndType irtree = eval.irtree;
E_LookupRule *lookup_rule = &e_lookup_rule__default;
E_Expr *lookup_rule_tag = &e_expr_nil;
E_LookupRule *lookup_rule = eval.lookup_rule_tag.rule;
E_Expr *lookup_rule_tag = eval.lookup_rule_tag.tag;
if(lookup_rule == &e_lookup_rule__default)
{
lookup_rule = root_eval.lookup_rule_tag.rule;
lookup_rule_tag = root_eval.lookup_rule_tag.tag;
}
E_LookupInfo lookup_info = lookup_rule->info(arena, &irtree, lookup_rule_tag, filter);
U64 total_possible_child_count = Max(lookup_info.idxed_expr_count, lookup_info.named_expr_count);
String8 opener_string = str8_lit("{");
String8 closer_string = str8_lit("}");
if(lookup_info.idxed_expr_count > lookup_info.named_expr_count)
{
opener_string = str8_lit("[");
closer_string = str8_lit("]");
}
// rjf: opener ({, [)
{
str8_list_push(arena, out, opener_string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, opener_string).x;
}
// rjf: build contents
if(depth < 4)
{
B32 is_first = 1;
for(U64 idx = 0; idx < total_possible_child_count && max_size > space_taken; idx += 1)
{
E_Expr *expr = &e_expr_nil;
String8 expr_string = {0};
lookup_rule->range(scratch.arena, eval.exprs.last, lookup_rule_tag, filter, r1u64(idx, idx+1), &expr, &expr_string, lookup_info.user_data);
if(expr != &e_expr_nil)
{
if(!is_first)
{
String8 comma = str8_lit(", ");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, comma).x;
str8_list_push(arena, out, comma);
}
is_first = 0;
E_Eval child_eval = e_eval_from_expr(scratch.arena, expr);
space_taken += rd_append_value_strings_from_eval(arena, filter, flags, radix, font, font_size, max_size-space_taken, depth+1, root_eval, child_eval, out);
if(space_taken > max_size && idx+1 < total_possible_child_count)
{
String8 ellipses = str8_lit(", ...");
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, ellipses).x;
str8_list_push(arena, out, ellipses);
}
}
}
}
else
{
String8 ellipses = str8_lit("...");
str8_list_push(arena, out, ellipses);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, ellipses).x;
}
// rjf: closer (}, ])
{
str8_list_push(arena, out, closer_string);
space_taken += fnt_dim_from_tag_size_string(font, font_size, 0, 0, closer_string).x;
}
}break;
}
}
scratch_end(scratch);
ProfEnd();
return space_taken;
}
internal String8
rd_value_string_from_eval(Arena *arena, String8 filter, EV_StringFlags flags, U32 default_radix, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval)
{
Temp scratch = scratch_begin(&arena, 1);
String8List strs = {0};
rd_append_value_strings_from_eval(scratch.arena, filter, flags, default_radix, font, font_size, max_size, 0, eval, eval, &strs);
String8 result = str8_list_join(arena, &strs, 0);
scratch_end(scratch);
return result;
}
#endif
internal String8
rd_value_string_from_eval_NEW(Arena *arena, String8 filter, EV_StringParams *params, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval)
rd_value_string_from_eval(Arena *arena, String8 filter, EV_StringParams *params, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval)
{
Temp scratch = scratch_begin(&arena, 1);
String8List strs = {0};
@@ -12712,6 +12246,8 @@ rd_frame(void)
{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)},
src/raddbg/raddbg_core.h
+1 -5
View File
@@ -1003,11 +1003,7 @@ internal void rd_window_frame(void);
////////////////////////////////
//~ rjf: Eval Visualization
#if 0 // TODO(rjf): @eval
internal F32 rd_append_value_strings_from_eval(Arena *arena, String8 filter, EV_StringFlags flags, U32 default_radix, FNT_Tag font, F32 font_size, F32 max_size, S32 depth, E_Eval root_eval, E_Eval eval, String8List *out);
internal String8 rd_value_string_from_eval(Arena *arena, String8 filter, EV_StringFlags flags, U32 default_radix, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval);
#endif
internal String8 rd_value_string_from_eval_NEW(Arena *arena, String8 filter, EV_StringParams *params, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval);
internal String8 rd_value_string_from_eval(Arena *arena, String8 filter, EV_StringParams *params, FNT_Tag font, F32 font_size, F32 max_size, E_Eval eval);
////////////////////////////////
//~ rjf: Hover Eval
src/raddbg/raddbg_views.c
+6 -1
View File
@@ -1500,10 +1500,15 @@ rd_info_from_watch_row_cell(Arena *arena, EV_Row *row, EV_StringFlags string_fla
{
string_params.radix = 16;
}
if(result.eval.space.kind == RD_EvalSpaceKind_CtrlEntity &&
rd_ctrl_entity_from_eval_space(result.eval.space)->kind == CTRL_EntityKind_Thread)
{
string_params.radix = 16;
}
}
//- rjf: generate strings/flags based on that expression & fill
result.string = rd_value_string_from_eval_NEW(arena, rd_view_query_input(), &string_params, font, font_size, max_size_px, result.eval);
result.string = rd_value_string_from_eval(arena, rd_view_query_input(), &string_params, font, font_size, max_size_px, result.eval);
result.flags |= !!(ev_type_key_is_editable(result.eval.irtree.type_key) && result.eval.irtree.mode == E_Mode_Offset) * RD_WatchCellFlag_CanEdit;
E_Type *type = e_type_from_key__cached(result.eval.irtree.type_key);
if(type->flags & (E_TypeFlag_IsPlainText|E_TypeFlag_IsPathText))
src/raddbg/raddbg_widgets.c
+1 -1
View File
@@ -1979,7 +1979,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe
if(!e_type_key_match(e_type_key_zero(), eval.irtree.type_key))
{
EV_StringParams string_params = {.flags = EV_StringFlag_ReadOnlyDisplayRules, .radix = 10};
eval_string = rd_value_string_from_eval_NEW(scratch.arena, str8_zero(), &string_params, params->font, params->font_size, params->font_size*60.f, eval);
eval_string = rd_value_string_from_eval(scratch.arena, str8_zero(), &string_params, params->font, params->font_size, params->font_size*60.f, eval);
}
ui_spacer(ui_em(1.5f, 1.f));
ui_set_next_pref_width(ui_children_sum(1));