renaming (mostly)

1 files changed, 105 insertions, 88 deletions

diff --git a/prb_string.c b/prb_string.c
index bb235df..06f4ed8 100644
--- a/prb_string.c
+++ b/prb_string.c
@@ -1,153 +1,170 @@
-Str8 str8(U8 *ptr, U64 length)
+/* NOTE(pryazha): Null-terminated strings */
+
+/* TODO(pryazha): Move to another file specific to OS you're in */
+void sys_vprintf(const char *fmt, va_list args)
 {
-	Assert(ptr);
+	vprintf(fmt, args);
+}
 
-	Str8	r;
+void sys_printf(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	sys_vprintf(fmt, args);
+	va_end(args);
+}
 
-	r.ptr = ptr;
-	r.length = length;
+/* NOTE(pryazha): Fixed-length strings */
 
+FLS fls(U8 *p, U64 len)
+{
+	FLS	r;
+	r.p = p;
+	r.len = len;
 	return r;
 }
 
-Str8 str8range(U8 *start, U8 *end)
+FLS flsfromcstr(const char *cstr)
 {
-	Str8	r;
+	U8	*p;
+	FLS	r;
 
-	r.ptr = start;
-	r.length = end-start;
+	p = (U8 *)cstr;
+	for (; *p; ++p);
+	r = flsrange((U8 *)cstr, p);
 
 	return r;
 }
 
-Str8 str8fromcstr(char *cstr)
+char *flstocstr(Arena *a, FLS s)
 {
-	U8	*ptr;
-	Str8	r;
+	U64	len;
+	char	*cstr;
 
-	ptr = (U8 *)cstr;
-	for (; *ptr; ++ptr);
-	r = str8range((U8 *)cstr, ptr);
+	len = s.len+1;
+	cstr = push_arena(a, len*sizeof(U8));
+	MEMCPY(cstr, s.p, len*sizeof(U8));
+	*(cstr+s.len) = 0;
 
-	return r;
+	return cstr;
 }
 
-char *str8tocstr(Arena *arena, Str8 s)
+FLS flsrange(U8 *st_arenat, U8 *end)
 {
-	U64	length;
-	char	*r;
-
-	length = s.length+1;
-	r = arena_push(arena, length*sizeof(U8));
-	MemoryCopy(r, s.ptr, length*sizeof(U8));
-	*(r+s.length) = 0;
-
+	FLS	r;
+	r.p = st_arenat;
+	r.len = end-st_arenat;
 	return r;
 }
 
-Str8 str8chopend(Str8 s, U64 count)
+FLS flschopend(FLS s, U64 cnt)
 {
-	U64	length;
-	Str8	r;
+	U64	len;
+	FLS	r;
 
-	length = s.length-ClampTop(count, s.length);
-	r = str8(s.ptr, length);
+	len = s.len-CLAMPTOP(cnt, s.len);
+	r = fls(s.p, len);
 
 	return r;
 }
 
-Str8 str8chopstart(Str8 s, U64 count)
+FLS flschopstart(FLS s, U64 cnt)
 {
-	U64	clamped, length;
-	Str8	r;
+	U64	clamped, len;
+	FLS	r;
 
-	clamped = ClampTop(count, s.length);
-	length = s.length-ClampTop(count, s.length);
-	r = str8(s.ptr+clamped, length);
+	clamped = CLAMPTOP(cnt, s.len);
+	len = s.len-CLAMPTOP(cnt, s.len);
+	r = fls(s.p+clamped, len);
 
 	return r;
 }
 
-void str8print(Str8 s)
+FLS flspushfv(Arena *a, const char *fmt, va_list args)
 {
-	for (U64 i = 0; i < s.length; ++i)
-		printf("%c", (char)(*(s.ptr+i)));
-}
+	ASSERT(a);
 
-Str8List *str8list(Arena *arena)
-{
-	Str8List	*list;
-	list = arena_push(arena, sizeof(Str8List));
-	MemoryZero(list, sizeof(Str8List));
-	return list;
+	char	tmp[1024];
+	S32	n;
+	FLS	r;
+
+	n = vsnprintf(tmp, 1024, fmt, args);
+
+	MEM0(&r, sizeof(FLS));
+
+	if (n > 0) {
+		r.p = push_arena(a, n);
+		MEMCPY(r.p, tmp, n);
+		r.len = n;
+	}
+
+	return r;
 }
 
-void str8listpush(Arena *arena, Str8List *list, Str8 str, B32 to_front)
+FLS flspushf(Arena *a, const char *fmt, ...)
 {
-	Assert(arena && list);
+	va_list	args;
+	FLS	r;
 
-	Str8Node	*n;
+	va_start(args, fmt);
+	r = flspushfv(a, fmt, args);
+	va_end(args);
 
-	n = arena_push(arena, sizeof(Str8Node));
-	n->str = str;
-	if (to_front)
-		DLLPushFront(list->first, list->last, n);
-	else
-		DLLPushBack(list->first, list->last, n);
-	list->total_length += str.length;
-	list->node_count++;
+	return r;
 }
 
-void str8listprint(Str8List *list)
+void flsprint(FLS s)
 {
-	Str8Node	*n;
-	for (n = list->first; n; n = n->next)
-		str8print(n->str);
+	ASSERT(s.p);
+	ASSERT(s.len);
+
+	fwrite(s.p, sizeof(U8), s.len, stdout);
 }
 
-Str8 str8pushfv(Arena *arena, char *fmt, va_list args)
+
+FLSList *flslist(Arena *a)
 {
-	va_list	args2;
-	Str8	r;
-	S32	buf_size, n;
-	U8	*buf;
+	FLSList	*l;
 
-	va_copy(args2, args);
+	l = push_arena(a, sizeof(FLSList));
+	MEM0(l, sizeof(FLSList));
 
-	buf_size = 1024;
-	buf = arena_push(arena, buf_size);
+	return l;
+}
 
-	n = vsnprintf((char *)buf, buf_size, fmt, args);
-	va_end(args2);
+void flslistpush(Arena *a, FLSList *l, FLS s, B32 front)
+{
+	ASSERT(a);
+	ASSERT(l);
 
-	MemoryZero(&r, sizeof(Str8));
+	FLSNode	*n;
 
-	if (n > 0)
-		r = str8(buf, n);
+	n = push_arena(a, sizeof(FLSNode));
+	n->str = s;
 
-	return r;
+	if (front)
+		DLLPUSHFRONT(l->first, l->last, n);
+	else
+		DLLPUSHBACK(l->first, l->last, n);
+	l->len += s.len;
+	l->ncnt++;
 }
 
-Str8 str8pushf(Arena *arena, char *fmt, ...)
+void flslistpushf(Arena *a, FLSList *l, B32 front, const char *fmt, ...)
 {
 	va_list	args;
-	Str8	r;
+	FLS	str;
 
 	va_start(args, fmt);
-	r = str8pushfv(arena, fmt, args);
+	str = flspushfv(a, fmt, args);
 	va_end(args);
 
-	return r;
+	flslistpush(a, l, str, front);
 }
 
-void str8listpushf(Arena *arena, Str8List *list, B32 to_front, char *fmt, ...)
+void flslistprint(FLSList *l)
 {
-	va_list	args;
-	Str8	str;
-
-	va_start(args, fmt);
-	str = str8pushfv(arena, fmt, args);
-	va_end(args);
-
-	str8listpush(arena, list, str, to_front);
+	FLSNode	*n;
+	for (n = l->first; n; n = n->next)
+		flsprint(n->str);
 }