diff --git a/.gitignore b/.gitignore index 50f6faf..c04f2fa 100644 --- a/.gitignore +++ b/.gitignore @@ -11,4 +11,6 @@ vgcore.* *.xcf *_NORMAL.png *_TEMPLATE.png -/out \ No newline at end of file +/out +GRAPH*.dot +GRAPH*.png \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 27fea5c..dda56d4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,6 +34,8 @@ add_compile_options(-fno-trapping-math) #add_executable(0_test src/l1_4/tests/t0.c) #add_executable(1_test src/l1_4/tests/t1.c) # +add_executable(l1_4_t2 src/l1_4/tests/t2.c) + add_executable(codegen_l1_5 src/l1_5/anne/codegen.c) # #add_executable(0_render_test src/l2/tests/r0/r0.c gen/l_wl_protocols/xdg-shell-private.c @@ -56,4 +58,4 @@ add_executable(codegen_l1_5 src/l1_5/anne/codegen.c) #target_link_libraries(0_play_test -lncurses) # -add_executable(l2t0 src/l2/tests/data_structures/t0.c) \ No newline at end of file +add_executable(l2t0 src/l2/tests/data_structures/t0.c) diff --git a/Makefile b/Makefile index 91d9d48..1e52fb4 100644 --- a/Makefile +++ b/Makefile @@ -54,6 +54,15 @@ xdg_shell_private := gen/l_wl_protocols/xdg-shell-private.c l_wl_protocols := gen/l_wl_protocols/xdg-shell-client.h $(xdg_shell_private) +out/l2/t0: src/l2/tests/data_structures/t0.c $(HEADERS_gen_l1_5) + mkdir -p out/l2 + $(cc) $(cflags) -o $@ $< + +.PHONY: run_l2_t0 +run_l2_t0: out/l2/t0 + mkdir -p src/l2/tests/data_structures/GRAPHS + cd src/l2/tests/data_structures && ../../../../out/l2/t0 + out/l2/r0: src/l2/tests/r0/r0.c $(HEADERS_src_l2) $(l_wl_protocols) mkdir -p out/l2 $(cc) $(cflags) -o $@ $< $(xdg_shell_private) -lvulkan -lm -lxkbcommon -lwayland-client -lpng @@ -101,4 +110,3 @@ run_r3: out/l2/r3 .PHONY: clean clean: rm -rf gen out - diff --git a/shell.nix b/shell.nix index 92fc387..8fdb217 100644 --- a/shell.nix +++ b/shell.nix @@ -12,7 +12,8 @@ let libs = (with pkgs; [ libpng ]); in pkgs.mkShell { - buildInputs = with pkgs; [ + buildInputs = with pkgs; [ + graphviz pipewire shaderc gnumake @@ -28,6 +29,6 @@ pkgs.mkShell { shellHook = '' export VK_LAYER_PATH="${pkgs.vulkan-validation-layers}/share/vulkan/explicit_layer.d" echo Day ruined. - ''; +''; } diff --git a/src/l1/core/VecU8_as_str.h b/src/l1/core/VecU8_as_str.h index d40a992..d80ec43 100644 --- a/src/l1/core/VecU8_as_str.h +++ b/src/l1/core/VecU8_as_str.h @@ -78,7 +78,7 @@ void S64_stringification_into_buf(S64 x, VecU8* targ){ if (x == 0) { VecU8_append(targ, '0'); } else if (x == -9223372036854775807L-1) { - VecU8_append_span(targ, cstr("-9223372036854775807")); + VecU8_append_span(targ, cstr("-9223372036854775808")); } else { if (x < 0) { VecU8_append(targ, '-'); @@ -97,7 +97,7 @@ void S64_stringification_into_buf(S64 x, VecU8* targ){ *right = *left; *left = t; left++; - right++; + right--; } } } @@ -130,7 +130,7 @@ void U64_stringification_into_buf(U64 x, VecU8* targ){ *right = *left; *left = t; left++; - right++; + right--; } } } @@ -156,7 +156,7 @@ NODISCARD VecU8 VecU8_fmt(const char* fmt, ...) { /* We had not taken ownership of YET (will take it the next iteration) */ VecU8 vs = va_arg(args, VecU8); k += vs.len; - } else if (*ch == 's') { + } else if (*ch == 'i') { S64 x = va_arg(args, S64); k += S64_stringification_get_length(x); } else if (*ch == 'u') { @@ -186,7 +186,7 @@ NODISCARD VecU8 VecU8_fmt(const char* fmt, ...) { } else if (*ch == 'v') { VecU8 vs = va_arg(args, VecU8); VecU8_append_vec(&res, vs); /* Moved ownership of vs argument */ - } else if (*ch == 's') { + } else if (*ch == 'i') { S64 x = va_arg(args, S64); S64_stringification_into_buf(x, &res); } else if (*ch == 'u') { @@ -203,4 +203,16 @@ NODISCARD VecU8 VecU8_fmt(const char* fmt, ...) { return res; } +// todo: generate a special span method to check equality of contents +bool strings_in_spans_equal(SpanU8 a, SpanU8 b) { + if (a.len != b.len) + return false; + for (size_t i = 0; i < a.len; i++) { + if (*SpanU8_at(a, i) != *SpanU8_at(b, i)) + return false; + } + return true; +} + + #endif diff --git a/src/l1/core/util.h b/src/l1/core/util.h index 1e99f56..dfe2826 100644 --- a/src/l1/core/util.h +++ b/src/l1/core/util.h @@ -85,4 +85,6 @@ typedef struct { U32 height; } SizeOfRectangleU32; +#define check(expr) if (!(expr)) { abortf("Assertion failed at %s : %d : " #expr "\n", __FILE__, __LINE__); } + #endif diff --git a/src/l1/system/creating_child_proc.h b/src/l1/system/creating_child_proc.h new file mode 100644 index 0000000..a651e8e --- /dev/null +++ b/src/l1/system/creating_child_proc.h @@ -0,0 +1,18 @@ +#ifndef prototype1_src_l1_system_creating_child_proc_h +#define prototype1_src_l1_system_creating_child_proc_h + +#include "../core/util.h" + +void calling_system_func_nofail(const char* command) { + int ret = system(command); + if (ret == -1) { + abortf("system() failed\n"); + } else if (WIFEXITED(ret) && WEXITSTATUS(ret) != 0) { + abortf("Error: command exited with code %d\n", WEXITSTATUS(ret)); + } else if (!WIFEXITED(ret)) { + abortf("Error: command terminated abnormally\n"); + } +} + + +#endif \ No newline at end of file diff --git a/src/l1_4/tests/t2.c b/src/l1_4/tests/t2.c new file mode 100644 index 0000000..0016d01 --- /dev/null +++ b/src/l1_4/tests/t2.c @@ -0,0 +1,41 @@ +#include "../../l1/core/VecU8_as_str.h" + +int main(){ + { + VecU8 res = VecU8_fmt("%i", 0); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("0"))); + VecU8_drop(res); + } + { + VecU8 res = VecU8_fmt("%i%i%i%i", -1LL, 0LL, 44LL, -231LL); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("-1044-231"))); + VecU8_drop(res); + } + { + VecU8 res = VecU8_fmt("%i", 44LL); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("44"))); + VecU8_drop(res); + } + { + VecU8 res = VecU8_fmt("%u", 44ULL); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("44"))); + VecU8_drop(res); + } + { + VecU8 res = VecU8_fmt("%u %i", 18446744073709551615ULL, -1LL); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("18446744073709551615 -1"))); + VecU8_drop(res); + } + { + VecU8 res = VecU8_fmt("%i %i", 9223372036854775807LL, -9223372036854775807LL-1); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("9223372036854775807 -9223372036854775808"))); + VecU8_drop(res); + } + { + VecU8 vec2 = vcstr("vec2"); + VecU8 res = VecU8_fmt("%i %v %i", -1230LL, vec2, 1340LL); + check(strings_in_spans_equal(VecU8_to_span(&res), cstr("-1230 vec2 1340"))); + VecU8_drop(res); + } + return 0; +} \ No newline at end of file diff --git a/src/l1_5/codegen/rb_tree_set_map_template_inst.h b/src/l1_5/codegen/rb_tree_set_map_template_inst.h index 561e19e..0da914d 100644 --- a/src/l1_5/codegen/rb_tree_set_map_template_inst.h +++ b/src/l1_5/codegen/rb_tree_set_map_template_inst.h @@ -177,6 +177,7 @@ void codegen_append_rb_tree_set_erase_kind_method( SPACE "U64 z = cur;\n" SPACE "U64 y = (self->tree.buf[z].left == 0 || self->tree.buf[z].right == 0) ? z : RBTree_minimum_in_subtree(self->tree.buf, self->tree.buf[z].right);\n" SPACE "U64 x = self->tree.buf[y].left != 0 ? self->tree.buf[y].left : self->tree.buf[y].right;\n" + SPACE "assert(x != y && x != z);\n" SPACE "U64 py = self->tree.buf[y].parent;\n" // May be null SPACE "self->tree.buf[x].parent = self->tree.buf[y].parent;\n" SPACE "if (py == 0)\n" @@ -189,11 +190,15 @@ void codegen_append_rb_tree_set_erase_kind_method( SPACE "if (z != y)\n" SPACE SPACE "RBTree_steal_neighbours(self->tree.buf, &self->root, z, y);\n" SPACE "U64 L = self->el.len;\n" /* self->tree.len - 1 */ - SPACE "RBTree_steal_neighbours(self->tree.buf, &self->root, L, z);\n" + SPACE "if (L != z){\n" + SPACE SPACE "RBTree_steal_neighbours(self->tree.buf, &self->root, L, z);\n" + SPACE SPACE "self->el.buf[z-1] = self->el.buf[L-1];\n" + SPACE SPACE "if (L == x)\n" + SPACE SPACE SPACE "x = z;\n" + SPACE "}\n" SPACE "self->tree.len--;\n" - SPACE "self->el.buf[z-1] = self->el.buf[L-1];\n" SPACE "self->el.len--;\n" - SPACE "if (y_org_clr)\n" + SPACE "if (y_org_clr == RBTree_black)\n" SPACE SPACE "RBTree_fix_after_delete(self->tree.buf, &self->root, x);\n" "%v" /* ret_found_case */ "}\n\n", @@ -322,6 +327,52 @@ NODISCARD VecU8 generate_rb_tree_Set_template_instantiation(set_instantiation_op )); } + VecU8_append_vec(&res, VecU8_fmt( + "NODISCARD %s %s_clone(const %s* self){\n" + SPACE "return (%s){.tree = VecRBTreeNode_clone(&self->tree), .root = self->root,\n" + SPACE SPACE "Vec%s_clone(&self->el)};\n" + "}\n\n", set, set, set, set, op.T)); + + VecU8_append_vec(&res, VecU8_fmt( + "U64 %s_find_next(const %s* self, U64 x){\n" + SPACE "assert(x != 0 && x < self->tree.len);\n" + SPACE "if (self->tree.buf[x].right != 0)\n" + SPACE SPACE "return RBTree_minimum_in_subtree(self->tree.buf, self->tree.buf[x].right);\n" + SPACE "while (true) {\n" + SPACE SPACE "U64 p = self->tree.buf[x].parent;\n" + SPACE SPACE "if (p == 0)\n" + SPACE SPACE SPACE "return 0;\n" + SPACE SPACE "if (self->tree.buf[p].left == x)\n" + SPACE SPACE SPACE "return p;\n" + SPACE SPACE "x = p;\n" + SPACE "}\n" + "}\n\n", set, set)); + + VecU8_append_vec(&res, VecU8_fmt( + "U64 %s_find_prev(const %s* self, U64 x){\n" + SPACE "assert(x != 0 && x < self->tree.len);\n" + SPACE "if (self->tree.buf[x].left != 0)\n" + SPACE SPACE "return RBTree_maximum_in_subtree(self->tree.buf, self->tree.buf[x].left);\n" + SPACE "while (true) {\n" + SPACE SPACE "U64 p = self->tree.buf[x].parent;\n" + SPACE SPACE "if (p == 0)\n" + SPACE SPACE SPACE "return 0;\n" + SPACE SPACE "if (self->tree.buf[p].right == x)\n" + SPACE SPACE SPACE "return p;\n" + SPACE SPACE "x = p;\n" + SPACE "}\n" + "}\n\n", set, set)); + + VecU8_append_vec(&res, VecU8_fmt( + "U64 %s_find_min(const %s* self) {\n" + SPACE "return self->root != 0 ? RBTree_minimum_in_subtree(self->tree.buf, self->root) : 0;\n" + "}\n\n", set, set)); + + VecU8_append_vec(&res, VecU8_fmt( + "U64 %s_find_max(const %s* self) {\n" + SPACE "return self->root != 0 ? RBTree_maximum_in_subtree(self->tree.buf, self->root) : 0;\n" + "}\n\n", set, set)); + // todo: continue from here. Implement method _pop_and_substitute() // todo: All the other methods are secondary in importance diff --git a/src/l1_5/core/rb_tree_node.h b/src/l1_5/core/rb_tree_node.h index d39aa16..a7d46d6 100644 --- a/src/l1_5/core/rb_tree_node.h +++ b/src/l1_5/core/rb_tree_node.h @@ -118,7 +118,7 @@ void RBTree_steal_neighbours(RBTreeNode* tree, U64* root, U64 fr, U64 to){ tree[to] = tree[fr]; } -/* helper function (used in _delete, _find_min methods). It is assumed that s is not null. +/* helper function (used in _erase, _find_min methods). It is assumed that s is not null. * Guaranteed to return no-null */ U64 RBTree_minimum_in_subtree(RBTreeNode* tree, U64 s){ @@ -128,6 +128,16 @@ U64 RBTree_minimum_in_subtree(RBTreeNode* tree, U64 s){ return s; } +/* helper function (used in _find_max, _find_prev methods). It is assumed that s is not null. + * Guaranteed to return no-null + */ +U64 RBTree_maximum_in_subtree(RBTreeNode* tree, U64 s){ + assert(s != 0); + while (tree[s].right != 0) + s = tree[s].right; + return s; +} + void RBTree_fix_after_delete(RBTreeNode* tree, U64* root, U64 me){ assert(tree[*root].parent == 0); while (me != *root && tree[me].color == RBTree_black) { diff --git a/src/l1_5/core/stringop.h b/src/l1_5/core/stringop.h index e59cd43..b4719b9 100644 --- a/src/l1_5/core/stringop.h +++ b/src/l1_5/core/stringop.h @@ -27,16 +27,6 @@ bool string_contains_string_ignorecase(SpanU8 str1, SpanU8 str2) { return false; } -bool strings_in_spans_equal(SpanU8 a, SpanU8 b) { - if (a.len != b.len) - return false; - for (size_t i = 0; i < a.len; i++) { - if (*SpanU8_at(a, i) != *SpanU8_at(b, i)) - return false; - } - return true; -} - bool is_string_in_string_vec(SpanU8 a, const VecVecU8* B) { for (size_t i = 0; i < B->len; i++) { if (strings_in_spans_equal(a, VecU8_to_span(VecVecU8_at(B, i)))) diff --git a/src/l2/tests/data_structures/t0.c b/src/l2/tests/data_structures/t0.c index d5b8535..1c06a03 100644 --- a/src/l2/tests/data_structures/t0.c +++ b/src/l2/tests/data_structures/t0.c @@ -1,128 +1,150 @@ #include "../../../../gen/l1_5/BuffRBTree_SetS64.h" +#include "../../../l1/core/VecU8_as_str.h" +#include "../../../l1/system/fileio.h" -void assert_structure_h_dfs(const VecRBTreeNode* tree, U64 x, VecU8* f){ +void check_structure_h_dfs(const VecRBTreeNode* tree, U64 x, VecU8* f){ if (x == 0) return; if (*VecU8_at(f, x - 1) != 0) - assert(false); + check(false); *VecU8_mat(f, x - 1) = 1; - assert_structure_h_dfs(tree, VecRBTreeNode_at(tree, x)->left, f); - assert_structure_h_dfs(tree, VecRBTreeNode_at(tree, x)->right, f); + check_structure_h_dfs(tree, VecRBTreeNode_at(tree, x)->left, f); + check_structure_h_dfs(tree, VecRBTreeNode_at(tree, x)->right, f); } -U32 assert_structure_h_dfs_2(RBTreeNode* tree, U64 x){ +U32 check_structure_h_dfs_2(RBTreeNode* tree, U64 x){ if (x == 0) { return 0; } - U32 a = assert_structure_h_dfs_2(tree, tree[x].left); - U32 b = assert_structure_h_dfs_2(tree, tree[x].right); - assert(a == b); + U32 a = check_structure_h_dfs_2(tree, tree[x].left); + U32 b = check_structure_h_dfs_2(tree, tree[x].right); + check(a == b); return a + (tree[x].color == RBTree_black ? 1 : 0); } -void assert_structure(const BuffRBTree_SetS64* self){ - assert(self->tree.len == self->el.len + 1); - assert(self->root < self->tree.len); +void check_structure(const BuffRBTree_SetS64* self){ + check(self->tree.len == self->el.len + 1); + check(self->root < self->tree.len); if (self->tree.len > 1) { - assert(self->root != 0); + check(self->root != 0); } VecU8 f = VecU8_new_zeroinit(self->tree.len - 1); - assert_structure_h_dfs(&self->tree, self->root, &f); + check_structure_h_dfs(&self->tree, self->root, &f); for (size_t i = 0; i < self->tree.len - 1; i++) { - assert(*VecU8_at(&f, i)); + check(*VecU8_at(&f, i)); } VecU8_drop(f); /* f invalidated */ for (size_t v = 1; v < self->tree.len; v++) { if (v == self->root) { - assert(self->tree.buf[v].parent == 0); + check(self->tree.buf[v].parent == 0); } else { - assert(self->tree.buf[v].parent != 0); + check(self->tree.buf[v].parent != 0); } - assert(self->tree.buf[v].parent < self->tree.len); - assert(self->tree.buf[v].left < self->tree.len); - assert(self->tree.buf[v].right < self->tree.len); + check(self->tree.buf[v].parent < self->tree.len); + check(self->tree.buf[v].left < self->tree.len); + check(self->tree.buf[v].right < self->tree.len); if (self->tree.buf[v].left != 0) { - assert(self->tree.buf[self->tree.buf[v].left].parent == v); - assert(self->el.buf[self->tree.buf[v].left - 1] < self->el.buf[v - 1]); + check(self->tree.buf[self->tree.buf[v].left].parent == v); + check(self->el.buf[self->tree.buf[v].left - 1] < self->el.buf[v - 1]); } if (self->tree.buf[v].right != 0) { - assert(self->tree.buf[self->tree.buf[v].right].parent == v); - assert(self->el.buf[v - 1] < self->el.buf[self->tree.buf[v].right - 1]); + check(self->tree.buf[self->tree.buf[v].right].parent == v); + check(self->el.buf[v - 1] < self->el.buf[self->tree.buf[v].right - 1]); } } /* Checking coloring */ - assert(self->tree.buf[0].color == RBTree_black); + check(self->tree.buf[0].color == RBTree_black); if (self->root != 0) - assert(self->tree.buf[self->root].color == RBTree_black); + check(self->tree.buf[self->root].color == RBTree_black); for (size_t v = 1; v < self->tree.len; v++) { if (self->tree.buf[v].color == RBTree_red) { - assert(self->tree.buf[self->tree.buf[v].left].color == RBTree_black); - assert(self->tree.buf[self->tree.buf[v].right].color == RBTree_black); + check(self->tree.buf[self->tree.buf[v].left].color == RBTree_black); + check(self->tree.buf[self->tree.buf[v].right].color == RBTree_black); } } - assert_structure_h_dfs_2(self->tree.buf, self->root); + check_structure_h_dfs_2(self->tree.buf, self->root); +} + +void save_tree_to_file(const BuffRBTree_SetS64* set, SpanU8 name){ + check_structure(set); + VecU8 graph = VecU8_new(); + VecU8_append_span(&graph, cstr( + "digraph rbtree {\n" + " fontsize = 20\n" + " rankdir = TB\n" + " bgcolor = \"lightgray\"\n" + " node [fontname = \"Arial\"];\n")); + for (size_t i = 1; i < set->tree.len; i++) { + VecU8_append_vec(&graph, VecU8_fmt(" v%s")); + } + VecU8_append_span(&graph, cstr("}\n")); + + VecU8 dot_filename_nt = VecU8_fmt("GRAPHS/GRAPH_%s.dot%c", name, 0); + write_whole_file_or_abort((CSTR)dot_filename_nt.buf, VecU8_to_span(&graph)); + VecU8_drop(graph); + VecU8_drop(dot_filename_nt); } void insert_only(){ { BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); - assert_structure(&set); + check_structure(&set); BuffRBTree_SetS64_drop(set); } { BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); bool ret = BuffRBTree_SetS64_insert(&set, 42); - assert(ret); - assert_structure(&set); - assert(set.el.len == 1); - assert(set.root == 1); + check(ret); + check_structure(&set); + check(set.el.len == 1); + check(set.root == 1); BuffRBTree_SetS64_drop(set); } { bool ret; BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); ret = BuffRBTree_SetS64_insert(&set, 42); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); ret = BuffRBTree_SetS64_insert(&set, 69); - assert(ret); - assert_structure(&set); - assert(set.el.len == 2); + check(ret); + check_structure(&set); + check(set.el.len == 2); BuffRBTree_SetS64_drop(set); } { bool ret; BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); ret = BuffRBTree_SetS64_insert(&set, 70); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); ret = BuffRBTree_SetS64_insert(&set, 50); - assert(ret); - assert_structure(&set); - assert(set.el.len == 2); + check(ret); + check_structure(&set); + check(set.el.len == 2); BuffRBTree_SetS64_drop(set); } { bool ret; BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); ret = BuffRBTree_SetS64_insert(&set, 1); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); ret = BuffRBTree_SetS64_insert(&set, 2); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); ret = BuffRBTree_SetS64_insert(&set, 3); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); BuffRBTree_SetS64_drop(set); } { BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); for (S64 i = 10; i < 100; i++) { bool ret = BuffRBTree_SetS64_insert(&set, i); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); } BuffRBTree_SetS64_drop(set); } @@ -130,8 +152,8 @@ void insert_only(){ BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); for (S64 i = 99; i >= 10; i--) { bool ret = BuffRBTree_SetS64_insert(&set, i); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); } BuffRBTree_SetS64_drop(set); } @@ -139,11 +161,11 @@ void insert_only(){ BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); for (S64 i = 10; i < 100; i++) { bool ret = BuffRBTree_SetS64_insert(&set, i); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); bool ret2 = BuffRBTree_SetS64_insert(&set, 1000 - i); - assert(ret2); - assert_structure(&set); + check(ret2); + check_structure(&set); } BuffRBTree_SetS64_drop(set); } @@ -158,20 +180,71 @@ void insert_and_then_find(){ BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); for (S64 p = 0; p < 100; p++) { bool ret = BuffRBTree_SetS64_insert(&set, 2 * p); - assert(ret); - assert_structure(&set); + check(ret); + check_structure(&set); for (S64 i = 0; i <= p; i++) { U64 ret1 = BuffRBTree_SetS64_find(&set, 2 * i); - assert(ret1); + check(ret1); U64 ret2 = BuffRBTree_SetS64_find(&set, 2 * i + 1); - assert(ret2 == 0); + check(ret2 == 0); } } BuffRBTree_SetS64_drop(set); } +void insert_and_delete(){ + { + BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); + check(BuffRBTree_SetS64_insert(&set, 1)) + check_structure(&set); + check(BuffRBTree_SetS64_find(&set, 1)); + check(BuffRBTree_SetS64_erase(&set, 1)); + check_structure(&set); + check(!BuffRBTree_SetS64_find(&set, 1)); + BuffRBTree_SetS64_drop(set); + } + { + BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); + check(BuffRBTree_SetS64_insert(&set, 1)) + check_structure(&set); + check(BuffRBTree_SetS64_insert(&set, 2)) + check_structure(&set); + check(BuffRBTree_SetS64_erase(&set, 2)); + check_structure(&set); + check(BuffRBTree_SetS64_find(&set, 1)); + check(!BuffRBTree_SetS64_find(&set, 2)); + check(BuffRBTree_SetS64_erase(&set, 1)); + check_structure(&set); + check(!BuffRBTree_SetS64_find(&set, 1)); + check(!BuffRBTree_SetS64_find(&set, 2)); + BuffRBTree_SetS64_drop(set); + } + { + BuffRBTree_SetS64 set = BuffRBTree_SetS64_new(); + check(BuffRBTree_SetS64_insert(&set, 1)) + check_structure(&set); + check(BuffRBTree_SetS64_insert(&set, 2)) + check_structure(&set); + check(BuffRBTree_SetS64_erase(&set, 1)); + check_structure(&set); + check(!BuffRBTree_SetS64_find(&set, 1)); + check(BuffRBTree_SetS64_find(&set, 2)); + + check(!BuffRBTree_SetS64_erase(&set, 1)); + check(!BuffRBTree_SetS64_find(&set, 1)); + check(BuffRBTree_SetS64_find(&set, 2)); + check(BuffRBTree_SetS64_erase(&set, 2)); + check_structure(&set); + check(!BuffRBTree_SetS64_find(&set, 1)); + check(!BuffRBTree_SetS64_find(&set, 2)); + BuffRBTree_SetS64_drop(set); + } + +} + int main() { insert_only(); insert_and_then_find(); + insert_and_delete(); return 0; } diff --git a/src/l2/tests/r0/r0.c b/src/l2/tests/r0/r0.c index e47d1cc..dd6c4f7 100644 --- a/src/l2/tests/r0/r0.c +++ b/src/l2/tests/r0/r0.c @@ -9,7 +9,7 @@ #include "../../../l1/system/fsmanip.h" #include "../../../../gen/l_wl_protocols/xdg-shell-client.h" #include - +#include "../../../l1/system/creating_child_proc.h" #include "../../margaret/png_pixel_masses.h" // todo: generate this structure in l2 @@ -1625,27 +1625,16 @@ static const struct wl_callback_listener main_h_wl_surface_frame_listener = { -void calling_system_func(const char* command) { - int ret = system(command); - if (ret == -1) { - abortf("system() failed\n"); - } else if (WIFEXITED(ret) && WEXITSTATUS(ret) != 0) { - abortf("Error: command exited with code %d\n", WEXITSTATUS(ret)); - } else if (!WIFEXITED(ret)) { - abortf("Error: command terminated abnormally\n"); - } -} - void compile_shader_dir(SpanU8 name) { mkdir_nofail("shaders/spv"); VecU8 spv_shader_dir_name = VecU8_fmt("shaders/spv/%s%c", name, 0); mkdir_nofail((CSTR)spv_shader_dir_name.buf); VecU8_drop(spv_shader_dir_name); VecU8 vert_cmd = VecU8_fmt("glslc -o shaders/spv/%s/vert.spv shaders/glsl/%s/%s.vert%c", name, name, name, 0); - calling_system_func((CSTR)vert_cmd.buf); + calling_system_func_nofail((CSTR)vert_cmd.buf); VecU8_drop(vert_cmd); VecU8 frag_cmd = VecU8_fmt("glslc -o shaders/spv/%s/frag.spv shaders/glsl/%s/%s.frag%c", name, name, name, 0); - calling_system_func((CSTR)frag_cmd.buf); + calling_system_func_nofail((CSTR)frag_cmd.buf); VecU8_drop(frag_cmd); }