renaming (mostly)

2 files changed, 125 insertions, 113 deletions

diff --git a/example/example b/example/example
index 02b1008..cefef94 100755
--- a/example/example
+++ b/example/example
diff --git a/example/example.c b/example/example.c
index 35d2b86..dc76ffb 100644
--- a/example/example.c
+++ b/example/example.c
@@ -19,77 +19,61 @@ typedef struct DLLNode {
 
 int main(void)
 {
-	F32 verts[] = {
+	F32	verts[] = {
 		1.0f, 0.0f, 0.0f,
 		0.0f, 1.0f, 0.0f,
 		0.0f, 0.0f, 1.0f
 	};
 
-	Assert(v3a(1.0f).y);
-	U64 memory_size = Kilobytes(4);
-	void *some_memory = malloc(memory_size);
-	*(S32 *)some_memory = 69;
-	U64 ptr_as_int = IntFromPtr(some_memory);
-	void *ptr_to_memory = PtrFromInt(ptr_as_int);
-	printf("IntFromPtr: %lu\n", ptr_as_int);
-	printf("Using PtrFromInt(%lu) to get the first element of some_memory: %d\n\n",
-	       ptr_as_int, *(S32 *)ptr_to_memory);
-	free(some_memory);
-
-	printf("OffsetOfMember(SomeStruct, flags): %lld\n\n",
-	       OffsetOfMember(SomeStruct, flags));
-
-	F32 range_min = 0.0f, range_max = 1.0f;
-	F32 clamped_number = 1.5f;
-	F32 another_clamped_number = -0.2f;
-	printf("ClampBottom(%f, %f): %f\n", range_min,
-	       another_clamped_number, ClampBottom(another_clamped_number, range_min));
-	printf("ClampTop(%f, %f): %f\n", range_max,
-	       clamped_number, ClampTop(clamped_number, range_max));
-
-	printf("Clamp(%f, %f, %f): %f\n", range_min, clamped_number, range_max,
-	       Clamp(range_min, clamped_number, range_max));
-	printf("Clamp(%f, %f, %f): %f\n\n", range_min, another_clamped_number, range_max,
-	       Clamp(range_min, another_clamped_number, range_max));
-
-	F32 swap_test_first = 10.0f, swap_test_second = 20.0f;
-	printf("Before Swap: swap_test_first = %f, swap_test_second = %f\n",
+	ASSERT(v3a(1.0f).y);
+
+	printf("OFFSETOF(SomeStruct, flags): %ld\n\n", OFFSETOF(SomeStruct, flags));
+
+	F32	range_min = 0.0f,
+		range_max = 1.0f,
+		clamped_number = 1.5f,
+		another_clamped_number = -0.2f;
+
+	printf("CLAMPBOT(%f, %f): %f\n", range_min,
+	       another_clamped_number, CLAMPBOT(another_clamped_number, range_min));
+	printf("CLAMPTOP(%f, %f): %f\n", range_max,
+	       clamped_number, CLAMPTOP(clamped_number, range_max));
+
+	printf("CLAMP(%f, %f, %f): %f\n", range_min, clamped_number, range_max,
+	       CLAMP(range_min, clamped_number, range_max));
+	printf("CLAMP(%f, %f, %f): %f\n\n", range_min, another_clamped_number, range_max,
+	       CLAMP(range_min, another_clamped_number, range_max));
+
+	F32	swap_test_first = 10.0f,
+		swap_test_second = 20.0f;
+
+	printf("Before SWAP: swap_test_first = %f, swap_test_second = %f\n",
 	       swap_test_first, swap_test_second);
-	Swap(F32, swap_test_first, swap_test_second);
-	printf("After Swap: swap_test_first = %f, swap_test_second = %f\n\n",
+	SWAP(F32, swap_test_first, swap_test_second);
+	printf("After SWAP: swap_test_first = %f, swap_test_second = %f\n\n",
 	       swap_test_first, swap_test_second);
 
-	SomeStruct some_stuct = { 10, 20, 30 };
+	SomeStruct	some_stuct = { 10, 20, 30 };
 	printf("SomeStruct: first: %d, second: %d, flags: %d\n",
 	       some_stuct.first, some_stuct.second, some_stuct.flags);
-	MemoryZero(&some_stuct, sizeof(SomeStruct));
-	printf("After MemoryZero(&some_stuct, sizeof(SomeStruct)):\n");
+	MEM0(&some_stuct, sizeof(SomeStruct));
+	printf("After MEM0(&some_stuct, sizeof(SomeStruct)):\n");
 	printf("some_stuct: first: %d, second: %d, flags: %d\n\n",
 	       some_stuct.first, some_stuct.second, some_stuct.flags);
 
 	some_stuct = (SomeStruct){ 10, 20, 30 };
 	printf("some_stuct: first: %d, second: %d, flags: %d\n",
 	       some_stuct.first, some_stuct.second, some_stuct.flags);
-	MemoryZeroStruct(&some_stuct);
-	printf("After MemoryZeroStruct(&some_stuct):\n");
+	MEM0STRUCT(&some_stuct);
+	printf("After MEM0STRUCT(&some_stuct):\n");
 	printf("some_stuct: first: %d, second: %d, flags: %d\n\n",
 	       some_stuct.first, some_stuct.second, some_stuct.flags);
 
-	printf("Before MemoryZeroArray:\n");
-	for (S32 i = 0; i < ArrayCount(verts); ++i)
-		printf("%f%c", verts[i], (((i+1)%4 == 0) ||
-					  (i == ArrayCount(verts)-1)) ? '\n' : ' ');
-	MemoryZeroArray(verts);
-	printf("After:\n");
-	for (S32 i = 0; i < ArrayCount(verts); ++i)
-		printf("%f%c", verts[i], (((i+1)%4 == 0) ||
-					  (i == ArrayCount(verts)-1)) ? '\n' : ' ');
-	printf("\n");
+	S32	dynamic_array_length = 10;
+	U64	dynamic_array_size = dynamic_array_length*sizeof(S32);
+	F32	*dynamic_array_first = malloc(dynamic_array_size);
+	F32	*dynamic_array_second = malloc(dynamic_array_size);
 
-	S32 dynamic_array_length = 10;
-	U64 dynamic_array_size = dynamic_array_length*sizeof(S32);
-	F32 *dynamic_array_first = malloc(dynamic_array_size);
-	F32 *dynamic_array_second = malloc(dynamic_array_size);
 	printf("first dynamic array:\n");
 	for (S32 i = 0; i < dynamic_array_length; ++i) {
 		F32 *element = dynamic_array_first+i;
@@ -101,15 +85,15 @@ int main(void)
 		F32 *element = dynamic_array_second+i;
 		printf("%f%c", *element, (i == dynamic_array_length-1) ? '\n' : ' ');
 	}
-	MemoryCopy(dynamic_array_second, dynamic_array_first, dynamic_array_size);
-	printf("After MemoryCopy(dynamic_array_second, dynamic_array_first, dynamic_array_size):\n");
+	MEMCPY(dynamic_array_second, dynamic_array_first, dynamic_array_size);
+	printf("After MEMCPY(dynamic_array_second, dynamic_array_first, dynamic_array_size):\n");
 	printf("second dynamic array:\n");
 	for (S32 i = 0; i < dynamic_array_length; ++i) {
 		F32 *element = dynamic_array_second+i;
 		printf("%f%c", *element, (i == dynamic_array_length-1) ? '\n' : ' ');
 	}
-	S32 memory_match = MemoryMatch(dynamic_array_first, dynamic_array_second, dynamic_array_size);
-	printf("And MemoryMatch(MemoryMatch(dynamic_array_first, dynamic_array_second, dynamic_array_size): %d\n\n", memory_match);
+	S32 memory_match = MEMMATCH(dynamic_array_first, dynamic_array_second, dynamic_array_size);
+	printf("And MEMMATCH(dynamic_array_first, dynamic_array_second, dynamic_array_size): %d\n\n", memory_match);
 	free(dynamic_array_first);
 	free(dynamic_array_second);
 
@@ -123,12 +107,12 @@ int main(void)
 	for (S32 i = 0; i < list_length; ++i) {
 		SLLNode *new = sllist+i;
 		new->val = i;
-		SLLPush(sllfirst, slllast, new);
+		SLLPUSH(sllfirst, slllast, new);
 	}
 	for (SLLNode *node = sllfirst; node; node = node->next)
 		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
-	SLLPop(sllfirst, slllast);
-	printf("After SLLPop(sllfirst, slllast): ");
+	SLLPOP(sllfirst, slllast);
+	printf("After SLLPOP(sllfirst, slllast): ");
 	for (SLLNode *node = sllfirst; node; node = node->next)
 		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
 	free(sllist);
@@ -142,14 +126,14 @@ int main(void)
 	for (S32 i = 0; i < list_length; ++i) {
 		DLLNode *new = dllist+i;
 		new->val = i;
-		DLLPushBack(dllfirst, dlllast, new);
+		DLLPUSHBACK(dllfirst, dlllast, new);
 	}
 	for (DLLNode *node = dllfirst; node; node = node->next)
 		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
 	printf("Remove odd numbers: ");
 	for (DLLNode *node = dllfirst; node; node = node->next)
 		if (node->val % 2 == 1)
-			DLLRemove(dllfirst, dlllast, node);
+			DLLREMOVE(dllfirst, dlllast, node);
 	for (DLLNode *node = dllfirst; node; node = node->next)
 		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
 	free(dllist);
@@ -160,66 +144,91 @@ int main(void)
 	printf("Matrices:\n");
 	printf("Identity:\n");
 	MAT4 m = MAT4_IDENTITY;
-	mat4print(m);
-	m = mat4scale(m, v3a(10.0f));
-	m = mat4transl(m, v3a(1.0f));
-	m = mat4transl(m, v3(0.0f, 68.0f, 0.0f));
-	mat4print(m);
-	printf("Determinant: %f\n", mat4det(m));
-	printf("Transpose:\n"); mat4print(mat4transp(m));
+	printmat4(m);
+	m = scalemat4(m, v3a(10.0f));
+	m = translmat4(m, v3a(1.0f));
+	m = translmat4(m, v3(0.0f, 68.0f, 0.0f));
+	printmat4(m);
+	printf("Determinant: %f\n", detmat4(m));
+	printf("Transpose:\n"); printmat4(transpmat4(m));
 	printf("mat4rotate(MAT4_IDENTITY, v3(0.0f, 45.0f, 0.0f)):\n");
-	mat4print(mat4rotate(MAT4_IDENTITY, v3(0.0f, 45.0f, 0.0f)));
+	printmat4(rotatemat4(MAT4_IDENTITY, v3(0.0f, 45.0f, 0.0f)));
+
+	sys_printf("Example of using sys_printf without args\n");
+	sys_printf("And with some of number : %x : <- like that or string : %s : for example\n", 69, "yeah");
 
 	printf("Using Arenas:\n");
-	Arena *a = arena_alloc(0);
+
+	Arena	*a;
+	U8	*df,
+		*ds;
+	Arena	*tmpa;
+	
+	a = alloc_arena(10);
+	df = push_arena(a, 5);
+	memset(df, 5, 5);
+	ds = push_arena(a, 5);
+	memset(ds, 10, 5);
+
+	tmpa = alloc_arena(0);
+
+	flsprint(FLSLIT("|"));
+	for (S32 i = 0; i < 10; i++)
+		flsprint(flspushf(tmpa, "%x%s", df[i], ((i+1) % 5 == 0) ? "|" : " "));
+	flsprint(FLSLIT("\n"));
+
+	release_arena(tmpa);
+	release_arena(a);
+
+	a = alloc_arena(0);
 	SLLNode *first = 0;
 	SLLNode *last = 0;
 	S32 node_count = 10;
 	for (S32 i = 0; i < node_count; ++i) {
-		SLLNode *new = arena_push(a, sizeof(SLLNode));
+		SLLNode *new = push_arena(a, sizeof(SLLNode));
 		new->val = i;
-		SLLPush(first, last, new);
+		SLLPUSH(first, last, new);
 	}
 	for (SLLNode *node = first; node; node = node->next)
 		printf("%d%s", node->val, ((node->next) ? " -> " : "\n"));
-	arena_release(a);
+	release_arena(a);
 
-	a = arena_alloc(sizeof(verts));
-	S32 verts_count = ArrayCount(verts);
-	F32 *dynamic_verts = arena_push(a, sizeof(verts));
-	MemoryZero(dynamic_verts, verts_count*sizeof(F32));
+	a = alloc_arena(sizeof(verts));
+	S32 verts_count = ARRCNT(verts);
+	F32 *dynamic_verts = push_arena(a, sizeof(verts));
+	MEM0(dynamic_verts, verts_count*sizeof(F32));
 	for (S32 i = 0; i < verts_count; ++i) {
 		F32 *vert = dynamic_verts+i;
 		printf("%f%c", *vert, (i == verts_count-1) ? '\n' : ' ');
 	}
-	arena_release(a);
+	release_arena(a);
 	printf("\n");
 
-	Arena *str_arena = arena_alloc(0);
+	Arena *str_arena = alloc_arena(0);
 	printf("Strings:\n");
 	char *cstr = "This is a C str\n";
-	Str8 str = str8fromcstr(cstr);
-	str = str8chopstart(str, 10);
-	cstr = str8tocstr(a, str);
+	FLS str = flsfromcstr(cstr);
+	str = flschopstart(str, 10);
+	cstr = flstocstr(a, str);
 	printf("%s", cstr);
-	str8print(str);
-	Str8 choped_str = str8chopend(str, 3);
-	str8print(choped_str);
+	flsprint(str);
+	FLS choped_str = flschopend(str, 3);
+	flsprint(choped_str);
 	printf("\n");
-	Str8List *list = str8list(str_arena);
-	str8listpush(str_arena, list, str, 0);
-	str8listpush(str_arena, list, str8fromcstr("test"), 0);
-	str8listpush(str_arena, list, str8fromcstr("and this is also a test\n"), 0);
-	str8listpush(str_arena, list, str8fromcstr("Kinda works!"), 1);
-	printf("Str8List: ");
-	str8listprint(list);
-	arena_release(str_arena);
-	str8listprint(list);
-
-	str_arena = arena_alloc(Kilobytes(10));
-	memory_size = 512;
+	FLSList *list = flslist(str_arena);
+	flslistpush(str_arena, list, str, 0);
+	flslistpush(str_arena, list, flsfromcstr("test"), 0);
+	flslistpush(str_arena, list, flsfromcstr("and this is also a test\n"), 0);
+	flslistpush(str_arena, list, flsfromcstr("Kinda works!"), 1);
+	printf("FLSList: ");
+	flslistprint(list);
+	release_arena(str_arena);
+	flslistprint(list);
+
+	str_arena = alloc_arena(KB(10));
+	U32 memory_size = 512;
 	U32 count = memory_size/sizeof(S32);
-	S32 *some = arena_push(str_arena, memory_size);
+	S32 *some = push_arena(str_arena, memory_size);
 	printf("str_arena(size): %ld\nMemory:\n", str_arena->cap);
 	for (S32 i = 0; i < count; i++) {
 		S32 *e = some+i;
@@ -230,7 +239,7 @@ int main(void)
 	printf("Remaining memory: %lu\n",
 	       str_arena->cap-str_arena->used);
 
-	arena_pop(str_arena, memory_size);
+	pop_arena(str_arena, memory_size);
 
 	printf("After arena pop\n");
 	printf("Memory used: %lu\n", str_arena->used);
@@ -239,26 +248,29 @@ int main(void)
 	printf("some ptr is %s\n", some ? "not null" : "null");
 	printf("str_arena(size): %lu\nMemory:\n", str_arena->cap);
 
-	Str8 new_str = str8pushf(str_arena, "Test of the formatted string: %d\n", 69);
-	str8print(new_str);
+	FLS new_str = flspushf(str_arena, "Test of the formatted string: %d\n", 69);
+	flsprint(new_str);
 
-	list = str8list(str_arena);
-	str8listpushf(str_arena, list, 0, "This is a list %d", 34);
-	str8listpushf(str_arena, list, 0, " of formatted strings: %d", 35);
-	str8listpushf(str_arena, list, 1, "And you can push to the start");
+	list = flslist(str_arena);
+	flslistpushf(str_arena, list, 0, "This is a list %d", 34);
+	flslistpushf(str_arena, list, 0, " of formatted strings: %d", 35);
+	flslistpushf(str_arena, list, 1, "And you can push to the start");
 	/* TODO(pryazha): Think about simpler way of using string literals.
 	 * Maybe you don't need to, I dunno */
-	str8listpushf(str_arena, list, 1, "The most interesting part is that you can include the whole string like that: %*s\n",
-		      str8expand(str8lit("Absolutely random string with absolutely random content (or not).")));
-	str8listprint(list);
+	flslistpushf(str_arena, list, 1, "The most interesting part is that you can include the whole string like that: %*s\n",
+		      FLSEXP(FLSLIT("Absolutely random string with absolutely random content (or not).")));
+	flslistprint(list);
 
-	arena_release(str_arena);
+	release_arena(str_arena);
 
-	a = arena_alloc(Megabytes(1));
-	str8print(str8lit("build.sh content:\n"));
-	Str8 file_content = str8_read_entire_file(a, str8lit("build.sh"));
-	str8print(file_content);
-	arena_release(a);
+	a = alloc_arena(MB(1));
+	flsprint(FLSLIT("build.sh content:\n"));
+	FLS file_content = fls_read_entire_file(a, FLSLIT("build.sh"));
+	if (file_content.p)
+		flsprint(file_content);
+	else
+		flsprint(FLSLIT("failed to read build.sh\n"));
+	release_arena(a);
 
 	return(0);
 }