pub/prototype1
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed some bugs, wrote some tests. Still need to write rb tree graphvizization for better gaming

Browse Source
This commit is contained in:
Андреев Григорий 2025-09-22 22:09:12 +03:00
parent 0a35394a2e
commit ccba6112fa
13 changed files with 298 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -11,4 +11,6 @@ vgcore.*
*.xcf
*_NORMAL.png
*_TEMPLATE.png
/out
/out
GRAPH*.dot
GRAPH*.png

4
CMakeLists.txt
View File

@ -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)
add_executable(l2t0 src/l2/tests/data_structures/t0.c)

10
Makefile
View File

@ -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

5
shell.nix
View File

@ -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.
'';
'';
}

22
src/l1/core/VecU8_as_str.h
View File

@ -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

2
src/l1/core/util.h
View File

@ -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

18
src/l1/system/creating_child_proc.h Normal file
View File

@ -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

41
src/l1_4/tests/t2.c Normal file
View File

@ -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;
}

57
src/l1_5/codegen/rb_tree_set_map_template_inst.h
View File

@ -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

12
src/l1_5/core/rb_tree_node.h
View File

@ -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) {

10
src/l1_5/core/stringop.h
View File

@ -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))))

195
src/l2/tests/data_structures/t0.c
View File

@ -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;
}

17
src/l2/tests/r0/r0.c
View File

@ -9,7 +9,7 @@
#include "../../../l1/system/fsmanip.h"
#include "../../../../gen/l_wl_protocols/xdg-shell-client.h"
#include <xkbcommon/xkbcommon.h>
#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);
}