From e0e4d06c1b21d36611e31c53e02bd4ae0a97fbd4 Mon Sep 17 00:00:00 2001 From: Felix Brendel Date: Sat, 4 May 2019 17:27:51 +0200 Subject: [PATCH] added symbols to visualization --- bin/visualization.svg | 1127 ++++++++++++++++++++++++++++++++++++++++- src/slime.h | 1 + src/visualization.cpp | 301 ++++++++++- 3 files changed, 1413 insertions(+), 16 deletions(-) diff --git a/bin/visualization.svg b/bin/visualization.svg index d991630..7702d63 100644 --- a/bin/visualization.svg +++ b/bin/visualization.svg @@ -1,13 +1,1132 @@ + viewBox='-00040 -00040 001496 007817'> - doeun + Date: - - ASDNew texhgfdgdhft + + 04.05.2019 + + + | + + + Time: + + + 17:25:39 + + + | + + + String Memory: + + + [allocated chars] + + + 65536 + + + [free] + + + 3026 + + + [used] + + + 62510 + + + [%free] + + + 00004.617310 + + + [%used] + + + 00095.382690 + + + | + + + Object Memory: + + + [#allocated] + + + 8192000 + + + [#free] + + + 8191179 + + + [#used] + + + 821 + + + [%free] + + + 00099.989975 + + + [%used] + + + 00000.010022 + + + | + + + Memory Contents: + + + Symbols: + + + 302 + + + = + + + > + + + >= + + + < + + + <= + + + + + + + - + + + * + + + / + + + ** + + + % + + + assert + + + define + + + mutate + + + if + + + quote + + + quasiquote + + + and + + + or + + + not + + + while + + + let + + + lambda + + + special-lambda + + + eval + + + prog + + + list + + + pair + + + first + + + rest + + + set-type + + + delete-type + + + type + + + info + + + show + + + print + + + read + + + exit + + + break + + + memstat + + + try + + + load + + + import + + + copy + + + error + + + symbol->keyword + + + string->symbol + + + symbol->string + + + concat-strings + + + define-syntax + + + when + + + condition + + + body + + + if + + + condition + + + unquote + + + pair + + + prog + + + body + + + unquote + + + nil + + + quasiquote + + + prog + + + define-syntax + + + unless + + + condition + + + body + + + if + + + condition + + + unquote + + + nil + + + pair + + + prog + + + body + + + unquote + + + quasiquote + + + prog + + + define-syntax + + + cond + + + clauses + + + define + + + rec + + + clauses + + + if + + + = + + + nil + + + clauses + + + nil + + + if + + + = + + + first + + + first + + + clauses + + + else + + + quote + + + prog + + + if + + + not + + + = + + + rest + + + clauses + + + error + + + pair + + + prog + + + quote + + + rest + + + first + + + clauses + + + list + + + if + + + quote + + + first + + + first + + + clauses + + + pair + + + prog + + + quote + + + rest + + + first + + + clauses + + + rec + + + rest + + + clauses + + + rec + + + clauses + + + prog + + + define + + + nil? + + + x + + + = + + + x + + + nil + + + define + + + number? + + + x + + + = + + + type + + + x + + + define + + + symbol? + + + x + + + = + + + type + + + x + + + define + + + keyword? + + + x + + + = + + + type + + + x + + + define + + + pair? + + + x + + + = + + + type + + + x + + + define + + + string? + + + x + + + = + + + type + + + x + + + define + + + lambda? + + + x + + + = + + + type + + + x + + + define + + + special-lambda? + + + x + + + = + + + type + + + x + + + define + + + built-n-function? + + + x + + + = + + + type + + + x + + + define + + + apply + + + fun + + + seq + + + eval + + + pair + + + fun + + + seq + + + define + + + end + + + seq + + + if + + + or + + + nil? + + + seq + + + not + + + pair? + + + rest + + + seq + + + seq + + + end + + + rest + + + seq + + + define + + + last + + + seq + + + first + + + end + + + seq + + + define + + + extend + + + seq + + + elem + + + if + + + pair? + + + seq + + + prog + + + define + + + e + + + end + + + seq + + + mutate + + + e + + + pair + + + first + + + e + + + elem + + + seq + + + elem + + + define + + + append + + + seq + + + elem + + + extend + + + seq + + + pair + + + elem + + + nil + + + define-syntax + + + extend! + + + seq + + + elem + + + mutate + + + seq + + + unquote + + + extend + + + seq + + + unquote + + + elem + + + unquote + + + quasiquote + + + prog + + + define-syntax + + + append! + + + seq + + + elem + + + mutate + + + seq + + + unquote + + + append + + + seq + + + unquote + + + elem + + + unquote + + + quasiquote + + + prog + + + define + + + length + + + seq + + + if + + + nil? + + + seq + + + + + + + length + + + rest + + + seq + + + define + + + increment + + + val + + + + + + + val + + + define + + + decrement + + + val + + + - + + + val + + + define + + + range + + + from + + + to + + + when + + + < + + + from + + + to + + + pair + + + from + + + range + + + + + + + from + + + to + + + condition + + + body + + + Keywords: + + + 16 + + + : + + + rest + + + : + + + rest + + + : + + + rest + + + : + + + number + + + : + + + symbol + + + : + + + keyword + + + : + + + pair + + + : + + + string + + + : + + + dynamic-function + + + : + + + dynamic-macro + + + : + + + built-in-function + + + : + + + keys + + + : + + + defaults-to + + + : + + + from + + + : + + + to + + + : + + + symbol-undefined + + + Numbers: + + + 6 + + + Strings: + + + 21 + + + Pairs: + + + 420 diff --git a/src/slime.h b/src/slime.h index e465dcd..faf9c89 100644 --- a/src/slime.h +++ b/src/slime.h @@ -3,6 +3,7 @@ #define _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_DEPRECATE #include +#include #include #include #include diff --git a/src/visualization.cpp b/src/visualization.cpp index b6c8e27..41071c7 100644 --- a/src/visualization.cpp +++ b/src/visualization.cpp @@ -1,7 +1,17 @@ proc visualize_lisp_machine() -> void { - const int padding = 30; + fprintf(stderr, "Drawing visualization..."); + defer { + fprintf(stderr, "Done!\n"); + }; + + const int padding = 40; const int margin = 20; + const char* draw_text_template = " \n %s\n \n"; + const char* draw_integer_template = " \n %d\n \n"; + const char* draw_float_template = " \n %012.6f\n \n"; + + FILE *f = fopen("visualization.svg", "w"); defer { fclose(f); @@ -18,27 +28,293 @@ proc visualize_lisp_machine() -> void { write_x = 0, write_y = 0; + + proc draw_margin = [&](int count = 1) { + write_x += margin * count; + }; + proc draw_new_line = [&](int count = 1) { + write_x = 0; + write_y += 25 * count; + }; proc draw_text = [&](const char* text) { - int text_width = 12 * strlen(text); - int text_height = 12; + // take care of escaping sensitive chars + int text_length = 0; + int extra_needed_chars = 0; + char* new_text; + + char source; + while ((source = text[text_length++]) != '\0') { + switch (source) { + case '<': + case '>': + extra_needed_chars += 3; + break; + case '&': + extra_needed_chars += 4; + break; + case '\'': + case '"': + extra_needed_chars += 5; + } + } + // if we need to replace some chars + if (extra_needed_chars > 0) { + new_text = (char*)malloc((text_length + extra_needed_chars) * sizeof(char)); + + int index_in_text = 0, + index_in_new_text = 0; + + char source; + while ((source = text[index_in_text++]) != '\0') { + switch (source) { + case '<': + new_text[index_in_new_text++] = '&'; + new_text[index_in_new_text++] = 'l'; + new_text[index_in_new_text++] = 't'; + new_text[index_in_new_text++] = ';'; + break; + case '>': + new_text[index_in_new_text++] = '&'; + new_text[index_in_new_text++] = 'g'; + new_text[index_in_new_text++] = 't'; + new_text[index_in_new_text++] = ';'; + break; + case '&': + new_text[index_in_new_text++] = '&'; + new_text[index_in_new_text++] = 'a'; + new_text[index_in_new_text++] = 'm'; + new_text[index_in_new_text++] = 'p'; + new_text[index_in_new_text++] = ';'; + break; + case '"': + new_text[index_in_new_text++] = '&'; + new_text[index_in_new_text++] = 'q'; + new_text[index_in_new_text++] = 'u'; + new_text[index_in_new_text++] = 'o'; + new_text[index_in_new_text++] = 't'; + new_text[index_in_new_text++] = ';'; + break; + case '\'': + new_text[index_in_new_text++] = '&'; + new_text[index_in_new_text++] = 'a'; + new_text[index_in_new_text++] = 'p'; + new_text[index_in_new_text++] = 'o'; + new_text[index_in_new_text++] = 's'; + new_text[index_in_new_text++] = ';'; + break; + default: + new_text[index_in_new_text++] = source; + } + } + new_text[index_in_new_text] = '\0'; + } + + int text_width = 12 * text_length; if (write_x + text_width > max_x) max_x = write_x + text_width; if (write_y > max_y) max_y = write_y; - fprintf(f, - " \n" - " %s" - "\n \n", write_x, write_y, text); + if (extra_needed_chars) { + fprintf(f, draw_text_template, write_x, write_y, new_text); + free(new_text); + } else { + fprintf(f, draw_text_template, write_x, write_y, text); + } write_x += text_width; }; + proc draw_integer = [&](int number) { + 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); + + write_x += text_width; + }; + proc draw_float = [&](float number) { + 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); + + write_x += text_width; + }; + + proc draw_header = [&]() { + proc draw_separator = [&]() { + draw_margin(); + draw_text("|"); + draw_margin(); + }; + + time_t t = time(NULL); + struct tm tm = *localtime(&t); - proc draw_header = [&](){ write_y = 12; - // draw_text("ASD"); - // write_x += margin; - draw_text("doeun"); + + // ------------------- + // Date + // ------------------- + 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); + + draw_separator(); + + // ------------------- + // Time + // ------------------- + char time[12]; + snprintf(time, 12, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min, tm.tm_sec); + + draw_text("Time: "); + draw_text(time); + + draw_separator(); + + // ------------------- + // String Memory + // ------------------- + draw_new_line(); + + int free_string_memory = Memory::next_free_spot_in_string_memory - Memory::string_memory; + for (int i = 0; i < Memory::free_spots_in_string_memory->next_index; ++i) { + free_string_memory += ((String*)(Memory::free_spots_in_string_memory->data[i]))->length; + } + int used_string_memory = Memory::string_memory_size - free_string_memory; + + draw_text("String Memory:"); + draw_margin(); + draw_text("[allocated chars] "); + draw_integer(Memory::string_memory_size); + draw_margin(); + draw_text("[free] "); + draw_integer(free_string_memory); + draw_margin(); + draw_text("[used] "); + draw_integer(used_string_memory); + draw_margin(); + draw_text("[%free] "); + draw_float(100.0f * free_string_memory / Memory::string_memory_size); + draw_margin(); + draw_text("[%used] "); + draw_float(100.0f * used_string_memory / Memory::string_memory_size); + + draw_separator(); + draw_new_line(); + + // ------------------- + // Object Memory + // ------------------- + + 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:"); + draw_margin(); + draw_text("[#allocated] "); + draw_integer(Memory::object_memory_size); + draw_margin(); + draw_text("[#free] "); + draw_integer(free_object_memory_cells); + draw_margin(); + draw_text("[#used] "); + draw_integer(used_object_memory_cells); + draw_margin(); + draw_text("[%free] "); + draw_float(100.0f * free_object_memory_cells / Memory::object_memory_size); + draw_margin(); + draw_text("[%used] "); + draw_float(100.0f * used_object_memory_cells / Memory::object_memory_size); + + draw_separator(); + + draw_new_line(); + draw_new_line(); + draw_new_line(); + }; + proc draw_symbols_keywords_and_numbers = [&]() { + Lisp_Object_Array_List* symbols = create_Lisp_Object_array_list(); + Lisp_Object_Array_List* keywords = create_Lisp_Object_array_list(); + 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(); + + // loop over all used memory + for (int i = 0; i < Memory::next_index_in_object_memory; ++i) { + for (int j = 0; j < Memory::free_spots_in_object_memory->next_index; ++j) { + if (i == Memory::free_spots_in_object_memory->data[j]) + goto next; + } + + switch (Memory::get_type(Memory::object_memory+i)) { + case Lisp_Object_Type::Symbol: append_to_array_list(symbols, Memory::object_memory+i); break; + case Lisp_Object_Type::String: append_to_array_list(strings, Memory::object_memory+i); break; + case Lisp_Object_Type::Keyword: append_to_array_list(keywords, Memory::object_memory+i); break; + case Lisp_Object_Type::Number : append_to_array_list(numbers, Memory::object_memory+i); break; + case Lisp_Object_Type::Pair : append_to_array_list(pairs, Memory::object_memory+i); break; + } + + next: ; + } + + draw_text("Memory Contents:"); + draw_new_line(); + draw_new_line(); + + int start_x = write_x, + start_y = write_y; + + draw_text("Symbols: "); + draw_integer(symbols->next_index); + + for (int i = 0; i < symbols->next_index; ++i) { + draw_new_line(); + write_x = start_x; + + draw_text(&symbols->data[i]->value.identifier->data); + } + + + write_x = start_x + 300; + write_y = start_y; + + draw_text("Keywords: "); + draw_integer(keywords->next_index); + + for (int i = 0; i < keywords->next_index; ++i) { + draw_new_line(); + write_x = start_x + 300; + + draw_text(":"); + draw_text(&keywords->data[i]->value.identifier->data); + } + + + + write_x = start_x + 600; + write_y = start_y; + + draw_text("Numbers: "); + draw_integer(numbers->next_index); + + write_x = start_x + 900; + write_y = start_y; + + draw_text("Strings: "); + draw_integer(strings->next_index); + + write_x = start_x + 1200; + write_y = start_y; + + draw_text("Pairs: "); + draw_integer(pairs->next_index); }; @@ -50,6 +326,7 @@ proc visualize_lisp_machine() -> void { ">\n\n", -padding, -padding, 0, 0); draw_header(); + draw_symbols_keywords_and_numbers(); fprintf(f, "\n\n");