felix
/
slime
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Przeglądaj źródła

visualizations have nice boxes and arrows diagrams for lists

master
Felix Brendel 7 lat temu
rodzic
79fa593519
commit
230d5d81fa
4 zmienionych plików z 2444 dodań i 977 usunięć
Widok podzielony
Opcje porównania
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania
  1. +2208
    -826
      bin/visualization.svg
  2. +19
    -99
      src/defines.cpp
  3. +20
    -0
      src/testing.cpp
  4. +197
    -52
      src/visualization.cpp

+ 2208
- 826
bin/visualization.svg
Plik diff jest za duży
Wyświetl plik


+ 19
- 99
src/defines.cpp Wyświetl plik

@@ -143,6 +143,25 @@ constexpr bool is_debug_build = false;
_merge_array_lists(arraylist, left, middle, right); \
} \
\
proc sorted_array_list_find(name##_Array_List* arraylist, type elem, int left=-1, int right=-1) -> int { \
if (left == -1) { \
return sorted_array_list_find(arraylist, elem, 0, arraylist->next_index - 1); \
} else if (left == right) { \
if ((size_t)arraylist->data[left] == (size_t)elem) \
return left; \
return -1; \
} else if (right < left) \
return -1; \
\
int middle = left + (right-left) / 2; \
\
if ((size_t)arraylist->data[middle] < (size_t)elem) \
return sorted_array_list_find(arraylist, elem, middle+1, right); \
if ((size_t)arraylist->data[middle] > (size_t)elem) \
return sorted_array_list_find(arraylist, elem, left, middle-1); \
return middle; \
} \
\
proc create_##name##_array_list(int initial_capacity = 16) -> name##_Array_List* { \
name##_Array_List* ret = new(name##_Array_List); \
ret->data = (type*)malloc(initial_capacity * sizeof(type)); \
@@ -152,105 +171,6 @@ constexpr bool is_debug_build = false;
}













// struct Int_Array_List {
// int* data;
// int length;
// int next_index;
// };

// proc remove_index_from_array_list(Int_Array_List* arraylist, int index) -> void {
// arraylist->data[index] = arraylist->data[--arraylist->next_index];
// }

// proc append_to_array_list(Int_Array_List* arraylist, int element) -> void {
// if (arraylist->next_index == arraylist->length) {
// arraylist->length *= 2;
// arraylist->data =
// (int*)realloc(arraylist->data, arraylist->length * sizeof(int));
// }
// arraylist->data[arraylist->next_index++] = element;
// }

// proc _merge_array_lists(Int_Array_List* arr, int start, int mid, int end) -> void {
// int start2 = mid + 1;

// /* If the direct merge is already sorted */
// if ((size_t)arr->data[mid] <= (size_t)arr->data[start2]) {
// return;
// }

// /* Two pointers to maintain start of both arrays to merge */
// while (start <= mid && start2 <= end) {
// if ((size_t)arr->data[start] <= (size_t)arr->data[start2]) {
// start++;
// }
// else {
// int value = arr->data[start2];
// int index = start2;

// /* Shift all the elements between element 1; element 2, right by 1. */
// while (index != start) {
// arr->data[index] = arr->data[index - 1];
// index--;
// }
// arr->data[start] = value;

// /* Update all the pointers */
// start++;
// mid++;
// start2++;
// }
// }
// }

// proc sort_array_list(Int_Array_List* arraylist, int left=-1, int right=-1) -> void {
// if (left == -1) {
// sort_array_list(arraylist, 0, arraylist->next_index - 1);
// return;
// } else if (left == right) {
// return;
// }

// int middle = left + (right-left) / 2;

// sort_array_list(arraylist, left, middle);
// sort_array_list(arraylist, middle+1, right);

// _merge_array_lists(arraylist, left, middle, right);
// }

// proc create_Int_array_list(int initial_capacity = 16) -> Int_Array_List* {
// Int_Array_List* ret = new(Int_Array_List);
// ret->data = (int*)malloc(initial_capacity * sizeof(int));
// ret->next_index = 0;
// ret->length = initial_capacity;
// return ret;
// }














template<typename F>
class defer_finalizer {
F f;


+ 20
- 0
src/testing.cpp Wyświetl plik

@@ -174,6 +174,25 @@ proc test_array_lists_sorting() -> testresult {
return pass;
}

proc test_array_lists_searching() -> testresult {
Int_Array_List* list = create_Int_array_list();
append_to_array_list(list, 1);
append_to_array_list(list, 2);
append_to_array_list(list, 3);
append_to_array_list(list, 4);

int index = sorted_array_list_find(list, 3);
assert_equal_int(index, 2);

index = sorted_array_list_find(list, 1);
assert_equal_int(index, 0);

index = sorted_array_list_find(list, 5);
assert_equal_int(index, -1);

return pass;
}

proc test_eval_operands() -> testresult {
char operands_string[] = "((eval 1) (+ 1 2) \"okay\" (eval :haha))";
Lisp_Object* operands = Parser::parse_single_expression(operands_string);
@@ -571,6 +590,7 @@ proc run_all_tests() -> bool {
printf("-- Util --\n");
invoke_test(test_array_lists_adding_and_removing);
invoke_test(test_array_lists_sorting);
invoke_test(test_array_lists_searching);

printf("\n -- Parsing --\n");
invoke_test(test_parse_atom);


+ 197
- 52
src/visualization.cpp Wyświetl plik

@@ -1,4 +1,11 @@
proc visualize_lisp_machine() -> void {
struct Drawn_Area {
int x;
int y;
int width;
int height;
};

fprintf(stderr, "Drawing visualization...");
defer {
fprintf(stderr, "Done!\n");
@@ -29,14 +36,20 @@ proc visualize_lisp_machine() -> void {
write_y = 0;


proc draw_margin = [&](int count = 1) {
proc draw_margin = [&](int count = 1) -> Drawn_Area {
write_x += margin * count;
return {
write_x - margin * count,
write_y,
margin * count,
write_y
};
};
proc draw_new_line = [&](int count = 1) {
write_x = 0;
write_y += 25 * count;
};
proc draw_text = [&](const char* text, const char* color = "#000000", bool draw_quotes = false, int max_length = 200) {
proc draw_text = [&](const char* text, const char* color = "#000000", bool draw_quotes = false, int max_length = 200) -> Drawn_Area {
// take care of escaping sensitive chars
int text_length = 0;
int extra_needed_chars = draw_quotes ? 10 : 0;
@@ -97,50 +110,140 @@ proc visualize_lisp_machine() -> void {

int text_width = 12 * (text_length + (draw_quotes ? 2 : 0));
if (write_x + text_width > max_x) max_x = write_x + text_width;
if (write_y > max_y) max_y = write_y;
if (write_y + 12 > max_y) max_y = write_y + 12;

const char* quote = draw_quotes ? "&quot;" : "";
if (extra_needed_chars) {
fprintf(f, draw_text_template, write_x, write_y, color, quote, new_text, quote);
fprintf(f, draw_text_template, write_x, write_y+12, color, quote, new_text, quote);
free(new_text);
} else {
fprintf(f, draw_text_template, write_x, write_y, color, quote, text, quote, color);
fprintf(f, draw_text_template, write_x, write_y+12, color, quote, text, quote, color);
}

write_x += text_width;
// write_x += text_width;

return {
write_x - text_width,
write_y,
text_width,
12
};
};
proc draw_integer = [&](int number) {
proc draw_integer = [&](int number) -> Drawn_Area {
int text_width = 12 * ((int)log10(number)+1);

if (write_x + text_width > max_x) max_x = write_x + text_width;
if (write_y > max_y) max_y = write_y;

fprintf(f, draw_integer_template, write_x, write_y, number);
fprintf(f, draw_integer_template, write_x, write_y+12, number);

write_x += text_width;
return {
write_x,
write_y,
text_width,
12
};
};
proc draw_float = [&](float number) {
proc draw_float = [&](float number) -> Drawn_Area {
int text_width = 12 * 12;

if (write_x + text_width > max_x) max_x = write_x + text_width;
if (write_y > max_y) max_y = write_y;

fprintf(f, draw_float_template, write_x, write_y, number);
fprintf(f, draw_float_template, write_x, write_y+12, number);

write_x += text_width;
return {
write_x,
write_y,
text_width,
12
};
};
std::function<Drawn_Area(Lisp_Object*)> draw_pair;
proc draw_lisp_object = [&](Lisp_Object* obj) -> Drawn_Area {
switch (Memory::get_type(obj)) {
case Lisp_Object_Type::T: return draw_text("t");
case Lisp_Object_Type::Nil: return draw_text("()");
case Lisp_Object_Type::Pair: return draw_pair(obj);
case Lisp_Object_Type::Number: return draw_float(obj->value.number);
case Lisp_Object_Type::Symbol: return draw_text(&obj->value.string->data);
case Lisp_Object_Type::Keyword: {
Drawn_Area colon = draw_text(":", "#c61b6e");
write_x += colon.width;
Drawn_Area text = draw_text(&obj->value.identifier->data, "#c61b6e");
write_x -= colon.width;
return {
colon.x,
colon.y,
colon.width + text.width,
colon.height
};
}
case Lisp_Object_Type::String: return draw_text(&obj->value.string->data, "#2aa198", true, 20);
default: return {0};
}
};
proc draw_pair = [&](Lisp_Object* pair) {
draw_pair = [&](Lisp_Object* pair) -> Drawn_Area {
Drawn_Area ret;
Drawn_Area child;

ret.x = write_x;
ret.y = write_y;
ret.width = 100;
ret.height = 100;

fprintf(f,
" <rect x='%d' y='%d' width='100' height='50' stroke-width='3' stroke='black' fill='white'/>"
" <line x1='%d' y1='%d' x2='%d' y2='%d' stroke-width='3' stroke='black'/>",
write_x, write_y, write_x+50, write_y, write_x+50, write_y+50);

// arrow to first
fprintf(f,
" <line x1='%d' y1='%d' x2='%d' y2='%d' stroke-width='3' stroke='black'/>",
write_x+25, write_y+25, write_x+25, write_y+100);

write_y += 110;
child = draw_lisp_object(pair->value.pair.first);
if (ret.width < child.width)
ret.width = child.width;
if (ret.height < child.height)
ret.height = child.height;

write_y -= 110;

if (pair->value.pair.rest == Memory::nil) {
fprintf(f,
" <line x1='%d' y1='%d' x2='%d' y2='%d' stroke-width='3' stroke='black'/>",
write_x+50, write_y+50, write_x+100, write_y);
} else {
// arrow to rest
int x_offset = 150;
if (child.width+margin > x_offset)
x_offset = child.width+margin;

fprintf(f,
" <line x1='%d' y1='%d' x2='%d' y2='%d' stroke-width='3' stroke='black'/>",
write_x+75, write_y+25, write_x+75+x_offset, write_y+25);

write_x += x_offset;
ret.width += 50;

child = draw_lisp_object(pair->value.pair.rest);
ret.width += child.width;
if (ret.height < 70 + child.height)
ret.height = 70 + child.height;

write_x -= x_offset;
}

fprintf(f, "\n");

if (max_x < ret.x + ret.width)
max_x = ret.x + ret.width;
if (max_y < ret.y + ret.height)
max_y = ret.y + ret.height;

return ret;
};
proc draw_header = [&]() {
proc draw_separator = [&]() {
@@ -160,8 +263,8 @@ proc visualize_lisp_machine() -> void {
char date[12];
snprintf(date, 12, "%02d.%02d.%d", tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900);

draw_text("Date: ");
draw_text(date);
write_x += draw_text("Date: ").width;
write_x += draw_text(date).width;

draw_separator();

@@ -171,8 +274,8 @@ proc visualize_lisp_machine() -> void {
char time[12];
snprintf(time, 12, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min, tm.tm_sec);

draw_text("Time: ");
draw_text(time);
write_x += draw_text("Time: ").width;
write_x += draw_text(time).width;

draw_separator();

@@ -187,22 +290,22 @@ proc visualize_lisp_machine() -> void {
}
int used_string_memory = Memory::string_memory_size - free_string_memory;

draw_text("String Memory:");
write_x += draw_text("String Memory:").width;
draw_margin();
draw_text("[allocated chars] ");
draw_integer(Memory::string_memory_size);
write_x += draw_text("[allocated chars] ").width;
write_x += draw_integer(Memory::string_memory_size).width;
draw_margin();
draw_text("[free] ");
draw_integer(free_string_memory);
write_x += draw_text("[free] ").width;
write_x += draw_integer(free_string_memory).width;
draw_margin();
draw_text("[used] ");
draw_integer(used_string_memory);
write_x += draw_text("[used] ").width;
write_x += draw_integer(used_string_memory).width;
draw_margin();
draw_text("[%free] ");
draw_float(100.0f * free_string_memory / Memory::string_memory_size);
write_x += draw_text("[%free] ").width;
write_x += draw_float(100.0f * free_string_memory / Memory::string_memory_size).width;
draw_margin();
draw_text("[%used] ");
draw_float(100.0f * used_string_memory / Memory::string_memory_size);
write_x += draw_text("[%used] ").width;
write_x += draw_float(100.0f * used_string_memory / Memory::string_memory_size).width;

draw_separator();
draw_new_line();
@@ -214,22 +317,22 @@ proc visualize_lisp_machine() -> void {
int free_object_memory_cells = Memory::object_memory_size - (Memory::next_index_in_object_memory - Memory::free_spots_in_object_memory->next_index);
int used_object_memory_cells = Memory::next_index_in_object_memory - Memory::free_spots_in_object_memory->next_index;

draw_text("Object Memory:");
write_x += draw_text("Object Memory:").width;
draw_margin();
draw_text("[#allocated] ");
draw_integer(Memory::object_memory_size);
write_x += draw_text("[#allocated] ").width;
write_x += draw_integer(Memory::object_memory_size).width;
draw_margin();
draw_text("[#free] ");
draw_integer(free_object_memory_cells);
write_x += draw_text("[#free] ").width;
write_x += draw_integer(free_object_memory_cells).width;
draw_margin();
draw_text("[#used] ");
draw_integer(used_object_memory_cells);
write_x += draw_text("[#used] ").width;
write_x += draw_integer(used_object_memory_cells).width;
draw_margin();
draw_text("[%free] ");
draw_float(100.0f * free_object_memory_cells / Memory::object_memory_size);
write_x += draw_text("[%free] ").width;
write_x += draw_float(100.0f * free_object_memory_cells / Memory::object_memory_size).width;
draw_margin();
draw_text("[%used] ");
draw_float(100.0f * used_object_memory_cells / Memory::object_memory_size);
write_x += draw_text("[%used] ").width;
write_x += draw_float(100.0f * used_object_memory_cells / Memory::object_memory_size).width;

draw_separator();

@@ -241,6 +344,7 @@ proc visualize_lisp_machine() -> void {
Lisp_Object_Array_List* numbers = create_Lisp_Object_array_list();
Lisp_Object_Array_List* strings = create_Lisp_Object_array_list();
Lisp_Object_Array_List* pairs = create_Lisp_Object_array_list();
Lisp_Object_Array_List* lists = create_Lisp_Object_array_list();

// loop over all used memory
for (int i = 0; i < Memory::next_index_in_object_memory; ++i) {
@@ -262,13 +366,43 @@ proc visualize_lisp_machine() -> void {
}

// create the lists-list by filtering the pairs-list.
Lisp_Oject_Array_List* pairs_to_filter = create_Int_array_list();
Lisp_Object_Array_List* pairs_to_filter = create_Lisp_Object_array_list();
Int_Array_List* indices_to_filter = create_Int_array_list();

// helper lambda:
proc remove_doubles_from_lisp_object_array_list = [&](Lisp_Object_Array_List* list) -> void {
if (list->next_index == 0)
return;

sort_array_list(list);
Int_Array_List* indices_to_filter = create_Int_array_list();

size_t last = (size_t)list->data[0];
for (int i = 1; i < list->next_index; ++i) {
if ((size_t)list->data[i] == last)
append_to_array_list(indices_to_filter, i);
else
last = (size_t)list->data[i];
}

for (int i = indices_to_filter->next_index; i >= 0; --i) {
remove_index_from_array_list(list, indices_to_filter->data[i]);
}

// sort again as removing items destroys the order
sort_array_list(list);
};

// recursive lambda
std::function<void(Lisp_Object*)> filter_pair_and_children;
filter_pair_and_children = [&](Lisp_Object* pair) {
append_to_array_list(pairs_to_filter, pair);

if (Memory::get_type(pair->value.pair.first) == Lisp_Object_Type::Pair)
filter_pair_and_children(pair->value.pair.first);

if (Memory::get_type(pair->value.pair.rest) == Lisp_Object_Type::Pair)
filter_pair_and_children(pair->value.pair.rest);
};
for (int i = 0; i < pairs->next_index; ++i) {
if (Memory::get_type(pairs->data[i]->value.pair.first) == Lisp_Object_Type::Pair)
@@ -279,6 +413,15 @@ proc visualize_lisp_machine() -> void {

}

remove_doubles_from_lisp_object_array_list(pairs_to_filter);
fprintf(stderr, "removing %d pairs\n", pairs_to_filter->next_index);
// okay, so pairs_to_filter now only the pairs once each that
// we want to filter from the pairs list
for (int i = 0; i < pairs->next_index; ++i) {
if (sorted_array_list_find(pairs_to_filter, pairs->data[i]) == -1) {
append_to_array_list(lists, pairs->data[i]);
}
}

draw_text("Memory Contents:");
draw_new_line();
@@ -287,7 +430,7 @@ proc visualize_lisp_machine() -> void {
int start_x = write_x,
start_y = write_y;

draw_text("Symbols: ");
write_x += draw_text("Symbols: ").width;
draw_integer(symbols->next_index);
draw_new_line();
write_x = start_x;
@@ -303,7 +446,7 @@ proc visualize_lisp_machine() -> void {
write_x = start_x + 300;
write_y = start_y;

draw_text("Keywords: ");
write_x += draw_text("Keywords: ").width;
draw_integer(keywords->next_index);
draw_new_line();
write_x = start_x + 300;
@@ -312,8 +455,7 @@ proc visualize_lisp_machine() -> void {
draw_new_line();
write_x = start_x + 300;

draw_text(":", "#c61b6e");
draw_text(&keywords->data[i]->value.identifier->data, "#c61b6e");
draw_lisp_object(keywords->data[i]);
}


@@ -321,7 +463,7 @@ proc visualize_lisp_machine() -> void {
write_x = start_x + 600;
write_y = start_y;

draw_text("Numbers: ");
write_x += draw_text("Numbers: ").width;
draw_integer(numbers->next_index);
draw_new_line();
write_x = start_x + 600;
@@ -336,7 +478,7 @@ proc visualize_lisp_machine() -> void {
write_x = start_x + 900;
write_y = start_y;

draw_text("Strings: ");
write_x += draw_text("Strings: ").width;
draw_integer(strings->next_index);
draw_new_line();
write_x = start_x + 900;
@@ -352,16 +494,18 @@ proc visualize_lisp_machine() -> void {
write_x = start_x + 2000;
write_y = start_y;

draw_text("Pairs: ");
write_x += draw_text("Lists, Pairs: ").width;
write_x += draw_integer(lists->next_index).width;
draw_margin();
draw_integer(pairs->next_index);
draw_new_line();
write_x = start_x + 2000;

for (int i = 0; i < pairs->next_index; ++i) {
for (int i = 0; i < lists->next_index; ++i) {
draw_new_line(3);
write_x = start_x + 2000;

draw_pair(pairs->data[i]);
write_y += draw_pair(lists->data[i]).height;
}
};

@@ -369,7 +513,7 @@ proc visualize_lisp_machine() -> void {
"<?xml version='1.0' encoding='UTF-8'?>\n"
"<svg xmlns='http://www.w3.org/2000/svg'\n"
" version='1.1' baseProfile='full'\n"
" viewBox='%06d %06d %06d %06d'"
" viewBox='%012d %012d %012d %012d'"
">\n\n", -padding, -padding, 0, 0);

draw_header();
@@ -385,6 +529,7 @@ proc visualize_lisp_machine() -> void {
"<?xml version='1.0' encoding='UTF-8'?>\n"
"<svg xmlns='http://www.w3.org/2000/svg'\n"
" version='1.1' baseProfile='full'\n"
" viewBox='%06d %06d %06d %06d'", -padding, -padding, max_x + 2*padding, max_y + 2*padding);
" viewBox='%012d %012d %012d %012d'"
">", -padding, -padding, max_x + 2*padding, max_y + 2*padding);

}

Napisz Podgląd
Ładowanie…
Anuluj
Zapisz