ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-06-24 20:54:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

further raddbgi -> rdi naming pass

Browse Source
This commit is contained in:
Ryan Fleury
2024-02-13 15:56:30 -08:00
parent b9f010dff6
commit 816f94ef71
17 changed files with 597 additions and 597 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/type_graph/type_graph.c
+108 -108
View File
@@ -279,7 +279,7 @@ tg_cons_type_make(TG_Graph *graph, TG_Kind kind, TG_Key direct_type_key, U64 u64
//~ rjf: Graph Introspection API
internal TG_Type *
tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_Type *type = &tg_type_nil;
U64 reg_byte_count = 0;
@@ -324,7 +324,7 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
}break;
case TG_Kind_Array:
{
U64 ptee_size = tg_byte_size_from_graph_rdi_key(graph, rdbg, cons_type->direct_type_key);
U64 ptee_size = tg_byte_size_from_graph_rdi_key(graph, rdi, cons_type->direct_type_key);
type->byte_size = ptee_size * type->count;
}break;
}
@@ -336,20 +336,20 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
case TG_KeyKind_Ext:
{
U64 type_node_idx = key.u64[0];
if(0 <= type_node_idx && type_node_idx < rdbg->type_nodes_count)
if(0 <= type_node_idx && type_node_idx < rdi->type_nodes_count)
{
RDI_TypeNode *rdbg_type = &rdbg->type_nodes[type_node_idx];
TG_Kind kind = tg_kind_from_rdi_type_kind(rdbg_type->kind);
RDI_TypeNode *rdi_type = &rdi->type_nodes[type_node_idx];
TG_Kind kind = tg_kind_from_rdi_type_kind(rdi_type->kind);
//- rjf: record types => unpack name * members & produce
if(RDI_TypeKind_FirstRecord <= rdbg_type->kind && rdbg_type->kind <= RDI_TypeKind_LastRecord)
if(RDI_TypeKind_FirstRecord <= rdi_type->kind && rdi_type->kind <= RDI_TypeKind_LastRecord)
{
// rjf: unpack name
String8 name = {0};
name.str = rdi_string_from_idx(rdbg, rdbg_type->user_defined.name_string_idx, &name.size);
name.str = rdi_string_from_idx(rdi, rdi_type->user_defined.name_string_idx, &name.size);
// rjf: unpack UDT info
RDI_UDT *udt = rdi_element_from_idx(rdbg, udts, rdbg_type->user_defined.udt_idx);
RDI_UDT *udt = rdi_element_from_idx(rdi, udts, rdi_type->user_defined.udt_idx);
// rjf: unpack members
TG_Member *members = 0;
@@ -357,23 +357,23 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
{
members_count = udt->member_count;
members = push_array(arena, TG_Member, members_count);
if(members_count != 0 && 0 <= udt->member_first && udt->member_first+udt->member_count <= rdbg->members_count)
if(members_count != 0 && 0 <= udt->member_first && udt->member_first+udt->member_count <= rdi->members_count)
{
for(U32 member_idx = udt->member_first;
member_idx < udt->member_first+udt->member_count;
member_idx += 1)
{
RDI_Member *src = &rdbg->members[member_idx];
RDI_Member *src = &rdi->members[member_idx];
TG_Kind member_type_kind = TG_Kind_Null;
if(src->type_idx < rdbg->type_nodes_count)
if(src->type_idx < rdi->type_nodes_count)
{
RDI_TypeNode *member_type = &rdbg->type_nodes[src->type_idx];
RDI_TypeNode *member_type = &rdi->type_nodes[src->type_idx];
member_type_kind = tg_kind_from_rdi_type_kind(member_type->kind);
}
TG_Member *dst = &members[member_idx-udt->member_first];
dst->kind = tg_member_kind_from_rdi_member_kind(src->kind);
dst->type_key = tg_key_ext(member_type_kind, (U64)src->type_idx);
dst->name.str = rdi_string_from_idx(rdbg, src->name_string_idx, &dst->name.size);
dst->name.str = rdi_string_from_idx(rdi, src->name_string_idx, &dst->name.size);
dst->off = (U64)src->off;
}
}
@@ -383,46 +383,46 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
type = push_array(arena, TG_Type, 1);
type->kind = kind;
type->name = push_str8_copy(arena, name);
type->byte_size = (U64)rdbg_type->byte_size;
type->byte_size = (U64)rdi_type->byte_size;
type->count = members_count;
type->members = members;
}
//- rjf: enum types => unpack name * values & produce
else if(rdbg_type->kind == RDI_TypeKind_Enum)
else if(rdi_type->kind == RDI_TypeKind_Enum)
{
// rjf: unpack name
String8 name = {0};
name.str = rdi_string_from_idx(rdbg, rdbg_type->user_defined.name_string_idx, &name.size);
name.str = rdi_string_from_idx(rdi, rdi_type->user_defined.name_string_idx, &name.size);
// rjf: unpack direct type
TG_Key direct_type_key = zero_struct;
if(rdbg_type->user_defined.direct_type_idx < type_node_idx)
if(rdi_type->user_defined.direct_type_idx < type_node_idx)
{
RDI_TypeNode *direct_type_node = &rdbg->type_nodes[rdbg_type->user_defined.direct_type_idx];
RDI_TypeNode *direct_type_node = &rdi->type_nodes[rdi_type->user_defined.direct_type_idx];
TG_Kind direct_type_kind = tg_kind_from_rdi_type_kind(direct_type_node->kind);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdbg_type->user_defined.direct_type_idx);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdi_type->user_defined.direct_type_idx);
}
// rjf: unpack members
TG_EnumVal *enum_vals = 0;
U32 enum_vals_count = 0;
{
U32 udt_idx = rdbg_type->user_defined.udt_idx;
if(0 <= udt_idx && udt_idx < rdbg->udts_count)
U32 udt_idx = rdi_type->user_defined.udt_idx;
if(0 <= udt_idx && udt_idx < rdi->udts_count)
{
RDI_UDT *udt = &rdbg->udts[udt_idx];
RDI_UDT *udt = &rdi->udts[udt_idx];
enum_vals_count = udt->member_count;
enum_vals = push_array(arena, TG_EnumVal, enum_vals_count);
if(0 <= udt->member_first && udt->member_first+udt->member_count < rdbg->enum_members_count)
if(0 <= udt->member_first && udt->member_first+udt->member_count < rdi->enum_members_count)
{
for(U32 member_idx = udt->member_first;
member_idx < udt->member_first+udt->member_count;
member_idx += 1)
{
RDI_EnumMember *src = &rdbg->enum_members[member_idx];
RDI_EnumMember *src = &rdi->enum_members[member_idx];
TG_EnumVal *dst = &enum_vals[member_idx-udt->member_first];
dst->name.str = rdi_string_from_idx(rdbg, src->name_string_idx, &dst->name.size);
dst->name.str = rdi_string_from_idx(rdi, src->name_string_idx, &dst->name.size);
dst->val = src->val;
}
}
@@ -433,39 +433,39 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
type = push_array(arena, TG_Type, 1);
type->kind = kind;
type->name = push_str8_copy(arena, name);
type->byte_size = (U64)rdbg_type->byte_size;
type->byte_size = (U64)rdi_type->byte_size;
type->count = enum_vals_count;
type->enum_vals = enum_vals;
type->direct_type_key = direct_type_key;
}
//- rjf: constructed types
if(RDI_TypeKind_FirstConstructed <= rdbg_type->kind && rdbg_type->kind <= RDI_TypeKind_LastConstructed)
if(RDI_TypeKind_FirstConstructed <= rdi_type->kind && rdi_type->kind <= RDI_TypeKind_LastConstructed)
{
// rjf: unpack direct type
B32 direct_type_is_good = 0;
TG_Key direct_type_key = zero_struct;
U64 direct_type_byte_size = 0;
if(rdbg_type->constructed.direct_type_idx < type_node_idx)
if(rdi_type->constructed.direct_type_idx < type_node_idx)
{
RDI_TypeNode *direct_type_node = &rdbg->type_nodes[rdbg_type->constructed.direct_type_idx];
RDI_TypeNode *direct_type_node = &rdi->type_nodes[rdi_type->constructed.direct_type_idx];
TG_Kind direct_type_kind = tg_kind_from_rdi_type_kind(direct_type_node->kind);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdbg_type->constructed.direct_type_idx);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdi_type->constructed.direct_type_idx);
direct_type_is_good = 1;
direct_type_byte_size = (U64)direct_type_node->byte_size;
}
// rjf: construct based on kind
switch(rdbg_type->kind)
switch(rdi_type->kind)
{
case RDI_TypeKind_Modifier:
{
TG_Flags flags = 0;
if(rdbg_type->flags & RDI_TypeModifierFlag_Const)
if(rdi_type->flags & RDI_TypeModifierFlag_Const)
{
flags |= TG_Flag_Const;
}
if(rdbg_type->flags & RDI_TypeModifierFlag_Volatile)
if(rdi_type->flags & RDI_TypeModifierFlag_Volatile)
{
flags |= TG_Flag_Volatile;
}
@@ -490,15 +490,15 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
type = push_array(arena, TG_Type, 1);
type->kind = kind;
type->direct_type_key = direct_type_key;
type->count = rdbg_type->constructed.count;
type->count = rdi_type->constructed.count;
type->byte_size = direct_type_byte_size * type->count;
}break;
case RDI_TypeKind_Function:
{
U32 count = rdbg_type->constructed.count;
U32 idx_run_first = rdbg_type->constructed.param_idx_run_first;
U32 count = rdi_type->constructed.count;
U32 idx_run_first = rdi_type->constructed.param_idx_run_first;
U32 check_count = 0;
U32 *idx_run = rdi_idx_run_from_first_count(rdbg, idx_run_first, count, &check_count);
U32 *idx_run = rdi_idx_run_from_first_count(rdi, idx_run_first, count, &check_count);
if(check_count == count)
{
type = push_array(arena, TG_Type, 1);
@@ -512,7 +512,7 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
U32 param_type_idx = idx_run[idx];
if(param_type_idx < type_node_idx)
{
RDI_TypeNode *param_type_node = &rdbg->type_nodes[param_type_idx];
RDI_TypeNode *param_type_node = &rdi->type_nodes[param_type_idx];
TG_Kind param_kind = tg_kind_from_rdi_type_kind(param_type_node->kind);
type->param_type_keys[idx] = tg_key_ext(param_kind, (U64)param_type_idx);
}
@@ -528,10 +528,10 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
// NOTE(rjf): for methods, the `direct` type points at the owner type.
// the return type, instead of being encoded via the `direct` type, is
// encoded via the first parameter.
U32 count = rdbg_type->constructed.count;
U32 idx_run_first = rdbg_type->constructed.param_idx_run_first;
U32 count = rdi_type->constructed.count;
U32 idx_run_first = rdi_type->constructed.param_idx_run_first;
U32 check_count = 0;
U32 *idx_run = rdi_idx_run_from_first_count(rdbg, idx_run_first, count, &check_count);
U32 *idx_run = rdi_idx_run_from_first_count(rdi, idx_run_first, count, &check_count);
if(check_count == count)
{
type = push_array(arena, TG_Type, 1);
@@ -545,7 +545,7 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
U32 param_type_idx = idx_run[idx];
if(param_type_idx < type_node_idx)
{
RDI_TypeNode *param_type_node = &rdbg->type_nodes[param_type_idx];
RDI_TypeNode *param_type_node = &rdi->type_nodes[param_type_idx];
TG_Kind param_kind = tg_kind_from_rdi_type_kind(param_type_node->kind);
type->param_type_keys[idx] = tg_key_ext(param_kind, (U64)param_type_idx);
}
@@ -566,11 +566,11 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
{
// rjf: unpack owner type
TG_Key owner_type_key = zero_struct;
if(rdbg_type->constructed.owner_type_idx < type_node_idx)
if(rdi_type->constructed.owner_type_idx < type_node_idx)
{
RDI_TypeNode *owner_type_node = &rdbg->type_nodes[rdbg_type->constructed.owner_type_idx];
RDI_TypeNode *owner_type_node = &rdi->type_nodes[rdi_type->constructed.owner_type_idx];
TG_Kind owner_type_kind = tg_kind_from_rdi_type_kind(owner_type_node->kind);
owner_type_key = tg_key_ext(owner_type_kind, (U64)rdbg_type->constructed.owner_type_idx);
owner_type_key = tg_key_ext(owner_type_kind, (U64)rdi_type->constructed.owner_type_idx);
}
type = push_array(arena, TG_Type, 1);
type->kind = kind;
@@ -582,20 +582,20 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
}
//- rjf: alias types
else if(rdbg_type->kind == RDI_TypeKind_Alias)
else if(rdi_type->kind == RDI_TypeKind_Alias)
{
// rjf: unpack name
String8 name = {0};
name.str = rdi_string_from_idx(rdbg, rdbg_type->user_defined.name_string_idx, &name.size);
name.str = rdi_string_from_idx(rdi, rdi_type->user_defined.name_string_idx, &name.size);
// rjf: unpack direct type
TG_Key direct_type_key = zero_struct;
U64 direct_type_byte_size = 0;
if(rdbg_type->user_defined.direct_type_idx < type_node_idx)
if(rdi_type->user_defined.direct_type_idx < type_node_idx)
{
RDI_TypeNode *direct_type_node = &rdbg->type_nodes[rdbg_type->user_defined.direct_type_idx];
RDI_TypeNode *direct_type_node = &rdi->type_nodes[rdi_type->user_defined.direct_type_idx];
TG_Kind direct_type_kind = tg_kind_from_rdi_type_kind(direct_type_node->kind);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdbg_type->user_defined.direct_type_idx);
direct_type_key = tg_key_ext(direct_type_kind, (U64)rdi_type->user_defined.direct_type_idx);
direct_type_byte_size = direct_type_node->byte_size;
}
@@ -608,11 +608,11 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
}
//- rjf: incomplete types
else if(RDI_TypeKind_FirstIncomplete <= rdbg_type->kind && rdbg_type->kind <= RDI_TypeKind_LastIncomplete)
else if(RDI_TypeKind_FirstIncomplete <= rdi_type->kind && rdi_type->kind <= RDI_TypeKind_LastIncomplete)
{
// rjf: unpack name
String8 name = {0};
name.str = rdi_string_from_idx(rdbg, rdbg_type->user_defined.name_string_idx, &name.size);
name.str = rdi_string_from_idx(rdi, rdi_type->user_defined.name_string_idx, &name.size);
// rjf: produce
type = push_array(arena, TG_Type, 1);
@@ -795,7 +795,7 @@ tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_K
}
internal TG_Key
tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_Key result = zero_struct;
switch(key.kind)
@@ -805,7 +805,7 @@ tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
case TG_KeyKind_Cons:
{
Temp scratch = scratch_begin(0, 0);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
result = type->direct_type_key;
scratch_end(scratch);
}break;
@@ -814,16 +814,16 @@ tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
}
internal TG_Key
tg_unwrapped_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_unwrapped_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
key = tg_unwrapped_from_graph_rdi_key(graph, rdbg, key);
key = tg_direct_from_graph_rdi_key(graph, rdbg, key);
key = tg_unwrapped_from_graph_rdi_key(graph, rdbg, key);
key = tg_unwrapped_from_graph_rdi_key(graph, rdi, key);
key = tg_direct_from_graph_rdi_key(graph, rdi, key);
key = tg_unwrapped_from_graph_rdi_key(graph, rdi, key);
return key;
}
internal TG_Key
tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_Key result = zero_struct;
switch(key.kind)
@@ -833,7 +833,7 @@ tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
case TG_KeyKind_Cons:
{
Temp scratch = scratch_begin(0, 0);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
result = type->owner_type_key;
scratch_end(scratch);
}break;
@@ -842,14 +842,14 @@ tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
}
internal TG_Key
tg_ptee_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_ptee_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_Key result = key;
B32 passed_ptr = 0;
for(;;)
{
TG_Kind kind = tg_kind_from_key(result);
result = tg_direct_from_graph_rdi_key(graph, rdbg, result);
result = tg_direct_from_graph_rdi_key(graph, rdi, result);
if(kind == TG_Kind_Ptr || kind == TG_Kind_LRef || kind == TG_Kind_RRef)
{
passed_ptr = 1;
@@ -874,7 +874,7 @@ tg_ptee_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
}
internal TG_Key
tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_Key result = key;
for(B32 good = 1; good;)
@@ -884,7 +884,7 @@ tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
kind == TG_Kind_Modifier ||
kind == TG_Kind_Alias)
{
result = tg_direct_from_graph_rdi_key(graph, rdbg, result);
result = tg_direct_from_graph_rdi_key(graph, rdi, result);
}
else
{
@@ -895,7 +895,7 @@ tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
}
internal U64
tg_byte_size_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_byte_size_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
U64 result = 0;
switch(key.kind)
@@ -910,7 +910,7 @@ tg_byte_size_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
case TG_KeyKind_Cons:
{
Temp scratch = scratch_begin(0, 0);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
result = type->byte_size;
scratch_end(scratch);
}break;
@@ -945,12 +945,12 @@ tg_member_copy(Arena *arena, TG_Member *src)
}
internal TG_MemberArray
tg_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
TG_MemberArray result = {0};
Temp scratch = scratch_begin(&arena, 1);
{
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
if(type->members != 0)
{
result.count = type->count;
@@ -967,7 +967,7 @@ tg_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, T
}
internal TG_MemberArray
tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
Temp scratch = scratch_begin(&arena, 1);
TG_Kind root_type_kind = tg_kind_from_key(key);
@@ -976,7 +976,7 @@ tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rd
TG_MemberList members_list = {0};
B32 members_need_offset_sort = 0;
{
TG_Type *root_type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *root_type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
typedef struct Task Task;
struct Task
{
@@ -1015,7 +1015,7 @@ tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rd
t->inheritance_chain = tg_key_list_copy(scratch.arena, &task->inheritance_chain);
tg_key_list_push(scratch.arena, &t->inheritance_chain, type->members[member_idx].type_key);
t->type_key = type->members[member_idx].type_key;
t->type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, type->members[member_idx].type_key);
t->type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, type->members[member_idx].type_key);
SLLQueuePush(first_task, last_task, t);
members_need_offset_sort = 1;
}
@@ -1064,7 +1064,7 @@ tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rd
TG_Member *member = &members.v[idx];
if(idx+1 < members.count)
{
U64 member_byte_size = tg_byte_size_from_graph_rdi_key(graph, rdbg, member->type_key);
U64 member_byte_size = tg_byte_size_from_graph_rdi_key(graph, rdi, member->type_key);
Rng1U64 member_byte_range = r1u64(member->off, member->off + member_byte_size);
if(member[1].off > member_byte_range.max)
{
@@ -1111,7 +1111,7 @@ tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rd
}
internal void
tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key, String8List *out, U32 prec, B32 skip_return)
tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key, String8List *out, U32 prec, B32 skip_return)
{
String8 keyword = {0};
TG_Kind kind = tg_kind_from_key(key);
@@ -1120,7 +1120,7 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
default:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
str8_list_push(arena, out, push_str8_copy(arena, type->name));
str8_list_push(arena, out, str8_lit(" "));
scratch_end(scratch);
@@ -1128,16 +1128,16 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_Bitfield:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, prec, skip_return);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, prec, skip_return);
}break;
case TG_Kind_Modifier:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
TG_Key direct = type->direct_type_key;
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 1, skip_return);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 1, skip_return);
if(type->flags & TG_Flag_Const)
{
str8_list_push(arena, out, str8_lit("const "));
@@ -1161,7 +1161,7 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_Alias:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
str8_list_push(arena, out, push_str8_copy(arena, type->name));
str8_list_push(arena, out, str8_lit(" "));
scratch_end(scratch);
@@ -1174,7 +1174,7 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
fwd_udt:;
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
str8_list_push(arena, out, keyword);
str8_list_push(arena, out, str8_lit(" "));
str8_list_push(arena, out, push_str8_copy(arena, type->name));
@@ -1184,8 +1184,8 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_Array:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 2, skip_return);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 2, skip_return);
if(prec == 1)
{
str8_list_push(arena, out, str8_lit("("));
@@ -1196,8 +1196,8 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
{
if(!skip_return)
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 2, 0);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 2, 0);
}
if(prec == 1)
{
@@ -1207,32 +1207,32 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_Ptr:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 1, skip_return);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 1, skip_return);
str8_list_push(arena, out, str8_lit("*"));
}break;
case TG_Kind_LRef:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 1, skip_return);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 1, skip_return);
str8_list_push(arena, out, str8_lit("&"));
}break;
case TG_Kind_RRef:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 1, skip_return);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 1, skip_return);
str8_list_push(arena, out, str8_lit("&&"));
}break;
case TG_Kind_MemberPtr:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
TG_Key direct = type->direct_type_key;
tg_lhs_string_from_key(arena, graph, rdbg, direct, out, 1, skip_return);
TG_Type *container = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, type->owner_type_key);
tg_lhs_string_from_key(arena, graph, rdi, direct, out, 1, skip_return);
TG_Type *container = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, type->owner_type_key);
if(container->kind != TG_Kind_Null)
{
str8_list_push(arena, out, push_str8_copy(arena, container->name));
@@ -1248,7 +1248,7 @@ tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
}
internal void
tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key, String8List *out, U32 prec)
tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key, String8List *out, U32 prec)
{
TG_Kind kind = tg_kind_from_key(key);
switch(kind)
@@ -1257,8 +1257,8 @@ tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_Bitfield:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_rhs_string_from_key(arena, graph, rdbg, direct, out, prec);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_rhs_string_from_key(arena, graph, rdi, direct, out, prec);
}break;
case TG_Kind_Modifier:
@@ -1267,14 +1267,14 @@ tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
case TG_Kind_RRef:
case TG_Kind_MemberPtr:
{
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_rhs_string_from_key(arena, graph, rdbg, direct, out, 1);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_rhs_string_from_key(arena, graph, rdi, direct, out, 1);
}break;
case TG_Kind_Array:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
if(prec == 1)
{
str8_list_push(arena, out, str8_lit(")"));
@@ -1283,15 +1283,15 @@ tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
str8_list_push(arena, out, str8_lit("["));
str8_list_push(arena, out, count_str);
str8_list_push(arena, out, str8_lit("]"));
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_rhs_string_from_key(arena, graph, rdbg, direct, out, 2);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_rhs_string_from_key(arena, graph, rdi, direct, out, 2);
scratch_end(scratch);
}break;
case TG_Kind_Function:
{
Temp scratch = scratch_begin(&arena, 1);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdbg, key);
TG_Type *type = tg_type_from_graph_rdi_key(scratch.arena, graph, rdi, key);
if(prec == 1)
{
str8_list_push(arena, out, str8_lit(")"));
@@ -1310,7 +1310,7 @@ tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
for(U64 param_idx = 0; param_idx < param_count; param_idx += 1)
{
TG_Key param_type_key = param_type_keys[param_idx];
String8 param_str = tg_string_from_key(arena, graph, rdbg, param_type_key);
String8 param_str = tg_string_from_key(arena, graph, rdi, param_type_key);
String8 param_str_trimmed = str8_skip_chop_whitespace(param_str);
str8_list_push(arena, out, param_str_trimmed);
if(param_idx+1 < param_count)
@@ -1320,20 +1320,20 @@ tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key k
}
str8_list_push(arena, out, str8_lit(")"));
}
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdbg, key);
tg_rhs_string_from_key(arena, graph, rdbg, direct, out, 2);
TG_Key direct = tg_direct_from_graph_rdi_key(graph, rdi, key);
tg_rhs_string_from_key(arena, graph, rdi, direct, out, 2);
scratch_end(scratch);
}break;
}
}
internal String8
tg_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key)
tg_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key)
{
Temp scratch = scratch_begin(&arena, 1);
String8List list = {0};
tg_lhs_string_from_key(scratch.arena, graph, rdbg, key, &list, 0, 0);
tg_rhs_string_from_key(scratch.arena, graph, rdbg, key, &list, 0);
tg_lhs_string_from_key(scratch.arena, graph, rdi, key, &list, 0, 0);
tg_rhs_string_from_key(scratch.arena, graph, rdi, key, &list, 0);
String8 result = str8_list_join(arena, &list, 0);
scratch_end(scratch);
return result;
src/type_graph/type_graph.h
+12 -12
View File
@@ -225,19 +225,19 @@ internal TG_Key tg_cons_type_make(TG_Graph *graph, TG_Kind kind, TG_Key direct_t
////////////////////////////////
//~ rjf: Graph Introspection API
internal TG_Type *tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Key tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Key tg_unwrapped_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Key tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Key tg_ptee_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Key tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal U64 tg_byte_size_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_Type *tg_type_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key tg_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key tg_unwrapped_direct_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key tg_owner_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key tg_ptee_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key tg_unwrapped_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal U64 tg_byte_size_from_graph_rdi_key(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Kind tg_kind_from_key(TG_Key key);
internal TG_Member *tg_member_copy(Arena *arena, TG_Member *src);
internal TG_MemberArray tg_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_MemberArray tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal void tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key, String8List *out, U32 prec, B32 skip_return);
internal void tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key, String8List *out, U32 prec);
internal String8 tg_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdbg, TG_Key key);
internal TG_MemberArray tg_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_MemberArray tg_data_members_from_graph_rdi_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal void tg_lhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key, String8List *out, U32 prec, B32 skip_return);
internal void tg_rhs_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key, String8List *out, U32 prec);
internal String8 tg_string_from_key(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
#endif // TYPE_GRAPH_H