1082 lines
44 KiB
C++
1082 lines
44 KiB
C++
/*
|
|
* Mr. 4th Dimention - Allen Webster
|
|
*
|
|
* 14.08.2019
|
|
*
|
|
* Log parser.
|
|
*
|
|
*/
|
|
|
|
// TOP
|
|
|
|
internal u64
|
|
log_parse__string_code(Log_Parse *parse, String_Const_u8 string, Log_String_Source string_source){
|
|
u64 result = 0;
|
|
if (string.size > 0){
|
|
String_Const_u8 data = make_data(string.str, string.size);
|
|
Table_Lookup lookup = table_lookup(&parse->string_to_id_table, data);
|
|
if (lookup.found_match){
|
|
table_read(&parse->string_to_id_table, lookup, &result);
|
|
}
|
|
else{
|
|
if (string_source == LogParse_ExternalString){
|
|
data = push_data_copy(parse->arena, data);
|
|
}
|
|
result = parse->string_id_counter;
|
|
parse->string_id_counter += 1;
|
|
table_insert(&parse->string_to_id_table, data, result);
|
|
table_insert(&parse->id_to_string_table, result, data);
|
|
}
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal String_Const_u8
|
|
log_parse__get_string(Log_Parse *parse, u64 code){
|
|
Table_Lookup lookup = table_lookup(&parse->id_to_string_table, code);
|
|
String_Const_u8 result = {};
|
|
if (lookup.found_match){
|
|
table_read(&parse->id_to_string_table, lookup, &result);
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Event*
|
|
log_parse__event(Log_Parse *parse,
|
|
String_Const_u8 file_name, String_Const_u8 line_number, String_Const_u8 event_name){
|
|
Log_Event *new_event = push_array(parse->arena, Log_Event, 1);
|
|
sll_queue_push(parse->first_event, parse->last_event, new_event);
|
|
parse->event_count += 1;
|
|
new_event->src_file_name = log_parse__string_code(parse, file_name, LogParse_ExternalString);
|
|
new_event->event_name = log_parse__string_code(parse, event_name, LogParse_ExternalString);
|
|
new_event->line_number = string_to_integer(line_number, 10);
|
|
new_event->event_number = parse->event_count;
|
|
return(new_event);
|
|
}
|
|
|
|
internal Log_Tag*
|
|
log_parse__tag(Log_Parse *parse, Log_Event *event, String_Const_u8 tag_name, String_Const_u8 tag_value){
|
|
Log_Tag *new_tag = push_array(parse->arena, Log_Tag, 1);
|
|
sll_queue_push(event->first_tag, event->last_tag, new_tag);
|
|
event->tag_count += 1;
|
|
new_tag->name = log_parse__string_code(parse, tag_name, LogParse_ExternalString);
|
|
if (tag_value.size == 0){
|
|
new_tag->value.kind = LogTagKind_String;
|
|
new_tag->value.value = 0;
|
|
}
|
|
else{
|
|
if (tag_value.str[0] == '"'){
|
|
if (tag_value.size == 1){
|
|
new_tag->value.kind = LogTagKind_String;
|
|
new_tag->value.value = 0;
|
|
}
|
|
else{
|
|
tag_value = string_skip(tag_value, 1);
|
|
if (tag_value.str[tag_value.size - 1] == '"'){
|
|
tag_value = string_chop(tag_value, 1);
|
|
}
|
|
String_Const_u8 escape = string_interpret_escapes(parse->arena, tag_value);
|
|
new_tag->value.kind = LogTagKind_String;
|
|
new_tag->value.value = log_parse__string_code(parse, escape, LogParse_PreAllocatedString);
|
|
}
|
|
}
|
|
else{
|
|
new_tag->value.kind = LogTagKind_Integer;
|
|
b32 is_negative = false;
|
|
if (string_match(string_prefix(tag_value, 1), string_u8_litexpr("-"))){
|
|
tag_value = string_skip(tag_value, 1);
|
|
is_negative = true;
|
|
}
|
|
if (string_match(string_prefix(tag_value, 2), string_u8_litexpr("0x"))){
|
|
tag_value = string_skip(tag_value, 2);
|
|
new_tag->value.value_s = (i64)string_to_integer(tag_value, 16);
|
|
}
|
|
else{
|
|
new_tag->value.value_s = (i64)string_to_integer(tag_value, 10);
|
|
}
|
|
if (is_negative){
|
|
new_tag->value.value_s = -new_tag->value.value_s;
|
|
}
|
|
}
|
|
}
|
|
return(new_tag);
|
|
}
|
|
|
|
internal Log_Event_List*
|
|
log_parse_get_list_tag_value(Log_Parse *parse, u64 name, Log_Tag_Value value){
|
|
Log_Event_List *result = 0;
|
|
Log_Tag_Name_Value key = {name, value};
|
|
Table_Lookup lookup = table_lookup(&parse->tag_value_to_event_list_table, make_data_struct(&key));
|
|
if (lookup.found_match){
|
|
u64 val = 0;
|
|
table_read(&parse->tag_value_to_event_list_table, lookup, &val);
|
|
result = (Log_Event_List*)IntAsPtr(val);
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Event_List*
|
|
log_parse__get_or_make_list_tag_value(Log_Parse *parse, Log_Tag *tag){
|
|
Log_Event_List *result = 0;
|
|
Log_Tag_Name_Value key = {tag->name, tag->value};
|
|
String_Const_u8 data_key = make_data_struct(&key);
|
|
Table_Lookup lookup = table_lookup(&parse->tag_value_to_event_list_table, data_key);
|
|
if (lookup.found_match){
|
|
u64 val = 0;
|
|
table_read(&parse->tag_value_to_event_list_table, lookup, &val);
|
|
result = (Log_Event_List*)IntAsPtr(val);
|
|
}
|
|
else{
|
|
result = push_array_zero(parse->arena, Log_Event_List, 1);
|
|
table_insert(&parse->tag_value_to_event_list_table, push_data_copy(parse->arena, data_key),
|
|
(u64)PtrAsInt(result));
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Event_List*
|
|
log_parse_get_list_tag_name(Log_Parse *parse, u64 name){
|
|
Log_Event_List *result = 0;
|
|
Table_Lookup lookup = table_lookup(&parse->tag_name_to_event_list_table, name);
|
|
if (lookup.found_match){
|
|
u64 val = 0;
|
|
table_read(&parse->tag_name_to_event_list_table, lookup, &val);
|
|
result = (Log_Event_List*)IntAsPtr(val);
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Event_List*
|
|
log_parse__get_or_make_list_tag_name(Log_Parse *parse, Log_Tag *tag){
|
|
Log_Event_List *result = 0;
|
|
Table_Lookup lookup = table_lookup(&parse->tag_name_to_event_list_table, tag->name);
|
|
if (lookup.found_match){
|
|
u64 val = 0;
|
|
table_read(&parse->tag_name_to_event_list_table, lookup, &val);
|
|
result = (Log_Event_List*)IntAsPtr(val);
|
|
}
|
|
else{
|
|
result = push_array_zero(parse->arena, Log_Event_List, 1);
|
|
table_insert(&parse->tag_name_to_event_list_table, tag->name, (u64)PtrAsInt(result));
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Parse
|
|
make_log_parse(Arena *arena, String_Const_u8 source){
|
|
Log_Parse parse = {};
|
|
parse.arena = arena;
|
|
parse.string_id_counter = 1;
|
|
parse.string_to_id_table = make_table_Data_u64(arena->base_allocator, 500);
|
|
parse.id_to_string_table = make_table_u64_Data(arena->base_allocator, 500);
|
|
|
|
for (;source.size > 0;){
|
|
u64 end_of_line = string_find_first(source, '\n');
|
|
String_Const_u8 line = string_prefix(source, end_of_line);
|
|
line = string_skip_chop_whitespace(line);
|
|
source = string_skip(source, end_of_line + 1);
|
|
|
|
String_Const_u8 src_file_name = {};
|
|
String_Const_u8 src_line_number = {};
|
|
b32 got_source_position = false;
|
|
|
|
String_Const_u8 whole_line = line;
|
|
|
|
{
|
|
u64 colon1 = string_find_first(line, ':');
|
|
src_file_name = string_prefix(line, colon1);
|
|
line = string_skip(line, colon1 + 1);
|
|
|
|
u64 colon2 = string_find_first(line, ':');
|
|
src_line_number = string_prefix(line, colon2);
|
|
line = string_skip(line, colon2 + 1);
|
|
|
|
if (string_is_integer(src_line_number, 10)){
|
|
got_source_position = true;
|
|
}
|
|
}
|
|
|
|
if (!got_source_position){
|
|
line = whole_line;
|
|
|
|
u64 colon0 = string_find_first(line, ':');
|
|
u64 colon1 = string_find_first(line, colon0 + 1, ':');
|
|
src_file_name = string_prefix(line, colon1);
|
|
line = string_skip(line, colon1 + 1);
|
|
|
|
u64 colon2 = string_find_first(line, ':');
|
|
src_line_number = string_prefix(line, colon2);
|
|
line = string_skip(line, colon2 + 1);
|
|
|
|
if (string_is_integer(src_line_number, 10)){
|
|
got_source_position = true;
|
|
}
|
|
}
|
|
|
|
if (got_source_position){
|
|
u64 bracket_open = string_find_first(line, '[');
|
|
String_Const_u8 event_name = string_prefix(line, bracket_open);
|
|
event_name = string_skip_chop_whitespace(event_name);
|
|
line = string_skip(line, bracket_open + 1);
|
|
|
|
Log_Event *event = log_parse__event(&parse,
|
|
src_file_name, src_line_number, event_name);
|
|
|
|
for (;line.size > 0;){
|
|
u64 bracket_close = string_find_first(line, ']');
|
|
String_Const_u8 tag = string_prefix(line, bracket_close);
|
|
line = string_skip(line, bracket_close + 1);
|
|
bracket_open = string_find_first(line, '[');
|
|
line = string_skip(line, bracket_open + 1);
|
|
|
|
u64 equal_sign = string_find_first(tag, '=');
|
|
String_Const_u8 tag_name = string_prefix(tag, equal_sign);
|
|
String_Const_u8 tag_contents = string_skip(tag, equal_sign + 1);
|
|
|
|
log_parse__tag(&parse, event, tag_name, tag_contents);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////
|
|
|
|
// NOTE(allen): fill acceleration structures
|
|
|
|
parse.tag_value_to_event_list_table = make_table_Data_u64(arena->base_allocator, Thousand(1));
|
|
parse.tag_name_to_event_list_table = make_table_u64_u64(arena->base_allocator, 100);
|
|
|
|
for (Log_Event *event = parse.first_event;
|
|
event != 0;
|
|
event = event->next){
|
|
for (Log_Tag *tag = event->first_tag;
|
|
tag != 0;
|
|
tag = tag->next){
|
|
{
|
|
Log_Event_List *list = log_parse__get_or_make_list_tag_value(&parse, tag);
|
|
Log_Event_Ptr_Node *node = push_array(arena, Log_Event_Ptr_Node, 1);
|
|
sll_queue_push(list->first, list->last, node);
|
|
list->count += 1;
|
|
node->event = event;
|
|
}
|
|
{
|
|
Log_Event_List *list = log_parse__get_or_make_list_tag_name(&parse, tag);
|
|
Log_Event_Ptr_Node *node = push_array(arena, Log_Event_Ptr_Node, 1);
|
|
sll_queue_push(list->first, list->last, node);
|
|
list->count += 1;
|
|
node->event = event;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Log_Event *event = parse.first_event;
|
|
event != 0;
|
|
event = event->next){
|
|
i32 slot_count = event->tag_count*3/2;
|
|
event->tag_name_to_tag_ptr_table = make_table_u64_u64(arena->base_allocator, slot_count);
|
|
for (Log_Tag *tag = event->first_tag;
|
|
tag != 0;
|
|
tag = tag->next){
|
|
table_insert(&event->tag_name_to_tag_ptr_table, tag->name, (u64)PtrAsInt(tag));
|
|
}
|
|
}
|
|
|
|
return(parse);
|
|
}
|
|
|
|
////////////////////////////////
|
|
|
|
internal void
|
|
log_events_sort_by_tag__inner(Log_Event **events, Log_Sort_Key *keys, i32 first, i32 one_past_last){
|
|
if (first + 1 < one_past_last){
|
|
i32 pivot_index = one_past_last - 1;
|
|
Log_Sort_Key *pivot_key = keys + pivot_index;
|
|
i32 j = first;
|
|
for (i32 i = first; i < one_past_last; i += 1){
|
|
Log_Sort_Key *key = keys + i;
|
|
b32 key_is_less_than_pivot_key = false;
|
|
if (key->value.kind < pivot_key->value.kind){
|
|
key_is_less_than_pivot_key = true;
|
|
}
|
|
else if (key->value.kind == pivot_key->value.kind){
|
|
if (key->value.value < pivot_key->value.value){
|
|
key_is_less_than_pivot_key = true;
|
|
}
|
|
else if (key->value.value == pivot_key->value.value){
|
|
if (key->number < pivot_key->number){
|
|
key_is_less_than_pivot_key = true;
|
|
}
|
|
}
|
|
}
|
|
if (key_is_less_than_pivot_key){
|
|
if (j < i){
|
|
Swap(Log_Event*, events[i], events[j]);
|
|
Swap(Log_Sort_Key, keys[i], keys[j]);
|
|
}
|
|
j += 1;
|
|
}
|
|
}
|
|
Swap(Log_Event*, events[pivot_index], events[j]);
|
|
Swap(Log_Sort_Key, keys[pivot_index], keys[j]);
|
|
log_events_sort_by_tag__inner(events, keys, first, j);
|
|
log_events_sort_by_tag__inner(events, keys, j + 1, one_past_last);
|
|
}
|
|
}
|
|
|
|
internal void
|
|
log_events_sort_by_tag(Arena *scratch, Log_Event_Ptr_Array array, u64 tag_name){
|
|
Temp_Memory temp = begin_temp(scratch);
|
|
Log_Sort_Key *keys = push_array(scratch, Log_Sort_Key, array.count);
|
|
for (i32 i = 0; i < array.count; i += 1){
|
|
Log_Event *event = array.events[i];
|
|
Table_Lookup lookup = table_lookup(&event->tag_name_to_tag_ptr_table, tag_name);
|
|
if (lookup.found_match){
|
|
u64 read_val = 0;
|
|
table_read(&event->tag_name_to_tag_ptr_table, lookup, &read_val);
|
|
Log_Tag *tag = (Log_Tag*)IntAsPtr(read_val);
|
|
keys[i].value = tag->value;
|
|
}
|
|
else{
|
|
keys[i].value.kind = LogTagKind_Null;
|
|
keys[i].value.value = 0;
|
|
}
|
|
keys[i].number = event->event_number;
|
|
}
|
|
|
|
log_events_sort_by_tag__inner(array.events, keys, 0, array.count);
|
|
|
|
end_temp(temp);
|
|
}
|
|
|
|
internal Log_Event_Ptr_Array
|
|
log_event_array_from_list(Arena *arena, Log_Event_List list){
|
|
Log_Event_Ptr_Array array = {};
|
|
array.count = list.count;
|
|
array.events = push_array(arena, Log_Event*, array.count);
|
|
i32 counter = 0;
|
|
for (Log_Event_Ptr_Node *node = list.first;
|
|
node != 0;
|
|
node = node->next){
|
|
array.events[counter] = node->event;
|
|
counter += 1;
|
|
}
|
|
return(array);
|
|
}
|
|
|
|
////////////////////////////////
|
|
|
|
global View_ID log_view = 0;
|
|
global Arena log_arena = {};
|
|
global Log_Parse log_parse = {};
|
|
global Log_Graph log_graph = {};
|
|
global Log_Filter_Set log_filter_set = {};
|
|
global Log_Filter_Set log_preview_set = {};
|
|
|
|
internal void
|
|
log_filter_set_init(Log_Filter_Set *set){
|
|
block_zero_struct(set);
|
|
for (i32 i = ArrayCount(set->filters_memory) - 1; i >= 0; i -= 1){
|
|
sll_stack_push(set->free_filters, &set->filters_memory[i]);
|
|
}
|
|
}
|
|
|
|
internal Log_Filter_Set*
|
|
log_filter_set_from_tab(Log_Graph_List_Tab tab){
|
|
Log_Filter_Set *result = 0;
|
|
switch (tab){
|
|
case LogTab_Filters:
|
|
{
|
|
result = &log_filter_set;
|
|
}break;
|
|
case LogTab_Previews:
|
|
{
|
|
result = &log_preview_set;
|
|
}break;
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Filter*
|
|
log_filter_set__new_filter(Log_Filter_Set *set, Log_Filter *prototype){
|
|
Log_Filter *result = set->free_filters;
|
|
if (result != 0){
|
|
for (Log_Filter *filter = set->first;
|
|
filter != 0;
|
|
filter = filter->next){
|
|
if (filter->kind == prototype->kind &&
|
|
filter->tag_name_code == prototype->tag_name_code &&
|
|
block_match_struct(&filter->tag_value, &prototype->tag_value)){
|
|
result = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (result != 0){
|
|
sll_stack_pop(set->free_filters);
|
|
block_copy_struct(result, prototype);
|
|
zdll_push_back(set->first, set->last, result);
|
|
set->count += 1;
|
|
set->alter_counter += 1;
|
|
}
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal void
|
|
log_filter_set__free_filter(Log_Filter_Set *set, Log_Filter *filter){
|
|
zdll_remove(set->first, set->last, filter);
|
|
set->count -= 1;
|
|
set->alter_counter += 1;
|
|
sll_stack_push(set->free_filters, filter);
|
|
}
|
|
|
|
internal void
|
|
log_graph_fill(Application_Links *app, Rect_f32 layout_region, Face_ID face_id){
|
|
if (log_parse.arena != 0){
|
|
if (log_graph.holding_temp){
|
|
end_temp(log_graph.temp);
|
|
}
|
|
block_zero_struct(&log_graph);
|
|
log_graph.holding_temp = true;
|
|
log_graph.temp = begin_temp(&log_arena);
|
|
log_graph.layout_region = layout_region;
|
|
log_graph.face_id = face_id;
|
|
log_graph.filter_alter_counter = log_filter_set.alter_counter;
|
|
log_graph.preview_alter_counter = log_preview_set.alter_counter;
|
|
log_graph.tab = LogTab_Filters;
|
|
|
|
f32 details_h = rect_height(layout_region)*.22f;
|
|
details_h = clamp_top(details_h, 250.f);
|
|
|
|
Rect_f32 details_region = Rf32(layout_region.x0, layout_region.y0,
|
|
layout_region.x1, layout_region.y0 + details_h);
|
|
Rect_f32 event_list_region = Rf32(layout_region.x0, layout_region.y0 + details_h,
|
|
layout_region.x1, layout_region.y1);
|
|
|
|
log_graph.details_region = details_region;
|
|
log_graph.details_region.p0 -= layout_region.p0;
|
|
log_graph.details_region.p1 -= layout_region.p0;
|
|
|
|
u64 thread_code = log_parse__string_code(&log_parse, string_u8_litexpr("thread"),
|
|
LogParse_ExternalString);
|
|
|
|
if (log_filter_set.count == 0){
|
|
// NOTE(allen): everything goes into the filtered list
|
|
for (Log_Event *event = log_parse.first_event;
|
|
event != 0;
|
|
event = event->next){
|
|
Log_Event_Ptr_Node *node = push_array(&log_arena, Log_Event_Ptr_Node, 1);
|
|
node->event = event;
|
|
sll_queue_push(log_graph.filtered_list.first, log_graph.filtered_list.last, node);
|
|
log_graph.filtered_list.count += 1;
|
|
}
|
|
}
|
|
else{
|
|
for (Log_Filter *filter = log_filter_set.first;
|
|
filter != 0;
|
|
filter = filter->next){
|
|
Log_Event_List *filter_list = 0;
|
|
if (filter->kind == LogFilter_TagValue){
|
|
filter_list = log_parse_get_list_tag_value(&log_parse, filter->tag_name_code,
|
|
filter->tag_value);
|
|
}
|
|
else if (filter->kind == LogFilter_Tag){
|
|
filter_list = log_parse_get_list_tag_name(&log_parse, filter->tag_name_code);
|
|
}
|
|
|
|
// NOTE(allen): combine with existing result
|
|
if (filter == log_filter_set.first){
|
|
for (Log_Event_Ptr_Node *node = filter_list->first;
|
|
node != 0;
|
|
node = node->next){
|
|
Log_Event_Ptr_Node *new_node = push_array(&log_arena, Log_Event_Ptr_Node, 1);
|
|
new_node->event = node->event;
|
|
sll_queue_push(log_graph.filtered_list.first, log_graph.filtered_list.last, new_node);
|
|
log_graph.filtered_list.count += 1;
|
|
}
|
|
}
|
|
else{
|
|
Log_Event_Ptr_Node **fixup_ptr = &log_graph.filtered_list.first;
|
|
log_graph.filtered_list.last = 0;
|
|
for (Log_Event_Ptr_Node *node_a = log_graph.filtered_list.first, *next = 0;
|
|
node_a != 0;
|
|
node_a = next){
|
|
next = node_a->next;
|
|
|
|
b32 remove_node_a = true;
|
|
for (Log_Event_Ptr_Node *node_b = filter_list->first;
|
|
node_b != 0;
|
|
node_b = node_b->next){
|
|
if (node_a->event == node_b->event){
|
|
remove_node_a = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (remove_node_a){
|
|
*fixup_ptr = next;
|
|
}
|
|
else{
|
|
fixup_ptr = &node_a->next;
|
|
log_graph.filtered_list.last = node_a;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
log_graph.event_array = log_event_array_from_list(&log_arena, log_graph.filtered_list);
|
|
log_events_sort_by_tag(&log_arena, log_graph.event_array, thread_code);
|
|
|
|
b32 had_a_tag = true;
|
|
u64 thread_id_value = 0;
|
|
Log_Graph_Thread_Bucket *prev_bucket = 0;
|
|
|
|
for (i32 i = 0; i < log_graph.event_array.count; i += 1){
|
|
Table_u64_u64 *tag_table = &log_graph.event_array.events[i]->tag_name_to_tag_ptr_table;
|
|
Table_Lookup lookup = table_lookup(tag_table, thread_code);
|
|
|
|
b32 emit_next_bucket = false;
|
|
if (!lookup.found_match){
|
|
if (had_a_tag){
|
|
had_a_tag = false;
|
|
thread_id_value = 0;
|
|
emit_next_bucket = true;
|
|
}
|
|
}
|
|
else{
|
|
u64 read_val = 0;
|
|
table_read(tag_table, lookup, &read_val);
|
|
Log_Tag *tag = (Log_Tag*)IntAsPtr(read_val);
|
|
if (!had_a_tag){
|
|
had_a_tag = true;
|
|
thread_id_value = tag->value.value;
|
|
emit_next_bucket = true;
|
|
}
|
|
else if (thread_id_value != tag->value.value){
|
|
thread_id_value = tag->value.value;
|
|
emit_next_bucket = true;
|
|
}
|
|
}
|
|
|
|
if (emit_next_bucket){
|
|
Log_Graph_Thread_Bucket *bucket = push_array(&log_arena, Log_Graph_Thread_Bucket, 1);
|
|
sll_queue_push(log_graph.first_bucket, log_graph.last_bucket, bucket);
|
|
log_graph.bucket_count += 1;
|
|
bucket->range.first = i;
|
|
bucket->had_a_tag = had_a_tag;
|
|
bucket->thread_id_value = thread_id_value;
|
|
if (prev_bucket != 0){
|
|
prev_bucket->range.one_past_last = i;
|
|
}
|
|
prev_bucket = bucket;
|
|
}
|
|
}
|
|
if (prev_bucket != 0){
|
|
prev_bucket->range.one_past_last = log_graph.event_array.count;
|
|
}
|
|
|
|
Face_Metrics metrics = get_face_metrics(app, face_id);
|
|
f32 line_height = metrics.line_height;
|
|
f32 box_h = f32_floor32(line_height*1.5f);
|
|
f32 box_w = f32_floor32(rect_width(event_list_region)/log_graph.bucket_count);
|
|
f32 y_cursor = event_list_region.y0 - layout_region.y0;
|
|
|
|
if (log_graph.bucket_count > 0){
|
|
f32 y_bottom = 0.f;
|
|
|
|
for (;;){
|
|
i32 smallest_event_number = max_i32;
|
|
i32 bucket_with_next_event_index = -1;
|
|
Log_Graph_Thread_Bucket *bucket_with_next_event = 0;
|
|
Log_Event *next_event = 0;
|
|
i32 iteration_counter = 0;
|
|
for (Log_Graph_Thread_Bucket *bucket = log_graph.first_bucket;
|
|
bucket != 0;
|
|
bucket = bucket->next, iteration_counter += 1){
|
|
if (bucket->range.first < bucket->range.one_past_last){
|
|
Log_Event *event = log_graph.event_array.events[bucket->range.first];
|
|
if (event->event_number < smallest_event_number){
|
|
smallest_event_number = event->event_number;
|
|
bucket_with_next_event_index = iteration_counter;
|
|
bucket_with_next_event = bucket;
|
|
next_event = event;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bucket_with_next_event == 0){
|
|
break;
|
|
}
|
|
|
|
bucket_with_next_event->range.first += 1;
|
|
|
|
Log_Graph_Box *box_node = push_array(&log_arena, Log_Graph_Box, 1);
|
|
sll_queue_push(log_graph.first_box, log_graph.last_box, box_node);
|
|
log_graph.box_count += 1;
|
|
Rect_f32 rect = Rf32(box_w*bucket_with_next_event_index , y_cursor,
|
|
box_w*(bucket_with_next_event_index + 1), y_cursor + box_h);
|
|
box_node->rect = rect;
|
|
box_node->event = next_event;
|
|
|
|
y_bottom = Max(y_bottom, rect.y1);
|
|
|
|
y_cursor += box_h;
|
|
}
|
|
|
|
log_graph.max_y_scroll = clamp_bot(line_height, y_bottom - rect_height(event_list_region)*0.5f);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void
|
|
log_parse_fill(Application_Links *app, Buffer_ID buffer){
|
|
if (log_arena.base_allocator == 0){
|
|
log_arena = make_arena_system();
|
|
}
|
|
|
|
linalloc_clear(&log_arena);
|
|
block_zero_struct(&log_graph);
|
|
log_filter_set_init(&log_filter_set);
|
|
log_filter_set_init(&log_preview_set);
|
|
|
|
String_Const_u8 log_text = push_whole_buffer(app, &log_arena, buffer);
|
|
log_parse = make_log_parse(&log_arena, log_text);
|
|
}
|
|
|
|
internal void
|
|
log_graph_render__tag(Arena *arena, Fancy_Line *line,
|
|
Log_Parse *log, Log_Tag *tag){
|
|
String_Const_u8 tag_name = log_parse__get_string(log, tag->name);
|
|
push_fancy_stringf(arena, line, f_white, "[");
|
|
push_fancy_string(arena, line, f_green, tag_name);
|
|
push_fancy_stringf(arena, line, f_white, "=");
|
|
if (tag->value.kind == LogTagKind_Integer){
|
|
push_fancy_stringf(arena, line, f_pink, "0x%llx", tag->value.value_s);
|
|
}
|
|
else if (tag->value.kind == LogTagKind_String){
|
|
String_Const_u8 value = log_parse__get_string(log, tag->value.value);
|
|
push_fancy_string(arena, line, f_pink, value);
|
|
}
|
|
push_fancy_stringf(arena, line, f_white, "]");
|
|
}
|
|
|
|
internal void
|
|
log_graph_render(Application_Links *app, Frame_Info frame_info, View_ID view){
|
|
if (log_parse.arena != 0){
|
|
////////////////////////////////
|
|
View_ID active_view = get_active_view(app, Access_Always);
|
|
b32 is_active_view = (active_view == view);
|
|
|
|
Rect_f32 view_rect = view_get_screen_rect(app, view);
|
|
Rect_f32 inner = rect_inner(view_rect, 3);
|
|
draw_rectangle_fcolor(app, view_rect, 0.f,
|
|
get_item_margin_color(is_active_view?UIHighlight_Active:UIHighlight_None));
|
|
draw_rectangle_fcolor(app, inner, 0.f, fcolor_id(defcolor_back));
|
|
|
|
Rect_f32 prev_clip = draw_set_clip(app, inner);
|
|
////////////////////////////////
|
|
|
|
Face_ID face_id = get_face_id(app, 0);
|
|
f32 y_scroll = log_graph.y_scroll;
|
|
Log_Event *selected_event = log_graph.selected_event;
|
|
if (!log_graph.holding_temp ||
|
|
inner != log_graph.layout_region ||
|
|
face_id != log_graph.face_id ||
|
|
log_filter_set.alter_counter != log_graph.filter_alter_counter){
|
|
log_graph_fill(app, inner, face_id);
|
|
}
|
|
log_graph.y_scroll = clamp(0.f, y_scroll, log_graph.max_y_scroll);
|
|
log_graph.selected_event = selected_event;
|
|
|
|
Mouse_State mouse = get_mouse_state(app);
|
|
Vec2_f32 m_p = V2f32(mouse.p) - inner.p0;
|
|
|
|
Face_Metrics metrics = get_face_metrics(app, log_graph.face_id);
|
|
f32 line_height = metrics.line_height;
|
|
|
|
Log_Event *hover_event = 0;
|
|
|
|
b32 in_details_region = (rect_contains_point(log_graph.details_region, m_p));
|
|
|
|
for (Log_Graph_Box *box_node = log_graph.first_box;
|
|
box_node != 0;
|
|
box_node = box_node->next){
|
|
Scratch_Block scratch(app);
|
|
|
|
Rect_f32 box = box_node->rect;
|
|
box.y0 -= log_graph.y_scroll;
|
|
box.y1 -= log_graph.y_scroll;
|
|
|
|
Rect_f32 box_inner = rect_inner(box, 3.f);
|
|
|
|
FColor margin_color = f_dark_gray;
|
|
if (!in_details_region && hover_event == 0 && rect_contains_point(box, m_p)){
|
|
margin_color = f_gray;
|
|
hover_event = box_node->event;
|
|
}
|
|
if (box_node->event == log_graph.selected_event){
|
|
margin_color = f_light_gray;
|
|
}
|
|
|
|
draw_rectangle_fcolor(app, box , 0.f, margin_color);
|
|
draw_rectangle_fcolor(app, box_inner, 0.f, f_black );
|
|
|
|
Log_Event *event = box_node->event;
|
|
|
|
String_Const_u8 event_name = log_parse__get_string(&log_parse, event->event_name);
|
|
Fancy_Line line = {};
|
|
push_fancy_string(scratch, &line, f_white, event_name);
|
|
|
|
for (Log_Filter *filter = log_preview_set.first;
|
|
filter != 0;
|
|
filter = filter->next){
|
|
Table_u64_u64 *table = &event->tag_name_to_tag_ptr_table;
|
|
Table_Lookup lookup = table_lookup(table, filter->tag_name_code);
|
|
if (lookup.found_match){
|
|
u64 val = 0;
|
|
table_read(table, lookup, &val);
|
|
Log_Tag *tag = (Log_Tag*)IntAsPtr(val);
|
|
push_fancy_string(scratch, &line, string_u8_litexpr(" "));
|
|
log_graph_render__tag(scratch, &line, &log_parse, tag);
|
|
}
|
|
}
|
|
|
|
|
|
Vec2_f32 p = V2f32(box_inner.x0 + 3.f,
|
|
(f32_round32((box_inner.y0 + box_inner.y1 - line_height)*0.5f)));
|
|
draw_fancy_line(app, log_graph.face_id, fcolor_zero(), &line, p);
|
|
}
|
|
|
|
{
|
|
Scratch_Block scratch(app);
|
|
|
|
Rect_f32 box = log_graph.details_region;
|
|
Rect_f32 box_inner = rect_inner(box, 3.f);
|
|
|
|
Log_Graph_List_Tab current_tab = log_graph.tab;
|
|
Log_Filter_Set *viewing_filter_set = log_filter_set_from_tab(current_tab);
|
|
|
|
draw_rectangle_fcolor(app, box , 0.f, f_dark_gray);
|
|
draw_rectangle_fcolor(app, box_inner, 0.f, f_black );
|
|
|
|
{
|
|
f32 y_cursor = box_inner.y0 + 3.f;
|
|
if (y_cursor + line_height > box_inner.y1) goto finish_list_display;
|
|
|
|
{
|
|
f32 x_cursor = box_inner.x0 + 3.f;
|
|
for (i32 i = LogTab_ERROR + 1; i < LogTab_COUNT; i += 1){
|
|
FColor color = (i == current_tab)?f_white:f_gray;
|
|
Fancy_Line line = {};
|
|
switch (i){
|
|
case LogTab_Filters:
|
|
{
|
|
push_fancy_stringf(scratch, &line, color, "filters");
|
|
}break;
|
|
case LogTab_Previews:
|
|
{
|
|
push_fancy_stringf(scratch, &line, color, "previews");
|
|
}break;
|
|
}
|
|
|
|
Vec2_f32 p = V2f32(x_cursor, y_cursor);
|
|
f32 width = get_fancy_line_width(app, log_graph.face_id,
|
|
&line);
|
|
draw_fancy_line(app, log_graph.face_id, fcolor_zero(),
|
|
&line, p);
|
|
x_cursor += width + metrics.normal_advance;
|
|
|
|
if (log_graph.has_unused_click){
|
|
Rect_f32 click_rect = Rf32_xy_wh(p.x, p.y,
|
|
width, line_height);
|
|
if (rect_contains_point(click_rect, log_graph.unused_click)){
|
|
log_graph.has_unused_click = false;
|
|
log_graph.tab = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (viewing_filter_set != 0){
|
|
for (Log_Filter *filter = viewing_filter_set->first, *next = 0;
|
|
filter != 0;
|
|
filter = next){
|
|
next = filter->next;
|
|
|
|
y_cursor += line_height;
|
|
if (y_cursor + line_height > box_inner.y1) goto finish_list_display;
|
|
|
|
Fancy_Line line = {};
|
|
|
|
if (filter->kind == LogFilter_TagValue){
|
|
push_fancy_stringf(scratch, &line, f_white, "val [");
|
|
String_Const_u8 tag_name = log_parse__get_string(&log_parse, filter->tag_name_code);
|
|
push_fancy_stringf(scratch, &line, f_green, "%.*s", string_expand(tag_name));
|
|
push_fancy_stringf(scratch, &line, f_white, "=");
|
|
if (filter->tag_value.kind == LogTagKind_Integer){
|
|
push_fancy_stringf(scratch, &line, f_pink, "0x%llx", filter->tag_value.value_s);
|
|
}
|
|
else if (filter->tag_value.kind == LogTagKind_String){
|
|
String_Const_u8 value = log_parse__get_string(&log_parse, filter->tag_value.value);
|
|
push_fancy_stringf(scratch, &line, f_pink, "%.*s", string_expand(value));
|
|
}
|
|
push_fancy_stringf(scratch, &line, f_white, "]");
|
|
}
|
|
else{
|
|
push_fancy_stringf(scratch, &line, f_white, "name [");
|
|
String_Const_u8 tag_name = log_parse__get_string(&log_parse, filter->tag_name_code);
|
|
push_fancy_stringf(scratch, &line, f_green, "%.*s", string_expand(tag_name));
|
|
push_fancy_stringf(scratch, &line, f_white, "]");
|
|
}
|
|
|
|
Vec2_f32 p = V2f32(box_inner.x0 + 3.f, y_cursor);
|
|
f32 width = get_fancy_line_width(app, log_graph.face_id,
|
|
&line);
|
|
draw_fancy_line(app, log_graph.face_id, fcolor_zero(),
|
|
&line, p);
|
|
|
|
if (log_graph.has_unused_click){
|
|
Rect_f32 click_rect = Rf32_xy_wh(p.x, p.y,
|
|
width, line_height);
|
|
if (rect_contains_point(click_rect, log_graph.unused_click)){
|
|
log_graph.has_unused_click = false;
|
|
log_filter_set__free_filter(viewing_filter_set, filter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
finish_list_display:;
|
|
}
|
|
|
|
Log_Event *view_event = (hover_event!=0)?hover_event:log_graph.selected_event;
|
|
if (view_event != 0){
|
|
f32 y_cursor = box_inner.y0 + 3.f;
|
|
if (y_cursor + line_height > box_inner.y1) goto finish_event_display;
|
|
|
|
{
|
|
Fancy_Line line = {};
|
|
String_Const_u8 file_name = log_parse__get_string(&log_parse, view_event->src_file_name);
|
|
push_fancy_stringf(scratch, &line, f_green, "[%d] ", view_event->event_number);
|
|
push_fancy_stringf(scratch, &line, f_white, "%.*s:", string_expand(file_name));
|
|
push_fancy_stringf(scratch, &line, f_pink, "%llu", view_event->line_number);
|
|
|
|
Vec2_f32 right_p = V2f32(box_inner.x1 - 3.f, y_cursor);
|
|
f32 width = get_fancy_line_width(app, log_graph.face_id, &line);
|
|
Vec2_f32 p = V2f32(right_p.x - width, right_p.y);
|
|
draw_fancy_line(app, log_graph.face_id, fcolor_zero(), &line, p);
|
|
}
|
|
|
|
for (Log_Tag *tag = view_event->first_tag;
|
|
tag != 0;
|
|
tag = tag->next){
|
|
y_cursor += line_height;
|
|
if (y_cursor + line_height > box_inner.y1) goto finish_event_display;
|
|
|
|
{
|
|
Fancy_Line line = {};
|
|
log_graph_render__tag(scratch, &line, &log_parse, tag);
|
|
|
|
Vec2_f32 right_p = V2f32(box_inner.x1 - 3.f, y_cursor);
|
|
f32 width = get_fancy_line_width(app, log_graph.face_id, &line);
|
|
Vec2_f32 p = V2f32(right_p.x - width, right_p.y);
|
|
draw_fancy_line(app, log_graph.face_id, fcolor_zero(),
|
|
&line, p);
|
|
|
|
if (log_graph.has_unused_click){
|
|
Rect_f32 click_rect = Rf32(p.x, p.y, right_p.x, p.y + line_height);
|
|
if (rect_contains_point(click_rect, log_graph.unused_click)){
|
|
log_graph.has_unused_click = false;
|
|
Log_Filter filter = {};
|
|
switch (log_graph.tab){
|
|
case LogTab_Filters:
|
|
{
|
|
filter.kind = LogFilter_TagValue;
|
|
filter.tag_name_code = tag->name;
|
|
filter.tag_value = tag->value;
|
|
}break;
|
|
case LogTab_Previews:
|
|
{
|
|
filter.kind = LogFilter_Tag;
|
|
filter.tag_name_code = tag->name;
|
|
}break;
|
|
}
|
|
if (filter.kind != LogTab_ERROR){
|
|
log_filter_set__new_filter(viewing_filter_set, &filter);
|
|
animate_in_n_milliseconds(app, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
finish_event_display:;
|
|
}
|
|
}
|
|
|
|
log_graph.has_unused_click = false;
|
|
draw_set_clip(app, prev_clip);
|
|
}
|
|
}
|
|
|
|
internal Log_Graph_Box*
|
|
log_graph__get_box_at_point(Log_Graph *graph, Vec2_f32 p){
|
|
Log_Graph_Box *result = 0;
|
|
if (!rect_contains_point(graph->details_region, p)){
|
|
for (Log_Graph_Box *box_node = graph->first_box;
|
|
box_node != 0;
|
|
box_node = box_node->next){
|
|
Rect_f32 box = box_node->rect;
|
|
box.y0 -= graph->y_scroll;
|
|
box.y1 -= graph->y_scroll;
|
|
if (rect_contains_point(box, p)){
|
|
result = box_node;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
internal Log_Graph_Box*
|
|
log_graph__get_box_at_mouse_point(Application_Links *app, Log_Graph *graph){
|
|
Mouse_State mouse = get_mouse_state(app);
|
|
Vec2_f32 m_p = V2f32(mouse.p) - graph->layout_region.p0;
|
|
return(log_graph__get_box_at_point(graph, m_p));
|
|
}
|
|
|
|
function void
|
|
log_graph__click_select_event(Application_Links *app, Vec2_f32 m_p)
|
|
{
|
|
if (log_view != 0 && log_graph.holding_temp){
|
|
Log_Graph_Box *box_node = log_graph__get_box_at_point(&log_graph, m_p);
|
|
if (box_node != 0){
|
|
log_graph.selected_event = box_node->event;
|
|
}
|
|
else{
|
|
log_graph.has_unused_click = true;
|
|
log_graph.unused_click = m_p;
|
|
}
|
|
}
|
|
}
|
|
|
|
function void
|
|
log_graph__click_jump_to_event_source(Application_Links *app, Vec2_f32 m_p){
|
|
if (log_view != 0 && log_graph.holding_temp){
|
|
Log_Graph_Box *box_node = log_graph__get_box_at_point(&log_graph, m_p);
|
|
if (box_node != 0){
|
|
Log_Event *event = box_node->event;
|
|
log_graph.selected_event = event;
|
|
|
|
View_ID target_view = get_next_view_looped_primary_panels(app, log_view,
|
|
Access_ReadVisible);
|
|
if (target_view != 0){
|
|
String_Const_u8 file_name = log_parse__get_string(&log_parse, event->src_file_name);
|
|
Buffer_ID target_buffer = get_buffer_by_file_name(app, file_name, Access_Always);
|
|
if (target_buffer == 0){
|
|
target_buffer = get_buffer_by_name(app, file_name, Access_Always);
|
|
}
|
|
if (target_buffer != 0){
|
|
set_view_to_location(app, target_view, target_buffer,
|
|
seek_line_col(event->line_number, 1));
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
log_graph.has_unused_click = true;
|
|
log_graph.unused_click = m_p;
|
|
}
|
|
}
|
|
}
|
|
|
|
CUSTOM_UI_COMMAND_SIG(show_the_log_graph)
|
|
CUSTOM_DOC("Parses *log* and displays the 'log graph' UI")
|
|
{
|
|
if (log_view != 0){
|
|
return;
|
|
}
|
|
|
|
Buffer_ID log_buffer = get_buffer_by_name(app, string_u8_litexpr("*log*"), Access_Always);
|
|
log_parse_fill(app, log_buffer);
|
|
|
|
log_view = get_this_ctx_view(app, Access_Always);
|
|
View_ID view = log_view;
|
|
|
|
View_Context ctx = view_current_context(app, view);
|
|
ctx.render_caller = log_graph_render;
|
|
View_Context_Block ctx_block(app, view, &ctx);
|
|
|
|
for (;;){
|
|
User_Input in = get_next_input(app, EventPropertyGroup_AnyUserInput, KeyCode_Escape);
|
|
if (in.abort){
|
|
view = 0;
|
|
break;
|
|
}
|
|
|
|
b32 handled = true;
|
|
switch (in.event.kind){
|
|
case InputEventKind_KeyStroke:
|
|
{
|
|
switch (in.event.key.code){
|
|
case KeyCode_PageUp:
|
|
{
|
|
log_graph.y_scroll -= get_page_jump(app, view);
|
|
}break;
|
|
|
|
case KeyCode_PageDown:
|
|
{
|
|
log_graph.y_scroll += get_page_jump(app, view);
|
|
}break;
|
|
|
|
default:
|
|
{
|
|
handled = false;
|
|
}break;
|
|
}
|
|
}break;
|
|
|
|
case InputEventKind_MouseButton:
|
|
{
|
|
Vec2_f32 m_p = V2f32(in.event.mouse.p) - log_graph.layout_region.p0;
|
|
switch (in.event.mouse.code){
|
|
case MouseCode_Left:
|
|
{
|
|
log_graph__click_jump_to_event_source(app, m_p);
|
|
}break;
|
|
|
|
case MouseCode_Right:
|
|
{
|
|
log_graph__click_select_event(app, m_p);
|
|
}break;
|
|
|
|
default:
|
|
{
|
|
handled = false;
|
|
}break;
|
|
}
|
|
}break;
|
|
|
|
case InputEventKind_MouseWheel:
|
|
{
|
|
f32 value = in.event.mouse_wheel.value;
|
|
log_graph.y_scroll += f32_round32(value);
|
|
}break;
|
|
|
|
default:
|
|
{
|
|
handled = false;
|
|
}break;
|
|
}
|
|
|
|
if (!handled){
|
|
if (ui_fallback_command_dispatch(app, view, &in)){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
log_view = 0;
|
|
}
|
|
|
|
// BOTTOM
|
|
|