diff --git a/src/dbg_engine/dbg_engine_core.c b/src/dbg_engine/dbg_engine_core.c index 02b5de6b..55ff4808 100644 --- a/src/dbg_engine/dbg_engine_core.c +++ b/src/dbg_engine/dbg_engine_core.c @@ -251,7 +251,7 @@ d_cmd_list_push_new(Arena *arena, D_CmdList *cmds, D_CmdKind kind, D_CmdParams * //- rjf: nil internal B32 -d_entity_is_nil(D_Entity *entity) +d_entity_is_nil(DF_Entity *entity) { return (entity == 0 || entity == &d_nil_entity); } @@ -259,13 +259,13 @@ d_entity_is_nil(D_Entity *entity) //- rjf: handle <-> entity conversions internal U64 -d_index_from_entity(D_Entity *entity) +d_index_from_entity(DF_Entity *entity) { return (U64)(entity - d_state->entities_base); } internal D_Handle -d_handle_from_entity(D_Entity *entity) +d_handle_from_entity(DF_Entity *entity) { D_Handle handle = d_handle_zero(); if(!d_entity_is_nil(entity)) @@ -276,10 +276,10 @@ d_handle_from_entity(D_Entity *entity) return handle; } -internal D_Entity * +internal DF_Entity * d_entity_from_handle(D_Handle handle) { - D_Entity *result = d_state->entities_base + handle.u64[0]; + DF_Entity *result = d_state->entities_base + handle.u64[0]; if(handle.u64[0] >= d_state->entities_count || result->gen != handle.u64[1]) { result = &d_nil_entity; @@ -293,7 +293,7 @@ d_entity_list_from_handle_list(Arena *arena, D_HandleList handles) D_EntityList result = {0}; for(D_HandleNode *n = handles.first; n != 0; n = n->next) { - D_Entity *entity = d_entity_from_handle(n->handle); + DF_Entity *entity = d_entity_from_handle(n->handle); if(!d_entity_is_nil(entity)) { d_entity_list_push(arena, &result, entity); @@ -317,19 +317,19 @@ d_handle_list_from_entity_list(Arena *arena, D_EntityList entities) //- rjf: entity recursion iterators internal D_EntityRec -d_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off) +d_entity_rec_depth_first(DF_Entity *entity, DF_Entity *subtree_root, U64 sib_off, U64 child_off) { D_EntityRec result = {0}; - if(!d_entity_is_nil(*MemberFromOffset(D_Entity **, entity, child_off))) + if(!d_entity_is_nil(*MemberFromOffset(DF_Entity **, entity, child_off))) { - result.next = *MemberFromOffset(D_Entity **, entity, child_off); + result.next = *MemberFromOffset(DF_Entity **, entity, child_off); result.push_count = 1; } - else for(D_Entity *parent = entity; parent != subtree_root && !d_entity_is_nil(parent); parent = parent->parent) + else for(DF_Entity *parent = entity; parent != subtree_root && !d_entity_is_nil(parent); parent = parent->parent) { - if(parent != subtree_root && !d_entity_is_nil(*MemberFromOffset(D_Entity **, parent, sib_off))) + if(parent != subtree_root && !d_entity_is_nil(*MemberFromOffset(DF_Entity **, parent, sib_off))) { - result.next = *MemberFromOffset(D_Entity **, parent, sib_off); + result.next = *MemberFromOffset(DF_Entity **, parent, sib_off); break; } result.pop_count += 1; @@ -339,11 +339,11 @@ d_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, //- rjf: ancestor/child introspection -internal D_Entity * -d_entity_child_from_kind(D_Entity *entity, D_EntityKind kind) +internal DF_Entity * +d_entity_child_from_kind(DF_Entity *entity, D_EntityKind kind) { - D_Entity *result = &d_nil_entity; - for(D_Entity *child = entity->first; !d_entity_is_nil(child); child = child->next) + DF_Entity *result = &d_nil_entity; + for(DF_Entity *child = entity->first; !d_entity_is_nil(child); child = child->next) { if(child->kind == kind) { @@ -354,11 +354,11 @@ d_entity_child_from_kind(D_Entity *entity, D_EntityKind kind) return result; } -internal D_Entity * -d_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind) +internal DF_Entity * +d_entity_ancestor_from_kind(DF_Entity *entity, D_EntityKind kind) { - D_Entity *result = &d_nil_entity; - for(D_Entity *p = entity->parent; !d_entity_is_nil(p); p = p->parent) + DF_Entity *result = &d_nil_entity; + for(DF_Entity *p = entity->parent; !d_entity_is_nil(p); p = p->parent) { if(p->kind == kind) { @@ -370,10 +370,10 @@ d_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind) } internal D_EntityList -d_push_entity_child_list_with_kind(Arena *arena, D_Entity *entity, D_EntityKind kind) +d_push_entity_child_list_with_kind(Arena *arena, DF_Entity *entity, D_EntityKind kind) { D_EntityList result = {0}; - for(D_Entity *child = entity->first; !d_entity_is_nil(child); child = child->next) + for(DF_Entity *child = entity->first; !d_entity_is_nil(child); child = child->next) { if(child->kind == kind) { @@ -383,11 +383,11 @@ d_push_entity_child_list_with_kind(Arena *arena, D_Entity *entity, D_EntityKind return result; } -internal D_Entity * -d_entity_child_from_string_and_kind(D_Entity *parent, String8 string, D_EntityKind kind) +internal DF_Entity * +d_entity_child_from_string_and_kind(DF_Entity *parent, String8 string, D_EntityKind kind) { - D_Entity *result = &d_nil_entity; - for(D_Entity *child = parent->first; !d_entity_is_nil(child); child = child->next) + DF_Entity *result = &d_nil_entity; + for(DF_Entity *child = parent->first; !d_entity_is_nil(child); child = child->next) { if(str8_match(child->string, string, 0) && child->kind == kind) { @@ -401,7 +401,7 @@ d_entity_child_from_string_and_kind(D_Entity *parent, String8 string, D_EntityKi //- rjf: entity list building internal void -d_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity) +d_entity_list_push(Arena *arena, D_EntityList *list, DF_Entity *entity) { D_EntityNode *n = push_array(arena, D_EntityNode, 1); n->entity = entity; @@ -414,7 +414,7 @@ d_entity_array_from_list(Arena *arena, D_EntityList *list) { D_EntityArray result = {0}; result.count = list->count; - result.v = push_array(arena, D_Entity *, result.count); + result.v = push_array(arena, DF_Entity *, result.count); U64 idx = 0; for(D_EntityNode *n = list->first; n != 0; n = n->next, idx += 1) { @@ -444,7 +444,7 @@ d_entity_fuzzy_item_array_from_entity_array_needle(Arena *arena, D_EntityArray * U64 result_idx = 0; for(U64 src_idx = 0; src_idx < array->count; src_idx += 1) { - D_Entity *entity = array->v[src_idx]; + DF_Entity *entity = array->v[src_idx]; String8 display_string = d_display_string_from_entity(scratch.arena, entity); FuzzyMatchRangeList matches = fuzzy_match_find(arena, needle, display_string); if(matches.count >= matches.needle_part_count) @@ -476,13 +476,13 @@ d_entity_fuzzy_item_array_from_entity_array_needle(Arena *arena, D_EntityArray * //- rjf: full path building, from file/folder entities internal String8 -d_full_path_from_entity(Arena *arena, D_Entity *entity) +d_full_path_from_entity(Arena *arena, DF_Entity *entity) { String8 string = {0}; { Temp scratch = scratch_begin(&arena, 1); String8List strs = {0}; - for(D_Entity *e = entity; !d_entity_is_nil(e); e = e->parent) + for(DF_Entity *e = entity; !d_entity_is_nil(e); e = e->parent) { if(e->kind == D_EntityKind_File) { @@ -500,7 +500,7 @@ d_full_path_from_entity(Arena *arena, D_Entity *entity) //- rjf: display string entities, for referencing entities in ui internal String8 -d_display_string_from_entity(Arena *arena, D_Entity *entity) +d_display_string_from_entity(Arena *arena, DF_Entity *entity) { String8 result = {0}; switch(entity->kind) @@ -526,7 +526,7 @@ d_display_string_from_entity(Arena *arena, D_Entity *entity) } else { - D_Entity *exe = d_entity_child_from_kind(entity, D_EntityKind_Executable); + DF_Entity *exe = d_entity_child_from_kind(entity, D_EntityKind_Executable); result = push_str8_copy(arena, exe->string); } }break; @@ -539,7 +539,7 @@ d_display_string_from_entity(Arena *arena, D_Entity *entity) } else { - D_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); + DF_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); if(loc->flags & D_EntityFlag_HasTextPoint) { result = push_str8f(arena, "%S:%I64d:%I64d", str8_skip_last_slash(loc->string), loc->text_point.line, loc->text_point.column); @@ -557,7 +557,7 @@ d_display_string_from_entity(Arena *arena, D_Entity *entity) case D_EntityKind_Process: { - D_Entity *main_mod_child = d_entity_child_from_kind(entity, D_EntityKind_Module); + DF_Entity *main_mod_child = d_entity_child_from_kind(entity, D_EntityKind_Module); String8 main_mod_name = str8_skip_last_slash(main_mod_child->string); result = push_str8f(arena, "%S%s%sPID: %i%s", main_mod_name, @@ -572,8 +572,8 @@ d_display_string_from_entity(Arena *arena, D_Entity *entity) String8 name = entity->string; if(name.size == 0) { - D_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); - D_Entity *first_thread = d_entity_child_from_kind(process, D_EntityKind_Thread); + DF_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); + DF_Entity *first_thread = d_entity_child_from_kind(process, D_EntityKind_Thread); if(first_thread == entity) { name = str8_lit("Main Thread"); @@ -603,7 +603,7 @@ d_display_string_from_entity(Arena *arena, D_Entity *entity) //- rjf: extra search tag strings for fuzzy filtering entities internal String8 -d_search_tags_from_entity(Arena *arena, D_Entity *entity) +d_search_tags_from_entity(Arena *arena, DF_Entity *entity) { String8 result = {0}; if(entity->kind == D_EntityKind_Thread) @@ -637,7 +637,7 @@ d_search_tags_from_entity(Arena *arena, D_Entity *entity) //- rjf: entity -> color operations internal Vec4F32 -d_hsva_from_entity(D_Entity *entity) +d_hsva_from_entity(DF_Entity *entity) { Vec4F32 result = {0}; if(entity->flags & D_EntityFlag_HasColor) @@ -648,7 +648,7 @@ d_hsva_from_entity(D_Entity *entity) } internal Vec4F32 -d_rgba_from_entity(D_Entity *entity) +d_rgba_from_entity(DF_Entity *entity) { Vec4F32 result = {0}; if(entity->flags & D_EntityFlag_HasColor) @@ -663,7 +663,7 @@ d_rgba_from_entity(D_Entity *entity) //- rjf: entity -> expansion tree keys internal EV_Key -d_ev_key_from_entity(D_Entity *entity) +d_ev_key_from_entity(DF_Entity *entity) { EV_Key parent_key = d_parent_ev_key_from_entity(entity); EV_Key key = ev_key_make(ev_hash_from_key(parent_key), (U64)entity); @@ -671,7 +671,7 @@ d_ev_key_from_entity(D_Entity *entity) } internal EV_Key -d_parent_ev_key_from_entity(D_Entity *entity) +d_parent_ev_key_from_entity(DF_Entity *entity) { EV_Key parent_key = ev_key_make(5381, (U64)entity); return parent_key; @@ -680,12 +680,12 @@ d_parent_ev_key_from_entity(D_Entity *entity) //- rjf: entity -> evaluation internal D_EntityEval * -d_eval_from_entity(Arena *arena, D_Entity *entity) +d_eval_from_entity(Arena *arena, DF_Entity *entity) { D_EntityEval *eval = push_array(arena, D_EntityEval, 1); { - D_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); - D_Entity *cnd = d_entity_child_from_kind(entity, D_EntityKind_Condition); + DF_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); + DF_Entity *cnd = d_entity_child_from_kind(entity, D_EntityKind_Condition); String8 label_string = push_str8_copy(arena, entity->string); String8 loc_string = {0}; if(loc->flags & D_EntityFlag_HasTextPoint) @@ -819,8 +819,8 @@ d_name_release(String8 string) //- rjf: entity allocation + tree forming -internal D_Entity * -d_entity_alloc(D_Entity *parent, D_EntityKind kind) +internal DF_Entity * +d_entity_alloc(DF_Entity *parent, D_EntityKind kind) { B32 user_defined_lifetime = !!(d_entity_kind_flags_table[kind] & D_EntityKindFlag_UserDefinedLifetime); U64 free_list_idx = !!user_defined_lifetime; @@ -829,14 +829,14 @@ d_entity_alloc(D_Entity *parent, D_EntityKind kind) // rjf: empty free list -> push new if(!d_state->entities_free[free_list_idx]) { - D_Entity *entity = push_array(d_state->entities_arena, D_Entity, 1); + DF_Entity *entity = push_array(d_state->entities_arena, DF_Entity, 1); d_state->entities_count += 1; d_state->entities_free_count += 1; SLLStackPush(d_state->entities_free[free_list_idx], entity); } // rjf: pop new entity off free-list - D_Entity *entity = d_state->entities_free[free_list_idx]; + DF_Entity *entity = d_state->entities_free[free_list_idx]; SLLStackPop(d_state->entities_free[free_list_idx]); d_state->entities_free_count -= 1; d_state->entities_active_count += 1; @@ -890,7 +890,7 @@ d_entity_alloc(D_Entity *parent, D_EntityKind kind) } internal void -d_entity_mark_for_deletion(D_Entity *entity) +d_entity_mark_for_deletion(DF_Entity *entity) { if(!d_entity_is_nil(entity)) { @@ -899,7 +899,7 @@ d_entity_mark_for_deletion(D_Entity *entity) } internal void -d_entity_release(D_Entity *entity) +d_entity_release(DF_Entity *entity) { Temp scratch = scratch_begin(0, 0); @@ -911,14 +911,14 @@ d_entity_release(D_Entity *entity) struct Task { Task *next; - D_Entity *e; + DF_Entity *e; }; Task start_task = {0, entity}; Task *first_task = &start_task; Task *last_task = &start_task; for(Task *task = first_task; task != 0; task = task->next) { - for(D_Entity *child = task->e->first; !d_entity_is_nil(child); child = child->next) + for(DF_Entity *child = task->e->first; !d_entity_is_nil(child); child = child->next) { Task *t = push_array(scratch.arena, Task, 1); t->e = child; @@ -950,7 +950,7 @@ d_entity_release(D_Entity *entity) } internal void -d_entity_change_parent(D_Entity *entity, D_Entity *old_parent, D_Entity *new_parent, D_Entity *prev_child) +d_entity_change_parent(DF_Entity *entity, DF_Entity *old_parent, DF_Entity *new_parent, DF_Entity *prev_child) { Assert(entity->parent == old_parent); Assert(prev_child->parent == old_parent || d_entity_is_nil(prev_child)); @@ -973,7 +973,7 @@ d_entity_change_parent(D_Entity *entity, D_Entity *old_parent, D_Entity *new_par //- rjf: entity simple equipment internal void -d_entity_equip_txt_pt(D_Entity *entity, TxtPt point) +d_entity_equip_txt_pt(DF_Entity *entity, TxtPt point) { d_require_entity_nonnil(entity, return); entity->text_point = point; @@ -981,7 +981,7 @@ d_entity_equip_txt_pt(D_Entity *entity, TxtPt point) } internal void -d_entity_equip_entity_handle(D_Entity *entity, D_Handle handle) +d_entity_equip_entity_handle(DF_Entity *entity, D_Handle handle) { d_require_entity_nonnil(entity, return); entity->entity_handle = handle; @@ -989,14 +989,14 @@ d_entity_equip_entity_handle(D_Entity *entity, D_Handle handle) } internal void -d_entity_equip_disabled(D_Entity *entity, B32 value) +d_entity_equip_disabled(DF_Entity *entity, B32 value) { d_require_entity_nonnil(entity, return); entity->disabled = value; } internal void -d_entity_equip_u64(D_Entity *entity, U64 u64) +d_entity_equip_u64(DF_Entity *entity, U64 u64) { d_require_entity_nonnil(entity, return); entity->u64 = u64; @@ -1004,7 +1004,7 @@ d_entity_equip_u64(D_Entity *entity, U64 u64) } internal void -d_entity_equip_color_rgba(D_Entity *entity, Vec4F32 rgba) +d_entity_equip_color_rgba(DF_Entity *entity, Vec4F32 rgba) { d_require_entity_nonnil(entity, return); Vec3F32 rgb = v3f32(rgba.x, rgba.y, rgba.z); @@ -1014,7 +1014,7 @@ d_entity_equip_color_rgba(D_Entity *entity, Vec4F32 rgba) } internal void -d_entity_equip_color_hsva(D_Entity *entity, Vec4F32 hsva) +d_entity_equip_color_hsva(DF_Entity *entity, Vec4F32 hsva) { d_require_entity_nonnil(entity, return); entity->color_hsva = hsva; @@ -1022,14 +1022,14 @@ d_entity_equip_color_hsva(D_Entity *entity, Vec4F32 hsva) } internal void -d_entity_equip_cfg_src(D_Entity *entity, D_CfgSrc cfg_src) +d_entity_equip_cfg_src(DF_Entity *entity, D_CfgSrc cfg_src) { d_require_entity_nonnil(entity, return); entity->cfg_src = cfg_src; } internal void -d_entity_equip_timestamp(D_Entity *entity, U64 timestamp) +d_entity_equip_timestamp(DF_Entity *entity, U64 timestamp) { d_require_entity_nonnil(entity, return); entity->timestamp = timestamp; @@ -1038,7 +1038,7 @@ d_entity_equip_timestamp(D_Entity *entity, U64 timestamp) //- rjf: control layer correllation equipment internal void -d_entity_equip_ctrl_handle(D_Entity *entity, CTRL_Handle handle) +d_entity_equip_ctrl_handle(DF_Entity *entity, CTRL_Handle handle) { d_require_entity_nonnil(entity, return); entity->ctrl_handle = handle; @@ -1046,7 +1046,7 @@ d_entity_equip_ctrl_handle(D_Entity *entity, CTRL_Handle handle) } internal void -d_entity_equip_arch(D_Entity *entity, Arch arch) +d_entity_equip_arch(DF_Entity *entity, Arch arch) { d_require_entity_nonnil(entity, return); entity->arch = arch; @@ -1054,7 +1054,7 @@ d_entity_equip_arch(D_Entity *entity, Arch arch) } internal void -d_entity_equip_ctrl_id(D_Entity *entity, U32 id) +d_entity_equip_ctrl_id(DF_Entity *entity, U32 id) { d_require_entity_nonnil(entity, return); entity->ctrl_id = id; @@ -1062,7 +1062,7 @@ d_entity_equip_ctrl_id(D_Entity *entity, U32 id) } internal void -d_entity_equip_stack_base(D_Entity *entity, U64 stack_base) +d_entity_equip_stack_base(DF_Entity *entity, U64 stack_base) { d_require_entity_nonnil(entity, return); entity->stack_base = stack_base; @@ -1070,7 +1070,7 @@ d_entity_equip_stack_base(D_Entity *entity, U64 stack_base) } internal void -d_entity_equip_vaddr_rng(D_Entity *entity, Rng1U64 range) +d_entity_equip_vaddr_rng(DF_Entity *entity, Rng1U64 range) { d_require_entity_nonnil(entity, return); entity->vaddr_rng = range; @@ -1078,7 +1078,7 @@ d_entity_equip_vaddr_rng(D_Entity *entity, Rng1U64 range) } internal void -d_entity_equip_vaddr(D_Entity *entity, U64 vaddr) +d_entity_equip_vaddr(DF_Entity *entity, U64 vaddr) { d_require_entity_nonnil(entity, return); entity->vaddr = vaddr; @@ -1088,7 +1088,7 @@ d_entity_equip_vaddr(D_Entity *entity, U64 vaddr) //- rjf: name equipment internal void -d_entity_equip_name(D_Entity *entity, String8 name) +d_entity_equip_name(DF_Entity *entity, String8 name) { d_require_entity_nonnil(entity, return); if(entity->string.size != 0) @@ -1106,7 +1106,7 @@ d_entity_equip_name(D_Entity *entity, String8 name) } internal void -d_entity_equip_namef(D_Entity *entity, char *fmt, ...) +d_entity_equip_namef(DF_Entity *entity, char *fmt, ...) { Temp scratch = scratch_begin(0, 0); va_list args; @@ -1144,9 +1144,9 @@ d_possible_overrides_from_file_path(Arena *arena, String8 file_path) for(D_EntityNode *n = links.first; n != 0; n = n->next) { //- rjf: unpack link - D_Entity *link = n->entity; - D_Entity *src = d_entity_child_from_kind(link, D_EntityKind_Source); - D_Entity *dst = d_entity_child_from_kind(link, D_EntityKind_Dest); + DF_Entity *link = n->entity; + DF_Entity *src = d_entity_child_from_kind(link, D_EntityKind_Source); + DF_Entity *dst = d_entity_child_from_kind(link, D_EntityKind_Dest); PathStyle src_style = PathStyle_Relative; PathStyle dst_style = PathStyle_Relative; String8List src_parts = path_normalized_list_from_string(scratch.arena, src->string, &src_style); @@ -1194,7 +1194,7 @@ d_possible_overrides_from_file_path(Arena *arena, String8 file_path) //- rjf: top-level state queries -internal D_Entity * +internal DF_Entity * d_entity_root(void) { return d_state->entities_root; @@ -1205,7 +1205,7 @@ d_push_entity_list_with_kind(Arena *arena, D_EntityKind kind) { ProfBeginFunction(); D_EntityList result = {0}; - for(D_Entity *entity = d_state->entities_root; + for(DF_Entity *entity = d_state->entities_root; !d_entity_is_nil(entity); entity = d_entity_rec_depth_first_pre(entity, &d_nil_entity).next) { @@ -1218,11 +1218,11 @@ d_push_entity_list_with_kind(Arena *arena, D_EntityKind kind) return result; } -internal D_Entity * +internal DF_Entity * d_entity_from_id(D_EntityID id) { - D_Entity *result = &d_nil_entity; - for(D_Entity *e = d_entity_root(); + DF_Entity *result = &d_nil_entity; + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, &d_nil_entity).next) { @@ -1235,11 +1235,11 @@ d_entity_from_id(D_EntityID id) return result; } -internal D_Entity * +internal DF_Entity * d_machine_entity_from_machine_id(CTRL_MachineID machine_id) { - D_Entity *result = &d_nil_entity; - for(D_Entity *e = d_entity_root(); + DF_Entity *result = &d_nil_entity; + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, &d_nil_entity).next) { @@ -1257,13 +1257,13 @@ d_machine_entity_from_machine_id(CTRL_MachineID machine_id) return result; } -internal D_Entity * +internal DF_Entity * d_entity_from_ctrl_handle(CTRL_Handle handle) { - D_Entity *result = &d_nil_entity; + DF_Entity *result = &d_nil_entity; if(handle.machine_id != 0 || handle.dmn_handle.u64[0] != 0) { - for(D_Entity *e = d_entity_root(); + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, &d_nil_entity).next) { @@ -1278,13 +1278,13 @@ d_entity_from_ctrl_handle(CTRL_Handle handle) return result; } -internal D_Entity * +internal DF_Entity * d_entity_from_ctrl_id(CTRL_MachineID machine_id, U32 id) { - D_Entity *result = &d_nil_entity; + DF_Entity *result = &d_nil_entity; if(id != 0) { - for(D_Entity *e = d_entity_root(); + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, &d_nil_entity).next) { @@ -1301,10 +1301,10 @@ d_entity_from_ctrl_id(CTRL_MachineID machine_id, U32 id) return result; } -internal D_Entity * +internal DF_Entity * d_entity_from_name_and_kind(String8 string, D_EntityKind kind) { - D_Entity *result = &d_nil_entity; + DF_Entity *result = &d_nil_entity; D_EntityList all_of_this_kind = d_query_cached_entity_list_with_kind(kind); for(D_EntityNode *n = all_of_this_kind.first; n != 0; n = n->next) { @@ -2354,19 +2354,19 @@ d_eval_space_from_ctrl_entity(CTRL_Entity *entity) //- rjf: entity <-> eval space -internal D_Entity * +internal DF_Entity * d_entity_from_eval_space(E_Space space) { - D_Entity *entity = &d_nil_entity; + DF_Entity *entity = &d_nil_entity; if(space.u64_0 != 0) { - entity = (D_Entity *)space.u64_0; + entity = (DF_Entity *)space.u64_0; } return entity; } internal E_Space -d_eval_space_from_entity(D_Entity *entity) +d_eval_space_from_entity(DF_Entity *entity) { E_Space space = {0}; space.u64_0 = (U64)entity; @@ -2396,7 +2396,7 @@ d_eval_space_read(void *u, E_Space space, void *out, Rng1U64 range) } #if 0 // TODO(rjf): @msgs - D_Entity *entity = d_entity_from_eval_space(space); + DF_Entity *entity = d_entity_from_eval_space(space); switch(entity->kind) { //- rjf: nil-space -> fall back to file system @@ -2483,7 +2483,7 @@ d_eval_space_write(void *u, E_Space space, void *in, Rng1U64 range) { B32 result = 0; #if 0 // TODO(rjf): @msgs - D_Entity *entity = d_entity_from_eval_space(space); + DF_Entity *entity = d_entity_from_eval_space(space); switch(entity->kind) { //- rjf: default -> making commits to entity evaluation @@ -2510,7 +2510,7 @@ d_eval_space_write(void *u, E_Space space, void *in, Rng1U64 range) range_dim >= 1) { result = 1; - D_Entity *condition = d_entity_child_from_kind(entity, D_EntityKind_Condition); + DF_Entity *condition = d_entity_child_from_kind(entity, D_EntityKind_Condition); if(d_entity_is_nil(condition)) { condition = d_entity_alloc(entity, D_EntityKind_Condition); @@ -2558,7 +2558,7 @@ internal U128 d_key_from_eval_space_range(E_Space space, Rng1U64 range, B32 zero_terminated) { U128 result = {0}; - D_Entity *entity = d_entity_from_eval_space(space); + DF_Entity *entity = d_entity_from_eval_space(space); switch(entity->kind) { default:{}break; @@ -2586,7 +2586,7 @@ d_whole_range_from_eval_space(E_Space space) // TODO(rjf): @msgs Rng1U64 result = r1u64(0, 0); #if 0 - D_Entity *entity = d_entity_from_eval_space(space); + DF_Entity *entity = d_entity_from_eval_space(space); switch(entity->kind) { default:{}break; @@ -2808,10 +2808,10 @@ d_tex2dformat_from_eval_params(E_Eval eval, MD_Node *params) //- rjf: eval -> entity -internal D_Entity * +internal DF_Entity * d_entity_from_eval_string(String8 string) { - D_Entity *entity = &d_nil_entity; + DF_Entity *entity = &d_nil_entity; { Temp scratch = scratch_begin(0, 0); E_Eval eval = e_eval_from_string(scratch.arena, string); @@ -2822,7 +2822,7 @@ d_entity_from_eval_string(String8 string) } internal String8 -d_eval_string_from_entity(Arena *arena, D_Entity *entity) +d_eval_string_from_entity(Arena *arena, DF_Entity *entity) { String8 eval_string = push_str8f(arena, "macro:`$%I64u`", entity->id); return eval_string; @@ -2976,7 +2976,7 @@ d_cfg_strings_from_core(Arena *arena, String8 root_path, D_CfgSrc source) D_EntityList entities = d_query_cached_entity_list_with_kind(k); for(D_EntityNode *n = entities.first; n != 0; n = n->next) { - D_Entity *entity = n->entity; + DF_Entity *entity = n->entity; if(entity->cfg_src != source) { continue; @@ -2992,7 +2992,7 @@ d_cfg_strings_from_core(Arena *arena, String8 root_path, D_CfgSrc source) } D_EntityRec rec = {0}; S64 depth = 0; - for(D_Entity *e = entity; !d_entity_is_nil(e); e = rec.next) + for(DF_Entity *e = entity; !d_entity_is_nil(e); e = rec.next) { //- rjf: get next iteration rec = d_entity_rec_depth_first_pre(e, entity); @@ -3186,14 +3186,14 @@ d_push_active_target_list(Arena *arena) //- rjf: expand key based entity queries -internal D_Entity * +internal DF_Entity * d_entity_from_ev_key_and_kind(EV_Key key, D_EntityKind kind) { - D_Entity *result = &d_nil_entity; + DF_Entity *result = &d_nil_entity; D_EntityList list = d_query_cached_entity_list_with_kind(kind); for(D_EntityNode *n = list.first; n != 0; n = n->next) { - D_Entity *entity = n->entity; + DF_Entity *entity = n->entity; if(ev_key_match(d_ev_key_from_entity(entity), key)) { result = entity; @@ -3494,7 +3494,7 @@ d_init(void) d_state->output_log_key = hs_hash_from_data(str8_lit("df_output_log_key")); d_state->entities_arena = arena_alloc(.reserve_size = GB(64), .commit_size = KB(64)); d_state->entities_root = &d_nil_entity; - d_state->entities_base = push_array(d_state->entities_arena, D_Entity, 0); + d_state->entities_base = push_array(d_state->entities_arena, DF_Entity, 0); d_state->entities_count = 0; d_state->ctrl_entity_store = ctrl_entity_store_alloc(); d_state->ctrl_stop_arena = arena_alloc(); @@ -3514,7 +3514,7 @@ d_init(void) // rjf: set up initial entities { - D_Entity *local_machine = d_entity_alloc(d_state->entities_root, D_EntityKind_Machine); + DF_Entity *local_machine = d_entity_alloc(d_state->entities_root, D_EntityKind_Machine); d_entity_equip_ctrl_handle(local_machine, ctrl_handle_make(CTRL_MachineID_Local, dmn_handle_zero())); d_entity_equip_name(local_machine, str8_lit("This PC")); } @@ -3609,10 +3609,10 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) // rjf: kill all entities which are marked to die on stop { - D_Entity *request = d_entity_from_id(event->msg_id); + DF_Entity *request = d_entity_from_id(event->msg_id); if(d_entity_is_nil(request)) { - for(D_Entity *entity = d_entity_root(); + for(DF_Entity *entity = d_entity_root(); !d_entity_is_nil(entity); entity = d_entity_rec_depth_first_pre(entity, d_entity_root()).next) { @@ -3645,69 +3645,10 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) result.count += 1; D_Event *evt = &n->v; evt->kind = D_EventKind_Stop; - evt->cause = cause; - evt->vaddr = event->rip_vaddr; + evt->cause = cause; + evt->thread = event->entity; + evt->vaddr = event->rip_vaddr; } - -#if 0 // TODO(rjf): @msgs - D_Entity *stop_thread = d_entity_from_ctrl_handle(event->entity); - // rjf: select & snap to thread causing stop - if(should_snap && stop_thread->kind == D_EntityKind_Thread) - { - log_infof("stop_thread: \"%S\"\n", d_display_string_from_entity(scratch.arena, stop_thread)); - d_cmd(D_CmdKind_SelectThread, .entity = d_handle_from_entity(stop_thread)); - } - - // rjf: if no stop-causing thread, and if selected thread, snap to selected - if(should_snap && d_entity_is_nil(stop_thread)) - { - D_Entity *selected_thread = d_entity_from_handle(d_regs()->thread); - if(!d_entity_is_nil(selected_thread)) - { - df_cmd(DF_CmdKind_FindThread, .thread = d_handle_from_entity(selected_thread)); - } - } - - // rjf: thread hit user breakpoint -> increment breakpoint hit count - if(should_snap && event->cause == CTRL_EventCause_UserBreakpoint) - { - U64 stop_thread_vaddr = ctrl_query_cached_rip_from_thread(d_state->ctrl_entity_store, stop_thread->ctrl_handle); - D_Entity *process = d_entity_ancestor_from_kind(stop_thread, D_EntityKind_Process); - D_Entity *module = d_module_from_process_vaddr(process, stop_thread_vaddr); - DI_Key dbgi_key = d_dbgi_key_from_module(module); - U64 stop_thread_voff = d_voff_from_vaddr(module, stop_thread_vaddr); - D_EntityList user_bps = d_query_cached_entity_list_with_kind(D_EntityKind_Breakpoint); - for(D_EntityNode *n = user_bps.first; n != 0; n = n->next) - { - D_Entity *bp = n->entity; - D_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); - D_LineList loc_lines = d_lines_from_file_path_line_num(scratch.arena, loc->string, loc->text_point.line); - if(loc_lines.first != 0) - { - for(D_LineNode *n = loc_lines.first; n != 0; n = n->next) - { - if(contains_1u64(n->v.voff_range, stop_thread_voff)) - { - bp->u64 += 1; - break; - } - } - } - else if(loc->flags & D_EntityFlag_HasVAddr && stop_thread_vaddr == loc->vaddr) - { - bp->u64 += 1; - } - else if(loc->string.size != 0) - { - U64 symb_voff = d_voff_from_dbgi_key_symbol_name(&dbgi_key, loc->string); - if(symb_voff == stop_thread_voff) - { - bp->u64 += 1; - } - } - } - } -#endif }break; //- rjf: entity creation/deletion @@ -3728,8 +3669,8 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) } // rjf: create entity - D_Entity *machine = d_machine_entity_from_machine_id(event->entity.machine_id); - D_Entity *entity = d_entity_alloc(machine, D_EntityKind_Process); + DF_Entity *machine = d_machine_entity_from_machine_id(event->entity.machine_id); + DF_Entity *entity = d_entity_alloc(machine, D_EntityKind_Process); d_entity_equip_u64(entity, event->msg_id); d_entity_equip_ctrl_handle(entity, event->entity); d_entity_equip_ctrl_id(entity, event->entity_id); @@ -3739,8 +3680,8 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) case CTRL_EventKind_NewThread: { // rjf: create entity - D_Entity *parent = d_entity_from_ctrl_handle(event->parent); - D_Entity *entity = d_entity_alloc(parent, D_EntityKind_Thread); + DF_Entity *parent = d_entity_from_ctrl_handle(event->parent); + DF_Entity *entity = d_entity_alloc(parent, D_EntityKind_Thread); d_entity_equip_ctrl_handle(entity, event->entity); d_entity_equip_arch(entity, event->arch); d_entity_equip_ctrl_id(entity, event->entity_id); @@ -3756,7 +3697,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) D_EntityList pending_thread_names = d_query_cached_entity_list_with_kind(D_EntityKind_PendingThreadName); for(D_EntityNode *n = pending_thread_names.first; n != 0; n = n->next) { - D_Entity *pending_thread_name = n->entity; + DF_Entity *pending_thread_name = n->entity; if(event->entity.machine_id == pending_thread_name->ctrl_handle.machine_id && event->entity_id == pending_thread_name->ctrl_id) { d_entity_mark_for_deletion(pending_thread_name); @@ -3768,7 +3709,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) // rjf: determine index in process U64 thread_idx_in_process = 0; - for(D_Entity *child = parent->first; !d_entity_is_nil(child); child = child->next) + for(DF_Entity *child = parent->first; !d_entity_is_nil(child); child = child->next) { if(child == entity) { @@ -3798,29 +3739,12 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) // rjf: equip color d_entity_equip_color_rgba(entity, thread_color); - -#if 0 // TODO(rjf): @msgs - // rjf: automatically select if we don't have a selected thread - D_Entity *selected_thread = d_entity_from_handle(d_state->base_regs.v.thread); - if(d_entity_is_nil(selected_thread)) - { - d_state->base_regs.v.thread = d_handle_from_entity(entity); - } - - // rjf: do initial snap - D_EntityList already_existing_processes = d_query_cached_entity_list_with_kind(D_EntityKind_Process); - B32 do_initial_snap = (already_existing_processes.count == 1 && thread_idx_in_process == 0); - if(do_initial_snap) - { - d_cmd(D_CmdKind_SelectThread, .entity = d_handle_from_entity(entity)); - } -#endif }break; case CTRL_EventKind_NewModule: { // rjf: grab process - D_Entity *parent = d_entity_from_ctrl_handle(event->parent); + DF_Entity *parent = d_entity_from_ctrl_handle(event->parent); // rjf: determine if this is the first module B32 is_first = 0; @@ -3830,7 +3754,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) } // rjf: create module entity - D_Entity *module = d_entity_alloc(parent, D_EntityKind_Module); + DF_Entity *module = d_entity_alloc(parent, D_EntityKind_Module); d_entity_equip_ctrl_handle(module, event->entity); d_entity_equip_arch(module, event->arch); d_entity_equip_name(module, event->string); @@ -3844,15 +3768,15 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) D_EntityList targets = d_query_cached_entity_list_with_kind(D_EntityKind_Target); for(D_EntityNode *n = targets.first; n != 0; n = n->next) { - D_Entity *target = n->entity; - D_Entity *exe = d_entity_child_from_kind(target, D_EntityKind_Executable); + DF_Entity *target = n->entity; + DF_Entity *exe = d_entity_child_from_kind(target, D_EntityKind_Executable); String8 exe_name = exe->string; String8 exe_name_normalized = path_normalized_from_string(scratch.arena, exe_name); String8 module_name_normalized = path_normalized_from_string(scratch.arena, module->string); if(str8_match(exe_name_normalized, module_name_normalized, StringMatchFlag_CaseInsensitive) && target->flags & D_EntityFlag_HasColor) { - D_Entity *first_thread = d_entity_child_from_kind(parent, D_EntityKind_Thread); + DF_Entity *first_thread = d_entity_child_from_kind(parent, D_EntityKind_Thread); Vec4F32 rgba = d_rgba_from_entity(target); d_entity_equip_color_rgba(parent, rgba); d_entity_equip_color_rgba(first_thread, rgba); @@ -3866,19 +3790,19 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) case CTRL_EventKind_EndProc: { U32 pid = event->entity_id; - D_Entity *process = d_entity_from_ctrl_handle(event->entity); + DF_Entity *process = d_entity_from_ctrl_handle(event->entity); d_entity_mark_for_deletion(process); }break; case CTRL_EventKind_EndThread: { - D_Entity *thread = d_entity_from_ctrl_handle(event->entity); + DF_Entity *thread = d_entity_from_ctrl_handle(event->entity); d_entity_mark_for_deletion(thread); }break; case CTRL_EventKind_EndModule: { - D_Entity *module = d_entity_from_ctrl_handle(event->entity); + DF_Entity *module = d_entity_from_ctrl_handle(event->entity); d_entity_mark_for_deletion(module); }break; @@ -3886,8 +3810,8 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) case CTRL_EventKind_ModuleDebugInfoPathChange: { - D_Entity *module = d_entity_from_ctrl_handle(event->entity); - D_Entity *debug_info = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); + DF_Entity *module = d_entity_from_ctrl_handle(event->entity); + DF_Entity *debug_info = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); if(d_entity_is_nil(debug_info)) { debug_info = d_entity_alloc(module, D_EntityKind_DebugInfoPath); @@ -3907,14 +3831,14 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) case CTRL_EventKind_ThreadName: { String8 string = event->string; - D_Entity *entity = d_entity_from_ctrl_handle(event->entity); + DF_Entity *entity = d_entity_from_ctrl_handle(event->entity); if(event->entity_id != 0) { entity = d_entity_from_ctrl_id(event->entity.machine_id, event->entity_id); } if(d_entity_is_nil(entity)) { - D_Entity *process = d_entity_from_ctrl_handle(event->parent); + DF_Entity *process = d_entity_from_ctrl_handle(event->parent); if(!d_entity_is_nil(process)) { entity = d_entity_alloc(process, D_EntityKind_PendingThreadName); @@ -4024,7 +3948,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) // ProfScope("eliminate deleted entities") { - for(D_Entity *entity = d_entity_root(), *next = 0; !d_entity_is_nil(entity); entity = next) + for(DF_Entity *entity = d_entity_root(), *next = 0; !d_entity_is_nil(entity); entity = next) { next = d_entity_rec_depth_first_pre(entity, &d_nil_entity).next; if(entity->flags & D_EntityFlag_MarkedForDeletion) @@ -4032,7 +3956,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) B32 undoable = (d_entity_kind_flags_table[entity->kind] & D_EntityKindFlag_UserDefinedLifetime); // rjf: fixup next entity to iterate to - next = d_entity_rec_depth_first(entity, &d_nil_entity, OffsetOf(D_Entity, next), OffsetOf(D_Entity, next)).next; + next = d_entity_rec_depth_first(entity, &d_nil_entity, OffsetOf(DF_Entity, next), OffsetOf(DF_Entity, next)).next; // rjf: eliminate root entity if we're freeing it if(entity == d_state->entities_root) @@ -4079,12 +4003,12 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) default:{}break; case DI_EventKind_ConversionStarted: { - D_Entity *task = d_entity_alloc(d_entity_root(), D_EntityKind_ConversionTask); + DF_Entity *task = d_entity_alloc(d_entity_root(), D_EntityKind_ConversionTask); d_entity_equip_name(task, event->string); }break; case DI_EventKind_ConversionEnded: { - D_Entity *task = d_entity_from_name_and_kind(event->string, D_EntityKind_ConversionTask); + DF_Entity *task = d_entity_from_name_and_kind(event->string, D_EntityKind_ConversionTask); if(!d_entity_is_nil(task)) { d_entity_mark_for_deletion(task); @@ -4208,65 +4132,6 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) run_kind = D_RunKind_Run; run_thread = &ctrl_entity_nil; run_flags = (cmd->kind == D_CmdKind_LaunchAndInit) ? CTRL_RunFlag_StopOnEntryPoint : 0; - -#if 0 // TODO(rjf): @msgs - for(D_EntityNode *n = targets.first; n != 0; n = n->next) - { - // rjf: extract data from target - D_Entity *target = n->entity; - String8 name = d_entity_child_from_kind(target, D_EntityKind_Executable)->string; - String8 args = d_entity_child_from_kind(target, D_EntityKind_Arguments)->string; - String8 path = d_entity_child_from_kind(target, D_EntityKind_WorkingDirectory)->string; - String8 entry= d_entity_child_from_kind(target, D_EntityKind_EntryPoint)->string; - name = str8_skip_chop_whitespace(name); - args = str8_skip_chop_whitespace(args); - path = str8_skip_chop_whitespace(path); - entry = str8_skip_chop_whitespace(entry); - if(path.size == 0) - { - path = os_get_current_path(scratch.arena); - } - - // rjf: build launch options - String8List cmdln_strings = {0}; - { - str8_list_push(scratch.arena, &cmdln_strings, name); - { - U64 start_split_idx = 0; - B32 quoted = 0; - for(U64 idx = 0; idx <= args.size; idx += 1) - { - U8 byte = idx < args.size ? args.str[idx] : 0; - if(byte == '"') - { - quoted ^= 1; - } - B32 splitter_found = (!quoted && (byte == 0 || char_is_space(byte))); - if(splitter_found) - { - String8 string = str8_substr(args, r1u64(start_split_idx, idx)); - if(string.size > 0) - { - str8_list_push(scratch.arena, &cmdln_strings, string); - } - start_split_idx = idx+1; - } - } - } - } - - // rjf: push message to launch - { - CTRL_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); - msg->kind = CTRL_MsgKind_Launch; - msg->path = path; - msg->cmd_line_string_list = cmdln_strings; - msg->env_inherit = 1; - MemoryCopyArray(msg->exception_code_filters, d_state->ctrl_exception_code_filters); - str8_list_push(scratch.arena, &msg->entry_points, entry); - } - } -#endif } // rjf: no targets -> error @@ -4462,20 +4327,20 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) { String8 file_path = params->file_path; TxtPt point = params->cursor; - D_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); + DF_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); d_entity_equip_cfg_src(bp, D_CfgSrc_Transient); bp->flags |= D_EntityFlag_DiesOnRunStop; - D_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); + DF_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); d_entity_equip_name(loc, file_path); d_entity_equip_txt_pt(loc, point); d_cmd(D_CmdKind_Run); }break; case D_CmdKind_RunToAddress: { - D_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); + DF_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); d_entity_equip_cfg_src(bp, D_CfgSrc_Transient); bp->flags |= D_EntityFlag_DiesOnRunStop; - D_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); + DF_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); d_entity_equip_vaddr(loc, params->vaddr); d_cmd(D_CmdKind_Run); }break; @@ -4503,8 +4368,8 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints) D_EntityList processes = d_query_cached_entity_list_with_kind(D_EntityKind_Process); for(D_EntityNode *n = processes.first; n != 0; n = n->next) { - D_Entity *process = n->entity; - D_Entity *target = d_entity_from_handle(process->entity_handle); + DF_Entity *process = n->entity; + DF_Entity *target = d_entity_from_handle(process->entity_handle); if(!d_entity_is_nil(target)) { d_entity_list_push(scratch.arena, &targets, target); diff --git a/src/dbg_engine/dbg_engine_core.h b/src/dbg_engine/dbg_engine_core.h index 7e70dbec..d64d7f32 100644 --- a/src/dbg_engine/dbg_engine_core.h +++ b/src/dbg_engine/dbg_engine_core.h @@ -305,15 +305,15 @@ enum typedef U64 D_EntityID; -typedef struct D_Entity D_Entity; -struct D_Entity +typedef struct DF_Entity DF_Entity; +struct DF_Entity { // rjf: tree links - D_Entity *first; - D_Entity *last; - D_Entity *next; - D_Entity *prev; - D_Entity *parent; + DF_Entity *first; + DF_Entity *last; + DF_Entity *next; + DF_Entity *prev; + DF_Entity *parent; // rjf: metadata D_EntityKind kind; @@ -352,7 +352,7 @@ typedef struct D_EntityNode D_EntityNode; struct D_EntityNode { D_EntityNode *next; - D_Entity *entity; + DF_Entity *entity; }; typedef struct D_EntityList D_EntityList; @@ -366,14 +366,14 @@ struct D_EntityList typedef struct D_EntityArray D_EntityArray; struct D_EntityArray { - D_Entity **v; + DF_Entity **v; U64 count; }; typedef struct D_EntityRec D_EntityRec; struct D_EntityRec { - D_Entity *next; + DF_Entity *next; S32 push_count; S32 pop_count; }; @@ -397,7 +397,7 @@ struct D_EntityEval typedef struct D_EntityFuzzyItem D_EntityFuzzyItem; struct D_EntityFuzzyItem { - D_Entity *entity; + DF_Entity *entity; FuzzyMatchRangeList matches; }; @@ -711,11 +711,11 @@ struct D_State // rjf: entity state Arena *entities_arena; - D_Entity *entities_base; + DF_Entity *entities_base; U64 entities_count; U64 entities_id_gen; - D_Entity *entities_root; - D_Entity *entities_free[2]; // [0] -> normal lifetime, not user defined; [1] -> user defined lifetime (& thus undoable) + DF_Entity *entities_root; + DF_Entity *entities_free[2]; // [0] -> normal lifetime, not user defined; [1] -> user defined lifetime (& thus undoable) U64 entities_free_count; U64 entities_active_count; @@ -766,7 +766,7 @@ struct D_State read_only global D_ViewRuleSpec d_nil_core_view_rule_spec = {0}; read_only global D_CfgTree d_nil_cfg_tree = {&d_nil_cfg_tree, D_CfgSrc_User, &md_nil_node}; read_only global D_CfgVal d_nil_cfg_val = {&d_nil_cfg_val, &d_nil_cfg_val, &d_nil_cfg_tree, &d_nil_cfg_tree}; -read_only global D_Entity d_nil_entity = +read_only global DF_Entity d_nil_entity = { &d_nil_entity, &d_nil_entity, @@ -819,29 +819,29 @@ internal void d_cmd_list_push_new(Arena *arena, D_CmdList *cmds, D_CmdKind kind, //~ rjf: Entity Type Pure Functions //- rjf: nil -internal B32 d_entity_is_nil(D_Entity *entity); +internal B32 d_entity_is_nil(DF_Entity *entity); #define d_require_entity_nonnil(entity, if_nil_stmts) do{if(d_entity_is_nil(entity)){if_nil_stmts;}}while(0) //- rjf: handle <-> entity conversions -internal U64 d_index_from_entity(D_Entity *entity); -internal D_Handle d_handle_from_entity(D_Entity *entity); -internal D_Entity *d_entity_from_handle(D_Handle handle); +internal U64 d_index_from_entity(DF_Entity *entity); +internal D_Handle d_handle_from_entity(DF_Entity *entity); +internal DF_Entity *d_entity_from_handle(D_Handle handle); internal D_EntityList d_entity_list_from_handle_list(Arena *arena, D_HandleList handles); internal D_HandleList d_handle_list_from_entity_list(Arena *arena, D_EntityList entities); //- rjf: entity recursion iterators -internal D_EntityRec d_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off); -#define d_entity_rec_depth_first_pre(entity, subtree_root) d_entity_rec_depth_first((entity), (subtree_root), OffsetOf(D_Entity, next), OffsetOf(D_Entity, first)) -#define d_entity_rec_depth_first_post(entity, subtree_root) d_entity_rec_depth_first((entity), (subtree_root), OffsetOf(D_Entity, prev), OffsetOf(D_Entity, last)) +internal D_EntityRec d_entity_rec_depth_first(DF_Entity *entity, DF_Entity *subtree_root, U64 sib_off, U64 child_off); +#define d_entity_rec_depth_first_pre(entity, subtree_root) d_entity_rec_depth_first((entity), (subtree_root), OffsetOf(DF_Entity, next), OffsetOf(DF_Entity, first)) +#define d_entity_rec_depth_first_post(entity, subtree_root) d_entity_rec_depth_first((entity), (subtree_root), OffsetOf(DF_Entity, prev), OffsetOf(DF_Entity, last)) //- rjf: ancestor/child introspection -internal D_Entity *d_entity_child_from_kind(D_Entity *entity, D_EntityKind kind); -internal D_Entity *d_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind); -internal D_EntityList d_push_entity_child_list_with_kind(Arena *arena, D_Entity *entity, D_EntityKind kind); -internal D_Entity *d_entity_child_from_string_and_kind(D_Entity *parent, String8 string, D_EntityKind kind); +internal DF_Entity *d_entity_child_from_kind(DF_Entity *entity, D_EntityKind kind); +internal DF_Entity *d_entity_ancestor_from_kind(DF_Entity *entity, D_EntityKind kind); +internal D_EntityList d_push_entity_child_list_with_kind(Arena *arena, DF_Entity *entity, D_EntityKind kind); +internal DF_Entity *d_entity_child_from_string_and_kind(DF_Entity *parent, String8 string, D_EntityKind kind); //- rjf: entity list building -internal void d_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity); +internal void d_entity_list_push(Arena *arena, D_EntityList *list, DF_Entity *entity); internal D_EntityArray d_entity_array_from_list(Arena *arena, D_EntityList *list); #define d_first_entity_from_list(list) ((list)->first != 0 ? (list)->first->entity : &d_nil_entity) @@ -850,24 +850,24 @@ internal D_EntityFuzzyItemArray d_entity_fuzzy_item_array_from_entity_list_needl internal D_EntityFuzzyItemArray d_entity_fuzzy_item_array_from_entity_array_needle(Arena *arena, D_EntityArray *array, String8 needle); //- rjf: full path building, from file/folder entities -internal String8 d_full_path_from_entity(Arena *arena, D_Entity *entity); +internal String8 d_full_path_from_entity(Arena *arena, DF_Entity *entity); //- rjf: display string entities, for referencing entities in ui -internal String8 d_display_string_from_entity(Arena *arena, D_Entity *entity); +internal String8 d_display_string_from_entity(Arena *arena, DF_Entity *entity); //- rjf: extra search tag strings for fuzzy filtering entities -internal String8 d_search_tags_from_entity(Arena *arena, D_Entity *entity); +internal String8 d_search_tags_from_entity(Arena *arena, DF_Entity *entity); //- rjf: entity -> color operations -internal Vec4F32 d_hsva_from_entity(D_Entity *entity); -internal Vec4F32 d_rgba_from_entity(D_Entity *entity); +internal Vec4F32 d_hsva_from_entity(DF_Entity *entity); +internal Vec4F32 d_rgba_from_entity(DF_Entity *entity); //- rjf: entity -> expansion tree keys -internal EV_Key d_ev_key_from_entity(D_Entity *entity); -internal EV_Key d_parent_ev_key_from_entity(D_Entity *entity); +internal EV_Key d_ev_key_from_entity(DF_Entity *entity); +internal EV_Key d_parent_ev_key_from_entity(DF_Entity *entity); //- rjf: entity -> evaluation -internal D_EntityEval *d_eval_from_entity(Arena *arena, D_Entity *entity); +internal D_EntityEval *d_eval_from_entity(Arena *arena, DF_Entity *entity); //////////////////////////////// //~ rjf: Name Allocation @@ -880,44 +880,44 @@ internal void d_name_release(String8 string); //~ rjf: Entity Stateful Functions //- rjf: entity allocation + tree forming -internal D_Entity *d_entity_alloc(D_Entity *parent, D_EntityKind kind); -internal void d_entity_mark_for_deletion(D_Entity *entity); -internal void d_entity_release(D_Entity *entity); -internal void d_entity_change_parent(D_Entity *entity, D_Entity *old_parent, D_Entity *new_parent, D_Entity *prev_child); +internal DF_Entity *d_entity_alloc(DF_Entity *parent, D_EntityKind kind); +internal void d_entity_mark_for_deletion(DF_Entity *entity); +internal void d_entity_release(DF_Entity *entity); +internal void d_entity_change_parent(DF_Entity *entity, DF_Entity *old_parent, DF_Entity *new_parent, DF_Entity *prev_child); //- rjf: entity simple equipment -internal void d_entity_equip_txt_pt(D_Entity *entity, TxtPt point); -internal void d_entity_equip_entity_handle(D_Entity *entity, D_Handle handle); -internal void d_entity_equip_disabled(D_Entity *entity, B32 b32); -internal void d_entity_equip_u64(D_Entity *entity, U64 u64); -internal void d_entity_equip_color_rgba(D_Entity *entity, Vec4F32 rgba); -internal void d_entity_equip_color_hsva(D_Entity *entity, Vec4F32 hsva); -internal void d_entity_equip_cfg_src(D_Entity *entity, D_CfgSrc cfg_src); -internal void d_entity_equip_timestamp(D_Entity *entity, U64 timestamp); +internal void d_entity_equip_txt_pt(DF_Entity *entity, TxtPt point); +internal void d_entity_equip_entity_handle(DF_Entity *entity, D_Handle handle); +internal void d_entity_equip_disabled(DF_Entity *entity, B32 b32); +internal void d_entity_equip_u64(DF_Entity *entity, U64 u64); +internal void d_entity_equip_color_rgba(DF_Entity *entity, Vec4F32 rgba); +internal void d_entity_equip_color_hsva(DF_Entity *entity, Vec4F32 hsva); +internal void d_entity_equip_cfg_src(DF_Entity *entity, D_CfgSrc cfg_src); +internal void d_entity_equip_timestamp(DF_Entity *entity, U64 timestamp); //- rjf: control layer correllation equipment -internal void d_entity_equip_ctrl_handle(D_Entity *entity, CTRL_Handle handle); -internal void d_entity_equip_arch(D_Entity *entity, Arch arch); -internal void d_entity_equip_ctrl_id(D_Entity *entity, U32 id); -internal void d_entity_equip_stack_base(D_Entity *entity, U64 stack_base); -internal void d_entity_equip_vaddr_rng(D_Entity *entity, Rng1U64 range); -internal void d_entity_equip_vaddr(D_Entity *entity, U64 vaddr); +internal void d_entity_equip_ctrl_handle(DF_Entity *entity, CTRL_Handle handle); +internal void d_entity_equip_arch(DF_Entity *entity, Arch arch); +internal void d_entity_equip_ctrl_id(DF_Entity *entity, U32 id); +internal void d_entity_equip_stack_base(DF_Entity *entity, U64 stack_base); +internal void d_entity_equip_vaddr_rng(DF_Entity *entity, Rng1U64 range); +internal void d_entity_equip_vaddr(DF_Entity *entity, U64 vaddr); //- rjf: name equipment -internal void d_entity_equip_name(D_Entity *entity, String8 name); -internal void d_entity_equip_namef(D_Entity *entity, char *fmt, ...); +internal void d_entity_equip_name(DF_Entity *entity, String8 name); +internal void d_entity_equip_namef(DF_Entity *entity, char *fmt, ...); //- rjf: file path map override lookups internal String8List d_possible_overrides_from_file_path(Arena *arena, String8 file_path); //- rjf: top-level state queries -internal D_Entity *d_entity_root(void); +internal DF_Entity *d_entity_root(void); internal D_EntityList d_push_entity_list_with_kind(Arena *arena, D_EntityKind kind); -internal D_Entity *d_entity_from_id(D_EntityID id); -internal D_Entity *d_machine_entity_from_machine_id(CTRL_MachineID machine_id); -internal D_Entity *d_entity_from_ctrl_handle(CTRL_Handle handle); -internal D_Entity *d_entity_from_ctrl_id(CTRL_MachineID machine_id, U32 id); -internal D_Entity *d_entity_from_name_and_kind(String8 string, D_EntityKind kind); +internal DF_Entity *d_entity_from_id(D_EntityID id); +internal DF_Entity *d_machine_entity_from_machine_id(CTRL_MachineID machine_id); +internal DF_Entity *d_entity_from_ctrl_handle(CTRL_Handle handle); +internal DF_Entity *d_entity_from_ctrl_id(CTRL_MachineID machine_id, U32 id); +internal DF_Entity *d_entity_from_name_and_kind(String8 string, D_EntityKind kind); //////////////////////////////// //~ rjf: View Rule Spec Stateful Functions @@ -972,8 +972,8 @@ internal CTRL_Entity *d_ctrl_entity_from_eval_space(E_Space space); internal E_Space d_eval_space_from_ctrl_entity(CTRL_Entity *entity); //- rjf: entity <-> eval space -internal D_Entity *d_entity_from_eval_space(E_Space space); -internal E_Space d_eval_space_from_entity(D_Entity *entity); +internal DF_Entity *d_entity_from_eval_space(E_Space space); +internal E_Space d_eval_space_from_entity(DF_Entity *entity); //- rjf: eval space reads/writes internal B32 d_eval_space_read(void *u, E_Space space, void *out, Rng1U64 range); @@ -1001,8 +1001,8 @@ internal Vec2S32 d_dim2s32_from_eval_params(E_Eval eval, MD_Node *params); internal R_Tex2DFormat d_tex2dformat_from_eval_params(E_Eval eval, MD_Node *params); //- rjf: eval <-> entity -internal D_Entity *d_entity_from_eval_string(String8 string); -internal String8 d_eval_string_from_entity(Arena *arena, D_Entity *entity); +internal DF_Entity *d_entity_from_eval_string(String8 string); +internal String8 d_eval_string_from_entity(Arena *arena, DF_Entity *entity); //- rjf: eval <-> file path internal String8 d_file_path_from_eval_string(Arena *arena, String8 string); @@ -1033,7 +1033,7 @@ internal DI_KeyList d_push_active_dbgi_key_list(Arena *arena); internal D_EntityList d_push_active_target_list(Arena *arena); //- rjf: expand key based entity queries -internal D_Entity *d_entity_from_ev_key_and_kind(EV_Key key, D_EntityKind kind); +internal DF_Entity *d_entity_from_ev_key_and_kind(EV_Key key, D_EntityKind kind); //- rjf: per-run caches internal CTRL_Unwind d_query_cached_unwind_from_thread(CTRL_Entity *thread); diff --git a/src/dbg_frontend/dbg_frontend_core.c b/src/dbg_frontend/dbg_frontend_core.c index f0961193..d17e524e 100644 --- a/src/dbg_frontend/dbg_frontend_core.c +++ b/src/dbg_frontend/dbg_frontend_core.c @@ -1109,7 +1109,7 @@ df_window_frame(DF_Window *ws) !df_view_is_nil(view); view = view->order_next) { - D_Entity *entity = d_entity_from_eval_string(str8(view->query_buffer, view->query_string_size)); + DF_Entity *entity = d_entity_from_eval_string(str8(view->query_buffer, view->query_string_size)); if(entity->flags & D_EntityFlag_MarkedForDeletion || (d_entity_is_nil(entity) && view->spec->info.flags & DF_ViewSpecFlag_ParameterizedByEntity)) { @@ -1370,7 +1370,7 @@ df_window_frame(DF_Window *ws) Temp scratch = scratch_begin(0, 0); DF_DragDropPayload *payload = &df_drag_drop_payload; DF_Panel *panel = df_panel_from_handle(payload->panel); - D_Entity *entity = d_entity_from_handle(payload->entity); + DF_Entity *entity = d_entity_from_handle(payload->entity); DF_View *view = df_view_from_handle(payload->view); { //- rjf: tab dragging @@ -1528,14 +1528,14 @@ df_window_frame(DF_Window *ws) D_EntityRec rec = {0}; S32 indent = 0; UI_PrefWidth(ui_text_dim(10, 1)) ui_labelf("Entity Tree:"); - for(D_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = rec.next) + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = rec.next) { ui_set_next_pref_width(ui_children_sum(1)); ui_set_next_pref_height(ui_children_sum(1)); UI_Row { ui_spacer(ui_em(2.f*indent, 1.f)); - D_Entity *dst = d_entity_from_handle(e->entity_handle); + DF_Entity *dst = d_entity_from_handle(e->entity_handle); if(!d_entity_is_nil(dst)) { ui_labelf("[link] %S -> %S", e->string, dst->string); @@ -1562,7 +1562,7 @@ df_window_frame(DF_Window *ws) //- rjf: auto-close entity ctx menu if(ui_ctx_menu_is_open(df_state->entity_ctx_menu_key)) { - D_Entity *entity = d_entity_from_handle(ws->entity_ctx_menu_entity); + DF_Entity *entity = d_entity_from_handle(ws->entity_ctx_menu_entity); if(d_entity_is_nil(entity)) { ui_ctx_menu_close(); @@ -1699,7 +1699,7 @@ df_window_frame(DF_Window *ws) UI_PrefWidth(ui_em(40.f, 1.f)) DF_Palette(DF_PaletteCode_ImplicitButton) { - D_Entity *entity = d_entity_from_handle(ws->entity_ctx_menu_entity); + DF_Entity *entity = d_entity_from_handle(ws->entity_ctx_menu_entity); CTRL_Entity *entity_ctrl = ctrl_entity_from_handle(d_state->ctrl_entity_store, entity->ctrl_handle); DF_IconKind entity_icon = df_entity_kind_icon_kind_table[entity->kind]; D_EntityKindFlags kind_flags = d_entity_kind_flags_table[entity->kind]; @@ -1751,7 +1751,7 @@ df_window_frame(DF_Window *ws) DF_Font(DF_FontSlot_Code) UI_TextPadding(ui_top_font_size()*1.5f) { - D_Entity *condition = d_entity_child_from_kind(entity, D_EntityKind_Condition); + DF_Entity *condition = d_entity_child_from_kind(entity, D_EntityKind_Condition); UI_Signal sig = df_line_editf(DF_LineEditFlag_Border|DF_LineEditFlag_CodeContents, 0, 0, &ws->entity_ctx_menu_input_cursor, &ws->entity_ctx_menu_input_mark, ws->entity_ctx_menu_input_buffer, sizeof(ws->entity_ctx_menu_input_buffer), &ws->entity_ctx_menu_input_size, 0, condition->string, "Condition###entity_cond_edit_%p", entity); if(ui_committed(sig)) { @@ -1774,7 +1774,7 @@ df_window_frame(DF_Window *ws) // rjf: exe editor if(entity->kind == D_EntityKind_Target) UI_TextPadding(ui_top_font_size()*1.5f) { - D_Entity *exe = d_entity_child_from_kind(entity, D_EntityKind_Executable); + DF_Entity *exe = d_entity_child_from_kind(entity, D_EntityKind_Executable); UI_Signal sig = df_line_editf(DF_LineEditFlag_Border, 0, 0, &ws->entity_ctx_menu_input_cursor, &ws->entity_ctx_menu_input_mark, ws->entity_ctx_menu_input_buffer, sizeof(ws->entity_ctx_menu_input_buffer), &ws->entity_ctx_menu_input_size, 0, exe->string, "Executable###entity_exe_edit_%p", entity); if(ui_committed(sig)) { @@ -1797,7 +1797,7 @@ df_window_frame(DF_Window *ws) // rjf: arguments editors if(entity->kind == D_EntityKind_Target) UI_TextPadding(ui_top_font_size()*1.5f) { - D_Entity *args = d_entity_child_from_kind(entity, D_EntityKind_Arguments); + DF_Entity *args = d_entity_child_from_kind(entity, D_EntityKind_Arguments); UI_Signal sig = df_line_editf(DF_LineEditFlag_Border, 0, 0, &ws->entity_ctx_menu_input_cursor, &ws->entity_ctx_menu_input_mark, ws->entity_ctx_menu_input_buffer, sizeof(ws->entity_ctx_menu_input_buffer), &ws->entity_ctx_menu_input_size, 0, args->string, "Arguments###entity_args_edit_%p", entity); if(ui_committed(sig)) { @@ -1882,7 +1882,7 @@ df_window_frame(DF_Window *ws) // rjf: go-to-location { - D_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); + DF_Entity *loc = d_entity_child_from_kind(entity, D_EntityKind_Location); if(!d_entity_is_nil(loc) && ui_clicked(df_icon_buttonf(DF_IconKind_FileOutline, 0, "Go To Location"))) { df_cmd(DF_CmdKind_FindCodeLocation, @@ -2853,7 +2853,7 @@ df_window_frame(DF_Window *ws) D_EntityList targets_list = d_query_cached_entity_list_with_kind(D_EntityKind_Target); for(D_EntityNode *n = targets_list.first; n != 0; n = n->next) { - D_Entity *target = n->entity; + DF_Entity *target = n->entity; UI_Palette *palette = ui_top_palette(); if(target->flags & D_EntityFlag_HasColor) { @@ -3058,7 +3058,7 @@ df_window_frame(DF_Window *ws) D_EntityList tasks = d_query_cached_entity_list_with_kind(D_EntityKind_ConversionTask); for(D_EntityNode *n = tasks.first; n != 0; n = n->next) { - D_Entity *task = n->entity; + DF_Entity *task = n->entity; if(task->alloc_time_us + 500000 < os_now_microseconds()) { String8 rdi_path = task->string; @@ -3154,8 +3154,8 @@ df_window_frame(DF_Window *ws) D_EntityList processes = d_query_cached_entity_list_with_kind(D_EntityKind_Process); for(D_EntityNode *n = processes.first; n != 0; n = n->next) { - D_Entity *process = n->entity; - D_Entity *target = d_entity_from_handle(process->entity_handle); + DF_Entity *process = n->entity; + DF_Entity *target = d_entity_from_handle(process->entity_handle); if(!d_entity_is_nil(target)) { String8 target_display_name = d_display_string_from_entity(scratch.arena, target); @@ -3891,7 +3891,7 @@ df_window_frame(DF_Window *ws) EV_Key parent_key = ev_key_make(5381, 1); EV_Key key = ev_key_make(ev_hash_from_key(parent_key), 1); EV_BlockList viz_blocks = ev_block_list_from_view_expr_keys(scratch.arena, ev_view, &top_level_view_rules, expr, parent_key, key); - D_Entity *entity = d_entity_from_eval_space(eval.space); + DF_Entity *entity = d_entity_from_eval_space(eval.space); U32 default_radix = (entity->kind == D_EntityKind_Thread ? 16 : 10); EV_WindowedRowList viz_rows = ev_windowed_row_list_from_block_list(scratch.arena, ev_view, r1s64(0, 50), &viz_blocks); @@ -3998,7 +3998,7 @@ df_window_frame(DF_Window *ws) default:{}break; case E_Mode_Offset: { - D_Entity *space_entity = d_entity_from_eval_space(row_eval.space); + DF_Entity *space_entity = d_entity_from_eval_space(row_eval.space); if(space_entity->kind == D_EntityKind_Process) { U64 size = e_type_byte_size_from_key(row_eval.type_key); @@ -5230,7 +5230,7 @@ df_window_frame(DF_Window *ws) { DF_Panel *src_panel = df_panel_from_handle(payload.panel); DF_View *view = df_view_from_handle(payload.view); - D_Entity *entity = d_entity_from_handle(payload.entity); + DF_Entity *entity = d_entity_from_handle(payload.entity); // rjf: view drop if(!df_view_is_nil(view)) @@ -7253,10 +7253,10 @@ df_stop_explanation_string_icon_from_ctrl_event(Arena *arena, CTRL_Event *event, DF_IconKind icon = DF_IconKind_Null; String8 explanation = {0}; Temp scratch = scratch_begin(&arena, 1); - D_Entity *thread = d_entity_from_ctrl_handle(event->entity); + DF_Entity *thread = d_entity_from_ctrl_handle(event->entity); String8 thread_display_string = d_display_string_from_entity(scratch.arena, thread); String8 process_thread_string = thread_display_string; - D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + DF_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); if(process->kind == D_EntityKind_Process) { String8 process_display_string = d_display_string_from_entity(scratch.arena, process); @@ -8154,7 +8154,7 @@ df_frame(void) D_EntityList entities = d_query_cached_entity_list_with_kind(evallable_kinds[idx]); for(D_EntityNode *n = entities.first; n != 0; n = n->next) { - D_Entity *entity = n->entity; + DF_Entity *entity = n->entity; E_Expr *expr = e_push_expr(scratch.arena, E_ExprKind_LeafOffset, 0); expr->space = d_eval_space_from_entity(entity); expr->mode = E_Mode_Offset; @@ -8172,7 +8172,7 @@ df_frame(void) D_EntityList watches = d_query_cached_entity_list_with_kind(D_EntityKind_Watch); for(D_EntityNode *n = watches.first; n != 0; n = n->next) { - D_Entity *watch = n->entity; + DF_Entity *watch = n->entity; String8 expr = watch->string; E_TokenArray tokens = e_token_array_from_text(scratch.arena, expr); E_Parse parse = e_parse_expr_from_text_tokens(scratch.arena, expr, &tokens); @@ -8432,7 +8432,7 @@ df_frame(void) //- rjf: config path saving/loading/applying case DF_CmdKind_OpenRecentProject: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); if(entity->kind == D_EntityKind_RecentProject) { df_cmd(DF_CmdKind_OpenProject, .file_path = entity->string); @@ -8608,7 +8608,7 @@ df_frame(void) if(src == D_CfgSrc_Project) { D_EntityList recent_projects = d_query_cached_entity_list_with_kind(D_EntityKind_RecentProject); - D_Entity *recent_project = &d_nil_entity; + DF_Entity *recent_project = &d_nil_entity; for(D_EntityNode *n = recent_projects.first; n != 0; n = n->next) { if(path_match_normalized(cfg_path, n->entity->string)) @@ -8660,7 +8660,7 @@ df_frame(void) { continue; } - D_Entity *entity = d_entity_alloc(d_entity_root(), k); + DF_Entity *entity = d_entity_alloc(d_entity_root(), k); d_entity_equip_cfg_src(entity, k_tree->source); // rjf: iterate config tree @@ -8668,7 +8668,7 @@ df_frame(void) struct Task { Task *next; - D_Entity *entity; + DF_Entity *entity; MD_Node *n; }; Task start_task = {0, entity, k_tree->root}; @@ -9761,7 +9761,7 @@ df_frame(void) { #if 0 // TODO(rjf): @msgs // rjf: unpack args - D_Entity *map = d_entity_from_handle(df_regs()->entity); + DF_Entity *map = d_entity_from_handle(df_regs()->entity); String8 path = path_normalized_from_string(scratch.arena, df_regs()->file_path); String8 path_folder = str8_chop_last_slash(path); String8 path_file = str8_skip_last_slash(path); @@ -9772,7 +9772,7 @@ df_frame(void) default:{}break; case DF_CmdKind_SetFileOverrideLinkSrc: { - D_Entity *map_parent = (df_regs()->file_path.size != 0) ? d_entity_from_path(path_folder, D_EntityFromPathFlag_OpenAsNeeded|D_EntityFromPathFlag_OpenMissing) : d_entity_root(); + DF_Entity *map_parent = (df_regs()->file_path.size != 0) ? d_entity_from_path(path_folder, D_EntityFromPathFlag_OpenAsNeeded|D_EntityFromPathFlag_OpenMissing) : d_entity_root(); if(d_entity_is_nil(map)) { map = d_entity_alloc(map_parent, D_EntityKind_FilePathMap); @@ -9789,7 +9789,7 @@ df_frame(void) { map = d_entity_alloc(d_entity_root(), D_EntityKind_FilePathMap); } - D_Entity *map_dst_entity = &d_nil_entity; + DF_Entity *map_dst_entity = &d_nil_entity; if(df_regs()->file_path.size != 0) { map_dst_entity = d_entity_from_path(path, D_EntityFromPathFlag_All); @@ -9827,12 +9827,12 @@ df_frame(void) #if 0 // TODO(rjf): @msgs //- rjf: grab src file & chosen replacement - D_Entity *file = d_entity_from_handle(params.entity); - D_Entity *replacement = d_entity_from_path(params.file_path, D_EntityFromPathFlag_OpenAsNeeded|D_EntityFromPathFlag_OpenMissing); + DF_Entity *file = d_entity_from_handle(params.entity); + DF_Entity *replacement = d_entity_from_path(params.file_path, D_EntityFromPathFlag_OpenAsNeeded|D_EntityFromPathFlag_OpenMissing); //- rjf: find - D_Entity *first_diff_src = file; - D_Entity *first_diff_dst = replacement; + DF_Entity *first_diff_src = file; + DF_Entity *first_diff_dst = replacement; for(;!d_entity_is_nil(first_diff_src) && !d_entity_is_nil(first_diff_dst);) { if(!str8_match(first_diff_src->string, first_diff_dst->string, StringMatchFlag_CaseInsensitive) || @@ -9850,7 +9850,7 @@ df_frame(void) //- rjf: override first different if(!d_entity_is_nil(first_diff_src) && !d_entity_is_nil(first_diff_dst)) { - D_Entity *link = d_entity_child_from_string_and_kind(first_diff_src->parent, first_diff_src->name, D_EntityKind_FilePathMap); + DF_Entity *link = d_entity_child_from_string_and_kind(first_diff_src->parent, first_diff_src->name, D_EntityKind_FilePathMap); if(d_entity_is_nil(link)) { link = d_entity_alloc(first_diff_src->parent, D_EntityKind_FilePathMap); @@ -10013,7 +10013,7 @@ df_frame(void) { DF_Panel *panel = df_panel_from_handle(df_regs()->panel); DF_ViewSpec *spec = df_view_spec_from_string(df_regs()->string); - D_Entity *entity = &d_nil_entity; + DF_Entity *entity = &d_nil_entity; if(spec->info.flags & DF_ViewSpecFlag_ParameterizedByEntity) { entity = d_entity_from_handle(df_regs()->entity); @@ -10112,7 +10112,7 @@ df_frame(void) for(DF_View *v = panel->first_tab_view; !df_view_is_nil(v); v = v->next) { if(df_view_is_project_filtered(v)) { continue; } - D_Entity *v_param_entity = d_entity_from_handle(v->params_entity); + DF_Entity *v_param_entity = d_entity_from_handle(v->params_entity); if(v_param_entity == d_entity_from_handle(df_regs()->entity)) { panel->selected_tab_view = df_handle_from_view(v); @@ -10650,10 +10650,10 @@ df_frame(void) // rjf: try to resolve name as a file #if 0 // TODO(rjf): @msgs - D_Entity *file = &d_nil_entity; + DF_Entity *file = &d_nil_entity; if(name_resolved == 0) { - D_Entity *src_entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *src_entity = d_entity_from_handle(df_regs()->entity); String8 file_part_of_name = name; U64 quote_pos = str8_find_needle(name, 0, str8_lit("\""), 0); if(quote_pos < name.size) @@ -10672,7 +10672,7 @@ df_frame(void) if(folders.node_count != 0) { String8 first_folder_name = folders.first->string; - D_Entity *root_folder = &d_nil_entity; + DF_Entity *root_folder = &d_nil_entity; // rjf: try to find root folder as if it's an absolute path if(d_entity_is_nil(root_folder)) @@ -10791,7 +10791,7 @@ df_frame(void) case DF_CmdKind_EditEntity: { #if 0 // TODO(rjf): @msgs - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); switch(entity->kind) { default: break; @@ -10807,7 +10807,7 @@ df_frame(void) case DF_CmdKind_EditTarget: { #if 0 // TODO(rjf): @msgs - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); if(!d_entity_is_nil(entity) && entity->kind == D_EntityKind_Target) { df_push_cmd(df_cmd_spec_from_kind(DF_CmdKind_Target), params); @@ -10822,7 +10822,7 @@ df_frame(void) //- rjf: catchall general entity activation paths (drag/drop, clicking) case DF_CmdKind_EntityRefFastPath: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); switch(entity->kind) { default: @@ -10844,7 +10844,7 @@ df_frame(void) #if 0 // TODO(rjf): @msgs DF_Window *ws = df_window_from_handle(df_regs()->window); DF_Panel *panel = df_panel_from_handle(df_regs()->panel); - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); switch(entity->kind) { default:{}break; @@ -11249,21 +11249,21 @@ df_frame(void) case DF_CmdKind_EnableBreakpoint: case DF_CmdKind_EnableTarget: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); d_entity_equip_disabled(entity, 0); }break; case DF_CmdKind_DisableEntity: case DF_CmdKind_DisableBreakpoint: case DF_CmdKind_DisableTarget: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); d_entity_equip_disabled(entity, 1); }break; case DF_CmdKind_RemoveEntity: case DF_CmdKind_RemoveBreakpoint: case DF_CmdKind_RemoveTarget: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); D_EntityKindFlags kind_flags = d_entity_kind_flags_table[entity->kind]; if(kind_flags & D_EntityKindFlag_CanDelete) { @@ -11272,29 +11272,29 @@ df_frame(void) }break; case DF_CmdKind_NameEntity: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); String8 string = df_regs()->string; d_entity_equip_name(entity, string); }break; case DF_CmdKind_DuplicateEntity: { - D_Entity *src = d_entity_from_handle(df_regs()->entity); + DF_Entity *src = d_entity_from_handle(df_regs()->entity); if(!d_entity_is_nil(src)) { typedef struct Task Task; struct Task { Task *next; - D_Entity *src_n; - D_Entity *dst_parent; + DF_Entity *src_n; + DF_Entity *dst_parent; }; Task starter_task = {0, src, src->parent}; Task *first_task = &starter_task; Task *last_task = &starter_task; for(Task *task = first_task; task != 0; task = task->next) { - D_Entity *src_n = task->src_n; - D_Entity *dst_n = d_entity_alloc(task->dst_parent, task->src_n->kind); + DF_Entity *src_n = task->src_n; + DF_Entity *dst_n = d_entity_alloc(task->dst_parent, task->src_n->kind); if(src_n->flags & D_EntityFlag_HasTextPoint) {d_entity_equip_txt_pt(dst_n, src_n->text_point);} if(src_n->flags & D_EntityFlag_HasU64) {d_entity_equip_u64(dst_n, src_n->u64);} if(src_n->flags & D_EntityFlag_HasColor) {d_entity_equip_color_hsva(dst_n, d_hsva_from_entity(src_n));} @@ -11303,7 +11303,7 @@ df_frame(void) if(src_n->disabled) {d_entity_equip_disabled(dst_n, 1);} if(src_n->string.size != 0) {d_entity_equip_name(dst_n, src_n->string);} dst_n->cfg_src = src_n->cfg_src; - for(D_Entity *src_child = task->src_n->first; !d_entity_is_nil(src_child); src_child = src_child->next) + for(DF_Entity *src_child = task->src_n->first; !d_entity_is_nil(src_child); src_child = src_child->next) { Task *child_task = push_array(scratch.arena, Task, 1); child_task->src_n = src_child; @@ -11315,8 +11315,8 @@ df_frame(void) }break; case DF_CmdKind_RelocateEntity: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); - D_Entity *location = d_entity_child_from_kind(entity, D_EntityKind_Location); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *location = d_entity_child_from_kind(entity, D_EntityKind_Location); if(d_entity_is_nil(location)) { location = d_entity_alloc(entity, D_EntityKind_Location); @@ -11351,8 +11351,8 @@ df_frame(void) D_EntityList bps = d_query_cached_entity_list_with_kind(D_EntityKind_Breakpoint); for(D_EntityNode *n = bps.first; n != 0; n = n->next) { - D_Entity *bp = n->entity; - D_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); + DF_Entity *bp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); if((loc->flags & D_EntityFlag_HasTextPoint && path_match_normalized(loc->string, file_path) && loc->text_point.line == pt.line) || (loc->flags & D_EntityFlag_HasVAddr && loc->vaddr == vaddr) || (!(loc->flags & D_EntityFlag_HasTextPoint) && str8_match(loc->string, string, 0))) @@ -11365,9 +11365,9 @@ df_frame(void) } if(!removed_already_existing) { - D_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); + DF_Entity *bp = d_entity_alloc(d_entity_root(), D_EntityKind_Breakpoint); d_entity_equip_cfg_src(bp, D_CfgSrc_Project); - D_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); + DF_Entity *loc = d_entity_alloc(bp, D_EntityKind_Location); if(file_path.size != 0 && pt.line != 0) { d_entity_equip_name(loc, file_path); @@ -11403,8 +11403,8 @@ df_frame(void) D_EntityList wps = d_query_cached_entity_list_with_kind(D_EntityKind_WatchPin); for(D_EntityNode *n = wps.first; n != 0; n = n->next) { - D_Entity *wp = n->entity; - D_Entity *loc = d_entity_child_from_kind(wp, D_EntityKind_Location); + DF_Entity *wp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(wp, D_EntityKind_Location); if((loc->flags & D_EntityFlag_HasTextPoint && path_match_normalized(loc->string, file_path) && loc->text_point.line == pt.line) || (loc->flags & D_EntityFlag_HasVAddr && loc->vaddr == vaddr) || (!(loc->flags & D_EntityFlag_HasTextPoint) && str8_match(loc->string, string, 0))) @@ -11417,10 +11417,10 @@ df_frame(void) } if(!removed_already_existing) { - D_Entity *wp = d_entity_alloc(d_entity_root(), D_EntityKind_WatchPin); + DF_Entity *wp = d_entity_alloc(d_entity_root(), D_EntityKind_WatchPin); d_entity_equip_name(wp, string); d_entity_equip_cfg_src(wp, D_CfgSrc_Project); - D_Entity *loc = d_entity_alloc(wp, D_EntityKind_Location); + DF_Entity *loc = d_entity_alloc(wp, D_EntityKind_Location); if(file_path.size != 0 && pt.line != 0) { d_entity_equip_name(loc, file_path); @@ -11437,10 +11437,10 @@ df_frame(void) case DF_CmdKind_ToggleWatchExpression: if(df_regs()->string.size != 0) { - D_Entity *existing_watch = d_entity_from_name_and_kind(df_regs()->string, D_EntityKind_Watch); + DF_Entity *existing_watch = d_entity_from_name_and_kind(df_regs()->string, D_EntityKind_Watch); if(d_entity_is_nil(existing_watch)) { - D_Entity *watch = &d_nil_entity; + DF_Entity *watch = &d_nil_entity; watch = d_entity_alloc(d_entity_root(), D_EntityKind_Watch); d_entity_equip_cfg_src(watch, D_CfgSrc_Project); d_entity_equip_name(watch, df_regs()->string); @@ -11539,17 +11539,17 @@ df_frame(void) case DF_CmdKind_AddTarget: { // rjf: build target - D_Entity *entity = &d_nil_entity; + DF_Entity *entity = &d_nil_entity; entity = d_entity_alloc(d_entity_root(), D_EntityKind_Target); d_entity_equip_disabled(entity, 1); d_entity_equip_cfg_src(entity, D_CfgSrc_Project); - D_Entity *exe = d_entity_alloc(entity, D_EntityKind_Executable); + DF_Entity *exe = d_entity_alloc(entity, D_EntityKind_Executable); d_entity_equip_name(exe, df_regs()->file_path); String8 working_dir = str8_chop_last_slash(df_regs()->file_path); if(working_dir.size != 0) { String8 working_dir_path = push_str8f(scratch.arena, "%S/", working_dir); - D_Entity *execution_path = d_entity_alloc(entity, D_EntityKind_WorkingDirectory); + DF_Entity *execution_path = d_entity_alloc(entity, D_EntityKind_WorkingDirectory); d_entity_equip_name(execution_path, working_dir_path); } df_cmd(DF_CmdKind_EditTarget, .entity = d_handle_from_entity(entity)); @@ -11557,14 +11557,14 @@ df_frame(void) }break; case DF_CmdKind_SelectTarget: { - D_Entity *entity = d_entity_from_handle(df_regs()->entity); + DF_Entity *entity = d_entity_from_handle(df_regs()->entity); if(entity->kind == D_EntityKind_Target) { D_EntityList all_targets = d_query_cached_entity_list_with_kind(D_EntityKind_Target); B32 is_selected = !entity->disabled; for(D_EntityNode *n = all_targets.first; n != 0; n = n->next) { - D_Entity *target = n->entity; + DF_Entity *target = n->entity; d_entity_equip_disabled(target, 1); } if(!is_selected) @@ -12171,11 +12171,11 @@ df_frame(void) U64 idx = 0; for(D_EntityNode *n = target_entities.first; n != 0; n = n->next, idx += 1) { - D_Entity *src_target = n->entity; - D_Entity *src_target_exe = d_entity_child_from_kind(src_target, D_EntityKind_Executable); - D_Entity *src_target_args = d_entity_child_from_kind(src_target, D_EntityKind_Arguments); - D_Entity *src_target_wdir = d_entity_child_from_kind(src_target, D_EntityKind_WorkingDirectory); - D_Entity *src_target_entry = d_entity_child_from_kind(src_target, D_EntityKind_EntryPoint); + DF_Entity *src_target = n->entity; + DF_Entity *src_target_exe = d_entity_child_from_kind(src_target, D_EntityKind_Executable); + DF_Entity *src_target_args = d_entity_child_from_kind(src_target, D_EntityKind_Arguments); + DF_Entity *src_target_wdir = d_entity_child_from_kind(src_target, D_EntityKind_WorkingDirectory); + DF_Entity *src_target_entry = d_entity_child_from_kind(src_target, D_EntityKind_EntryPoint); D_Target *dst_target = &targets.v[idx]; dst_target->exe = src_target_exe->string; dst_target->args = src_target_args->string; @@ -12195,14 +12195,14 @@ df_frame(void) U64 idx = 0; for(D_EntityNode *n = bp_entities.first; n != 0; n = n->next) { - D_Entity *src_bp = n->entity; + DF_Entity *src_bp = n->entity; if(src_bp->disabled) { breakpoints.count -= 1; continue; } - D_Entity *src_bp_loc = d_entity_child_from_kind(src_bp, D_EntityKind_Location); - D_Entity *src_bp_cnd = d_entity_child_from_kind(src_bp, D_EntityKind_Condition); + DF_Entity *src_bp_loc = d_entity_child_from_kind(src_bp, D_EntityKind_Location); + DF_Entity *src_bp_cnd = d_entity_child_from_kind(src_bp, D_EntityKind_Condition); D_Breakpoint *dst_bp = &breakpoints.v[idx]; dst_bp->file_path = src_bp_loc->string; dst_bp->pt = src_bp_loc->text_point; @@ -12252,6 +12252,10 @@ df_frame(void) { CTRL_Entity *thread = ctrl_entity_from_handle(d_state->ctrl_entity_store, evt->thread); U64 vaddr = evt->vaddr; + CTRL_Entity *process = ctrl_entity_ancestor_from_kind(thread, CTRL_EntityKind_Process); + CTRL_Entity *module = ctrl_module_from_process_vaddr(process, vaddr); + DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + U64 voff = ctrl_voff_from_vaddr(module, vaddr); // rjf: valid stop thread? -> select & snap if(thread != &ctrl_entity_nil) @@ -12270,7 +12274,36 @@ df_frame(void) // rjf: increment breakpoint hit counts if(evt->cause == D_EventCause_UserBreakpoint) { - + D_EntityList user_bps = d_query_cached_entity_list_with_kind(D_EntityKind_Breakpoint); + for(D_EntityNode *n = user_bps.first; n != 0; n = n->next) + { + DF_Entity *bp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); + D_LineList loc_lines = d_lines_from_file_path_line_num(scratch.arena, loc->string, loc->text_point.line); + if(loc_lines.first != 0) + { + for(D_LineNode *n = loc_lines.first; n != 0; n = n->next) + { + if(contains_1u64(n->v.voff_range, voff)) + { + bp->u64 += 1; + break; + } + } + } + else if(loc->flags & D_EntityFlag_HasVAddr && vaddr == loc->vaddr) + { + bp->u64 += 1; + } + else if(loc->string.size != 0) + { + U64 symb_voff = d_voff_from_dbgi_key_symbol_name(&dbgi_key, loc->string); + if(symb_voff == voff) + { + bp->u64 += 1; + } + } + } } }break; } @@ -12319,7 +12352,7 @@ df_frame(void) // { F32 rate = 1.f - pow_f32(2.f, -20.f*df_state->frame_dt); - for(D_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, d_entity_root()).next) + for(DF_Entity *e = d_entity_root(); !d_entity_is_nil(e); e = d_entity_rec_depth_first_pre(e, d_entity_root()).next) { F32 diff = (1.f - e->alive_t); e->alive_t += diff * rate; diff --git a/src/dbg_frontend/dbg_frontend_views.c b/src/dbg_frontend/dbg_frontend_views.c index f44f566b..a05e12ab 100644 --- a/src/dbg_frontend/dbg_frontend_views.c +++ b/src/dbg_frontend/dbg_frontend_views.c @@ -202,8 +202,8 @@ df_code_view_build(Arena *arena, DF_View *view, DF_CodeViewState *cv, DF_CodeVie D_EntityList bps = d_query_cached_entity_list_with_kind(D_EntityKind_Breakpoint); for(D_EntityNode *n = bps.first; n != 0; n = n->next) { - D_Entity *bp = n->entity; - D_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); + DF_Entity *bp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); if(path_match_normalized(loc->string, df_regs()->file_path) && visible_line_num_range.min <= loc->text_point.line && loc->text_point.line <= visible_line_num_range.max) { @@ -248,8 +248,8 @@ df_code_view_build(Arena *arena, DF_View *view, DF_CodeViewState *cv, DF_CodeVie D_EntityList wps = d_query_cached_entity_list_with_kind(D_EntityKind_WatchPin); for(D_EntityNode *n = wps.first; n != 0; n = n->next) { - D_Entity *wp = n->entity; - D_Entity *loc = d_entity_child_from_kind(wp, D_EntityKind_Location); + DF_Entity *wp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(wp, D_EntityKind_Location); if(path_match_normalized(loc->string, df_regs()->file_path) && visible_line_num_range.min <= loc->text_point.line && loc->text_point.line <= visible_line_num_range.max) { @@ -300,8 +300,8 @@ df_code_view_build(Arena *arena, DF_View *view, DF_CodeViewState *cv, DF_CodeVie D_EntityList bps = d_query_cached_entity_list_with_kind(D_EntityKind_Breakpoint); for(D_EntityNode *n = bps.first; n != 0; n = n->next) { - D_Entity *bp = n->entity; - D_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); + DF_Entity *bp = n->entity; + DF_Entity *loc = d_entity_child_from_kind(bp, D_EntityKind_Location); if(loc->flags & D_EntityFlag_HasVAddr && contains_1u64(dasm_vaddr_range, loc->vaddr)) { U64 off = loc->vaddr-dasm_vaddr_range.min; @@ -322,8 +322,8 @@ df_code_view_build(Arena *arena, DF_View *view, DF_CodeViewState *cv, DF_CodeVie D_EntityList pins = d_query_cached_entity_list_with_kind(D_EntityKind_WatchPin); for(D_EntityNode *n = pins.first; n != 0; n = n->next) { - D_Entity *pin = n->entity; - D_Entity *loc = d_entity_child_from_kind(pin, D_EntityKind_Location); + DF_Entity *pin = n->entity; + DF_Entity *loc = d_entity_child_from_kind(pin, D_EntityKind_Location); if(loc->flags & D_EntityFlag_HasVAddr && contains_1u64(dasm_vaddr_range, loc->vaddr)) { U64 off = loc->vaddr-dasm_vaddr_range.min; @@ -1010,14 +1010,14 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d D_EntityList watches = d_query_cached_entity_list_with_kind(mutable_entity_kind); for(D_EntityNode *n = watches.first; n != 0; n = n->next) { - D_Entity *watch = n->entity; + DF_Entity *watch = n->entity; if(watch->flags & D_EntityFlag_MarkedForDeletion) { continue; } EV_Key parent_key = d_parent_ev_key_from_entity(watch); EV_Key key = d_ev_key_from_entity(watch); - D_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); + DF_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); ev_key_set_view_rule(eval_view, key, view_rule->string); String8 expr_string = watch->string; FuzzyMatchRangeList matches = fuzzy_match_find(scratch.arena, filter, expr_string); @@ -1039,7 +1039,7 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d D_EntityList bps = d_query_cached_entity_list_with_kind(mutable_entity_kind); for(D_EntityNode *n = bps.first; n != 0; n = n->next) { - D_Entity *bp = n->entity; + DF_Entity *bp = n->entity; if(bp->flags & D_EntityFlag_MarkedForDeletion) { continue; @@ -1078,7 +1078,7 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d D_EntityList wps = d_query_cached_entity_list_with_kind(mutable_entity_kind); for(D_EntityNode *n = wps.first; n != 0; n = n->next) { - D_Entity *wp = n->entity; + DF_Entity *wp = n->entity; if(wp->flags & D_EntityFlag_MarkedForDeletion) { continue; @@ -1727,7 +1727,7 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d if(modifiable) { DF_WatchViewPoint pt = df_watch_view_point_from_tbl(&blocks, tbl); - D_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); + DF_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); if(!d_entity_is_nil(watch)) { d_entity_equip_name(watch, new_string); @@ -1773,8 +1773,8 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d { DF_WatchViewPoint pt = df_watch_view_point_from_tbl(&blocks, tbl); ev_key_set_view_rule(eval_view, pt.key, new_string); - D_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); - D_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); + DF_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); + DF_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); if(new_string.size != 0 && d_entity_is_nil(view_rule)) { view_rule = d_entity_alloc(watch, D_EntityKind_ViewRule); @@ -1857,14 +1857,14 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d { DF_WatchViewPoint fallback_pt_prev = df_watch_view_point_from_tbl(&blocks, v2s64(0, y - 1)); DF_WatchViewPoint fallback_pt_next = df_watch_view_point_from_tbl(&blocks, v2s64(0, y + 1)); - D_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); + DF_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); if(!d_entity_is_nil(watch)) { EV_Key new_cursor_key = empty_row_key; EV_Key new_cursor_parent_key = empty_row_parent_key; if((evt->delta_2s32.x < 0 || evt->delta_2s32.y < 0) && !ev_key_match(ev_key_zero(), fallback_pt_prev.key)) { - D_Entity *fallback_watch = d_entity_from_ev_key_and_kind(fallback_pt_prev.key, mutable_entity_kind); + DF_Entity *fallback_watch = d_entity_from_ev_key_and_kind(fallback_pt_prev.key, mutable_entity_kind); if(!d_entity_is_nil(fallback_watch)) { new_cursor_key = fallback_pt_prev.key; @@ -1873,7 +1873,7 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d } else if(!ev_key_match(ev_key_zero(), fallback_pt_next.key)) { - D_Entity *fallback_watch = d_entity_from_ev_key_and_kind(fallback_pt_next.key, mutable_entity_kind); + DF_Entity *fallback_watch = d_entity_from_ev_key_and_kind(fallback_pt_next.key, mutable_entity_kind); if(!d_entity_is_nil(fallback_watch)) { new_cursor_key = fallback_pt_next.key; @@ -1889,8 +1889,8 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d // rjf: view rule deletions else if(selection_tbl.min.x <= DF_WatchViewColumnKind_ViewRule && DF_WatchViewColumnKind_ViewRule <= selection_tbl.max.x) { - D_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); - D_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); + DF_Entity *watch = d_entity_from_ev_key_and_kind(pt.key, mutable_entity_kind); + DF_Entity *view_rule = d_entity_child_from_kind(watch, D_EntityKind_ViewRule); d_entity_mark_for_deletion(view_rule); ev_key_set_view_rule(eval_view, pt.key, str8_zero()); } @@ -1992,16 +1992,16 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d EV_Key first_watch_key = ev_key_from_block_list_row_num(&blocks, selection_tbl.min.y); EV_Key reorder_group_prev_watch_key = ev_key_from_block_list_row_num(&blocks, selection_tbl.min.y - 1); EV_Key reorder_group_next_watch_key = ev_key_from_block_list_row_num(&blocks, selection_tbl.max.y + 1); - D_Entity *reorder_group_prev = d_entity_from_ev_key_and_kind(reorder_group_prev_watch_key, mutable_entity_kind); - D_Entity *reorder_group_next = d_entity_from_ev_key_and_kind(reorder_group_next_watch_key, mutable_entity_kind); - D_Entity *first_watch = d_entity_from_ev_key_and_kind(first_watch_key, mutable_entity_kind); - D_Entity *last_watch = first_watch; + DF_Entity *reorder_group_prev = d_entity_from_ev_key_and_kind(reorder_group_prev_watch_key, mutable_entity_kind); + DF_Entity *reorder_group_next = d_entity_from_ev_key_and_kind(reorder_group_next_watch_key, mutable_entity_kind); + DF_Entity *first_watch = d_entity_from_ev_key_and_kind(first_watch_key, mutable_entity_kind); + DF_Entity *last_watch = first_watch; if(!d_entity_is_nil(first_watch)) { for(S64 y = selection_tbl.min.y+1; y <= selection_tbl.max.y; y += 1) { EV_Key key = ev_key_from_block_list_row_num(&blocks, y); - D_Entity *new_last = d_entity_from_ev_key_and_kind(key, mutable_entity_kind); + DF_Entity *new_last = d_entity_from_ev_key_and_kind(key, mutable_entity_kind); if(!d_entity_is_nil(new_last)) { last_watch = new_last; @@ -2217,7 +2217,7 @@ df_watch_view_build(DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 d default:{}break; case E_Mode_Offset: { - D_Entity *space_entity = d_entity_from_eval_space(row_eval.space); + DF_Entity *space_entity = d_entity_from_eval_space(row_eval.space); if(space_entity->kind == D_EntityKind_Process) { U64 size = e_type_byte_size_from_key(row_eval.type_key); @@ -2969,7 +2969,7 @@ DF_VIEW_UI_FUNCTION_DEF(getting_started) //- rjf: user has 1 target. build helper for launching it case 1: { - D_Entity *target = d_first_entity_from_list(&targets); + DF_Entity *target = d_first_entity_from_list(&targets); String8 target_full_path = target->string; String8 target_name = str8_skip_last_slash(target_full_path); UI_PrefHeight(ui_em(3.75f, 1.f)) @@ -3958,7 +3958,7 @@ df_process_info_list_from_query(Arena *arena, String8 query) U64 idx = 0; for(D_EntityNode *n = processes.first; n != 0; n = n->next, idx += 1) { - D_Entity *process = n->entity; + DF_Entity *process = n->entity; attached_process_pids[idx] = process->ctrl_id; } } @@ -4235,7 +4235,7 @@ DF_VIEW_UI_FUNCTION_DEF(system_processes) typedef struct DF_EntityListerItem DF_EntityListerItem; struct DF_EntityListerItem { - D_Entity *entity; + DF_Entity *entity; FuzzyMatchRangeList name_match_ranges; }; @@ -4269,7 +4269,7 @@ df_entity_lister_item_list_from_needle(Arena *arena, D_EntityKind kind, D_Entity D_EntityList ent_list = d_query_cached_entity_list_with_kind(kind); for(D_EntityNode *n = ent_list.first; n != 0; n = n->next) { - D_Entity *entity = n->entity; + DF_Entity *entity = n->entity; if(!(entity->flags & omit_flags)) { String8 display_string = d_display_string_from_entity(scratch.arena, entity); @@ -4346,7 +4346,7 @@ DF_VIEW_UI_FUNCTION_DEF(entity_lister) }; DF_EntityListerViewState *fev = df_view_user_state(view, DF_EntityListerViewState); D_Handle selected_entity_handle = fev->selected_entity_handle; - D_Entity *selected_entity = d_entity_from_handle(selected_entity_handle); + DF_Entity *selected_entity = d_entity_from_handle(selected_entity_handle); //- rjf: build filtered array of entities DF_EntityListerItemList ent_list = df_entity_lister_item_list_from_needle(scratch.arena, entity_kind, entity_flags_omit, string); @@ -4356,7 +4356,7 @@ DF_VIEW_UI_FUNCTION_DEF(entity_lister) //- rjf: submit best match when hitting enter w/ no selection if(d_entity_is_nil(d_entity_from_handle(fev->selected_entity_handle)) && ent_arr.count != 0 && ui_slot_press(UI_EventActionSlot_Accept)) { - D_Entity *ent = ent_arr.v[0].entity; + DF_Entity *ent = ent_arr.v[0].entity; df_cmd(DF_CmdKind_CompleteQuery, .entity = d_handle_from_entity(ent)); } @@ -4400,7 +4400,7 @@ DF_VIEW_UI_FUNCTION_DEF(entity_lister) idx += 1) { DF_EntityListerItem item = ent_arr.v[idx]; - D_Entity *ent = item.entity; + DF_Entity *ent = item.entity; ui_set_next_hover_cursor(OS_Cursor_HandPoint); ui_set_next_child_layout_axis(Axis2_X); UI_Box *box = &ui_g_nil_box; @@ -4669,7 +4669,7 @@ DF_VIEW_SETUP_FUNCTION_DEF(target) DF_VIEW_CMD_FUNCTION_DEF(target) { DF_TargetViewState *tv = df_view_user_state(view, DF_TargetViewState); - D_Entity *entity = d_entity_from_eval_string(string); + DF_Entity *entity = d_entity_from_eval_string(string); #if 0 // TODO(rjf): @msgs // rjf: process commands for(DF_Cmd *cmd = 0; df_next_cmd(&cmd);) @@ -4690,10 +4690,10 @@ DF_VIEW_CMD_FUNCTION_DEF(target) case DF_CmdKind_PickFolder: { String8 pick_string = cmd->params.file_path; - D_Entity *storage_entity = entity; + DF_Entity *storage_entity = entity; if(tv->pick_dst_kind != D_EntityKind_Nil) { - D_Entity *child = d_entity_child_from_kind(entity, tv->pick_dst_kind); + DF_Entity *child = d_entity_child_from_kind(entity, tv->pick_dst_kind); if(d_entity_is_nil(child)) { child = d_entity_alloc(entity, tv->pick_dst_kind); @@ -4711,7 +4711,7 @@ DF_VIEW_UI_FUNCTION_DEF(target) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); - D_Entity *entity = d_entity_from_eval_string(string); + DF_Entity *entity = d_entity_from_eval_string(string); D_EntityList custom_entry_points = d_push_entity_child_list_with_kind(scratch.arena, entity, D_EntityKind_EntryPoint); F32 row_height_px = floor_f32(ui_top_font_size()*2.5f); @@ -4941,7 +4941,7 @@ DF_VIEW_UI_FUNCTION_DEF(target) { default: { - D_Entity *child = d_entity_child_from_kind(entity, commit_storage_child_kind); + DF_Entity *child = d_entity_child_from_kind(entity, commit_storage_child_kind); if(d_entity_is_nil(child)) { child = d_entity_alloc(entity, commit_storage_child_kind); @@ -5002,7 +5002,7 @@ DF_VIEW_UI_FUNCTION_DEF(targets) // NOTE(rjf): 0 => nothing, 1 => add new, 2 => first target Vec2S64 cursor = {0}; { - D_Entity *selected_target = d_entity_from_handle(tv->selected_target_handle); + DF_Entity *selected_target = d_entity_from_handle(tv->selected_target_handle); for(U64 idx = 0; idx < targets.count; idx += 1) { if(selected_target == targets.v[idx].entity) @@ -5057,7 +5057,7 @@ DF_VIEW_UI_FUNCTION_DEF(targets) row_idx += 1) UI_Row { - D_Entity *target = targets.v[row_idx-1].entity; + DF_Entity *target = targets.v[row_idx-1].entity; B32 row_selected = ((U64)cursor.y == row_idx+1); // rjf: enabled @@ -5179,7 +5179,7 @@ DF_VIEW_CMD_FUNCTION_DEF(file_path_map) { String8 pick_string = cmd->regs->file_path; Side pick_side = fpms->pick_file_dst_side; - D_Entity *storage_entity = d_entity_from_handle(fpms->pick_file_dst_map); + DF_Entity *storage_entity = d_entity_from_handle(fpms->pick_file_dst_map); df_cmd(pick_side == Side_Min ? DF_CmdKind_SetFileOverrideLinkSrc : DF_CmdKind_SetFileOverrideLinkDst, @@ -5283,9 +5283,9 @@ DF_VIEW_UI_FUNCTION_DEF(file_path_map) row_idx += 1) UI_TableVector { U64 map_idx = row_idx-1; - D_Entity *map = (map_idx < maps.count ? maps.v[map_idx] : &d_nil_entity); - D_Entity *map_src = d_entity_child_from_kind(map, D_EntityKind_Source); - D_Entity *map_dst = d_entity_child_from_kind(map, D_EntityKind_Dest); + DF_Entity *map = (map_idx < maps.count ? maps.v[map_idx] : &d_nil_entity); + DF_Entity *map_src = d_entity_child_from_kind(map, D_EntityKind_Source); + DF_Entity *map_dst = d_entity_child_from_kind(map, D_EntityKind_Dest); String8 map_src_path = map_src->string; String8 map_dst_path = map_dst->string; B32 row_selected = (fpms->cursor.y == row_idx); @@ -5547,16 +5547,16 @@ DF_VIEW_UI_FUNCTION_DEF(scheduler) D_EntityArray entities = {0}; { entities.count = machines.count+processes.count+threads.count; - entities.v = push_array_no_zero(scratch.arena, D_Entity *, entities.count); + entities.v = push_array_no_zero(scratch.arena, DF_Entity *, entities.count); U64 idx = 0; for(D_EntityNode *machine_n = machines.first; machine_n != 0; machine_n = machine_n->next) { - D_Entity *machine = machine_n->entity; + DF_Entity *machine = machine_n->entity; entities.v[idx] = machine; idx += 1; for(D_EntityNode *process_n = processes.first; process_n != 0; process_n = process_n->next) { - D_Entity *process = process_n->entity; + DF_Entity *process = process_n->entity; if(d_entity_ancestor_from_kind(process, D_EntityKind_Machine) != machine) { continue; @@ -5565,7 +5565,7 @@ DF_VIEW_UI_FUNCTION_DEF(scheduler) idx += 1; for(D_EntityNode *thread_n = threads.first; thread_n != 0; thread_n = thread_n->next) { - D_Entity *thread = thread_n->entity; + DF_Entity *thread = thread_n->entity; if(d_entity_ancestor_from_kind(thread, D_EntityKind_Process) != process) { continue; @@ -5624,7 +5624,7 @@ DF_VIEW_UI_FUNCTION_DEF(scheduler) idx <= visible_row_range.max && idx < items.count; idx += 1) { - D_Entity *entity = items.v[idx].entity; + DF_Entity *entity = items.v[idx].entity; CTRL_Entity *entity_ctrl = ctrl_entity_from_handle(d_state->ctrl_entity_store, entity->ctrl_handle); B32 row_is_selected = (cursor.y == (S64)(idx+1)); F32 depth = 0.f; @@ -5816,7 +5816,7 @@ DF_VIEW_CMD_FUNCTION_DEF(modules) { Temp scratch = scratch_begin(0, 0); String8 pick_string = cmd->regs->file_path; - D_Entity *module = d_entity_from_handle(mv->pick_file_dst_entity); + DF_Entity *module = d_entity_from_handle(mv->pick_file_dst_entity); if(module->kind == D_EntityKind_Module) { String8 exe_path = module->string; @@ -5853,16 +5853,16 @@ DF_VIEW_UI_FUNCTION_DEF(modules) D_EntityArray entities = {0}; { entities.count = processes.count+modules.count; - entities.v = push_array_no_zero(scratch.arena, D_Entity *, entities.count); + entities.v = push_array_no_zero(scratch.arena, DF_Entity *, entities.count); U64 idx = 0; for(D_EntityNode *process_n = processes.first; process_n != 0; process_n = process_n->next) { - D_Entity *process = process_n->entity; + DF_Entity *process = process_n->entity; entities.v[idx] = process; idx += 1; for(D_EntityNode *module_n = modules.first; module_n != 0; module_n = module_n->next) { - D_Entity *module = module_n->entity; + DF_Entity *module = module_n->entity; if(d_entity_ancestor_from_kind(module, D_EntityKind_Process) != process) { continue; @@ -5928,7 +5928,7 @@ DF_VIEW_UI_FUNCTION_DEF(modules) } //- rjf: build table - D_Entity *commit_module = &d_nil_entity; + DF_Entity *commit_module = &d_nil_entity; Rng1S64 visible_row_range = {0}; UI_ScrollListParams scroll_list_params = {0}; { @@ -5954,7 +5954,7 @@ DF_VIEW_UI_FUNCTION_DEF(modules) U64 idx_in_process = 0; for(U64 idx = 0; idx < items.count; idx += 1) { - D_Entity *entity = items.v[idx].entity; + DF_Entity *entity = items.v[idx].entity; B32 row_is_selected = (cursor.y == (S64)(idx+1)); idx_in_process += (entity->kind == D_EntityKind_Module); if(visible_row_range.min <= idx && idx <= visible_row_range.max) @@ -6746,9 +6746,9 @@ DF_VIEW_CMD_FUNCTION_DEF(disasm) default: break; case DF_CmdKind_GoToAddress: { - D_Entity *process = &d_nil_entity; + DF_Entity *process = &d_nil_entity; { - D_Entity *entity = d_entity_from_handle(cmd->regs->entity); + DF_Entity *entity = d_entity_from_handle(cmd->regs->entity); if(!d_entity_is_nil(entity) && (entity->kind == D_EntityKind_Process || entity->kind == D_EntityKind_Thread || diff --git a/src/dbg_frontend/dbg_frontend_widgets.c b/src/dbg_frontend/dbg_frontend_widgets.c index f5697144..63a1162a 100644 --- a/src/dbg_frontend/dbg_frontend_widgets.c +++ b/src/dbg_frontend/dbg_frontend_widgets.c @@ -415,7 +415,7 @@ df_icon_buttonf(DF_IconKind kind, FuzzyMatchRangeList *matches, char *fmt, ...) } internal void -df_entity_tooltips(D_Entity *entity) +df_entity_tooltips(DF_Entity *entity) { Temp scratch = scratch_begin(0, 0); DF_Palette(DF_PaletteCode_Floating) switch(entity->kind) @@ -446,7 +446,7 @@ df_entity_tooltips(D_Entity *entity) } { CTRL_Event stop_event = d_ctrl_last_stop_event(); - D_Entity *stopper_thread = d_entity_from_ctrl_handle(stop_event.entity); + DF_Entity *stopper_thread = d_entity_from_ctrl_handle(stop_event.entity); if(stopper_thread == entity) { ui_spacer(ui_em(1.5f, 1.f)); @@ -582,7 +582,7 @@ df_entity_tooltips(D_Entity *entity) } internal UI_Signal -df_entity_desc_button(D_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query, B32 is_implicit) +df_entity_desc_button(DF_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query, B32 is_implicit) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -677,7 +677,7 @@ df_entity_desc_button(D_Entity *entity, FuzzyMatchRangeList *name_matches, Strin } if(entity->kind == D_EntityKind_Target) UI_FlagsAdd(UI_BoxFlag_DrawTextWeak) UI_FontSize(ui_top_font_size()*0.95f) { - D_Entity *args = d_entity_child_from_kind(entity, D_EntityKind_Arguments); + DF_Entity *args = d_entity_child_from_kind(entity, D_EntityKind_Arguments); ui_label(args->string); } if(kind_flags & D_EntityKindFlag_CanEnable && entity->disabled) UI_FlagsAdd(UI_BoxFlag_DrawTextWeak) UI_FontSize(ui_top_font_size()*0.95f) UI_HeightFill @@ -1337,7 +1337,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe //- rjf: build margin breakpoint ui for(D_EntityNode *n = line_bps.first; n != 0; n = n->next) { - D_Entity *bp = n->entity; + DF_Entity *bp = n->entity; Vec4F32 bp_color = df_rgba_from_theme_color(DF_ThemeColor_Breakpoint); if(bp->flags & D_EntityFlag_HasColor) { @@ -1422,7 +1422,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe //- rjf: build margin watch pin ui for(D_EntityNode *n = line_pins.first; n != 0; n = n->next) { - D_Entity *pin = n->entity; + DF_Entity *pin = n->entity; Vec4F32 color = df_rgba_from_theme_color(DF_ThemeColor_Text); if(pin->flags & D_EntityFlag_HasColor) { @@ -1659,7 +1659,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe { for(D_EntityNode *n = pins.first; n != 0; n = n->next) { - D_Entity *pin = n->entity; + DF_Entity *pin = n->entity; String8 pin_expr = pin->string; E_Eval eval = e_eval_from_string(scratch.arena, pin_expr); String8 eval_string = {0}; @@ -1787,7 +1787,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe UI_Signal priority_margin_container_sig = ui_signal_from_box(priority_margin_container_box); UI_Signal catchall_margin_container_sig = ui_signal_from_box(catchall_margin_container_box); UI_Signal text_container_sig = ui_signal_from_box(text_container_box); - D_Entity *line_drag_entity = &d_nil_entity; + DF_Entity *line_drag_entity = &d_nil_entity; { //- rjf: determine mouse drag range TxtRng mouse_drag_rng = txt_rng(mouse_pt, mouse_pt); @@ -1860,7 +1860,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe if(df_drag_is_active() && contains_2f32(clipped_top_container_rect, ui_mouse())) { DF_DragDropPayload *payload = &df_drag_drop_payload; - D_Entity *entity = d_entity_from_handle(payload->entity); + DF_Entity *entity = d_entity_from_handle(payload->entity); if(entity->kind == D_EntityKind_Thread || entity->kind == D_EntityKind_WatchPin || entity->kind == D_EntityKind_Breakpoint) @@ -1874,7 +1874,7 @@ df_code_slice(DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe DF_DragDropPayload payload = {0}; if(!d_entity_is_nil(line_drag_entity) && df_drag_drop(&payload) && contains_1s64(params->line_num_range, mouse_pt.line)) { - D_Entity *dropped_entity = line_drag_entity; + DF_Entity *dropped_entity = line_drag_entity; S64 line_num = mouse_pt.line; U64 line_idx = line_num - params->line_num_range.min; U64 line_vaddr = params->line_vaddrs[line_idx]; diff --git a/src/dbg_frontend/dbg_frontend_widgets.h b/src/dbg_frontend/dbg_frontend_widgets.h index d41da8e4..b143d480 100644 --- a/src/dbg_frontend/dbg_frontend_widgets.h +++ b/src/dbg_frontend/dbg_frontend_widgets.h @@ -90,8 +90,8 @@ internal UI_Signal df_cmd_spec_button(String8 name); internal void df_cmd_list_menu_buttons(U64 count, String8 *cmd_names, U32 *fastpath_codepoints); internal UI_Signal df_icon_button(DF_IconKind kind, FuzzyMatchRangeList *matches, String8 string); internal UI_Signal df_icon_buttonf(DF_IconKind kind, FuzzyMatchRangeList *matches, char *fmt, ...); -internal void df_entity_tooltips(D_Entity *entity); -internal UI_Signal df_entity_desc_button(D_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query, B32 is_implicit); +internal void df_entity_tooltips(DF_Entity *entity); +internal UI_Signal df_entity_desc_button(DF_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query, B32 is_implicit); internal void df_src_loc_button(String8 file_path, TxtPt point); //////////////////////////////// diff --git a/src/raddbg/raddbg_main.c b/src/raddbg/raddbg_main.c index a489e113..77c78647 100644 --- a/src/raddbg/raddbg_main.c +++ b/src/raddbg/raddbg_main.c @@ -775,7 +775,7 @@ entry_point(CmdLine *cmd_line) if(args.node_count > 0 && args.first->string.size != 0) { Temp scratch = scratch_begin(0, 0); - D_Entity *target = d_entity_alloc(d_entity_root(), D_EntityKind_Target); + DF_Entity *target = d_entity_alloc(d_entity_root(), D_EntityKind_Target); d_entity_equip_cfg_src(target, D_CfgSrc_CommandLine); String8List passthrough_args_list = {0}; for(String8Node *n = args.first->next; n != 0; n = n->next) @@ -790,7 +790,7 @@ entry_point(CmdLine *cmd_line) if(args.first->string.size != 0) { String8 exe_name = args.first->string; - D_Entity *exe = d_entity_alloc(target, D_EntityKind_Executable); + DF_Entity *exe = d_entity_alloc(target, D_EntityKind_Executable); PathStyle style = path_style_from_str8(exe_name); if(style == PathStyle_Relative) { @@ -805,7 +805,7 @@ entry_point(CmdLine *cmd_line) if(path_part_of_arg.size != 0) { String8 path = push_str8f(scratch.arena, "%S/", path_part_of_arg); - D_Entity *wdir = d_entity_alloc(target, D_EntityKind_WorkingDirectory); + DF_Entity *wdir = d_entity_alloc(target, D_EntityKind_WorkingDirectory); d_entity_equip_name(wdir, path); } @@ -814,7 +814,7 @@ entry_point(CmdLine *cmd_line) String8 args_str = str8_list_join(scratch.arena, &passthrough_args_list, &join); if(args_str.size != 0) { - D_Entity *args_entity = d_entity_alloc(target, D_EntityKind_Arguments); + DF_Entity *args_entity = d_entity_alloc(target, D_EntityKind_Arguments); d_entity_equip_name(args_entity, args_str); } scratch_end(scratch);