Trying this again.

2 files changed, 98 insertions, 1 deletions

diff --git a/makefile b/makefile
index 414af85..3652375 100644
--- a/makefile
+++ b/makefile
@@ -14,7 +14,7 @@ endif
 
 INCLUDES=-Iinc/
 
-OBJECTS=obj/salloc.c.o obj/arena.c.o obj/resarr.c.o
+OBJECTS=obj/salloc.c.o obj/arena.c.o obj/resarr.c.o obj/sstring.c.o
 
 .PHONY: all
 all: build/lib/libspicy.so build/lib/static/libspicy.a includes
diff --git a/src/sstring.c b/src/sstring.c
new file mode 100644
index 0000000..adcffec
--- /dev/null
+++ b/src/sstring.c
@@ -0,0 +1,97 @@
+#include "sstring.h"
+
+#include <string.h>
+#include <stdarg.h>
+
+int sassign(sstring* restrict dst, const sstring* restrict src)
+{
+  if (!src || !dst) return -1;
+
+  memcpy(dst->buf, src->buf, sstrlen(src));
+  dst->len = sstrlen(src);
+  dst->buf[dst->len] = 0;
+
+  return dst->len;
+}
+
+// Assignment operator for C-Strings
+int cassign(sstring* restrict dst, const char* restrict src)
+{
+    if (!src || !dst) return -1;
+    dst->len = strlen(strncpy(dst->buf, src, 65536));
+    return dst->len;
+}
+
+// Sizeof operator
+size_t sstrlen(const sstring* str)
+{
+  if(!str) return 0;
+  return (str->len > 65536) ? 65536 : str->len;
+}
+
+
+static int sshift(sstring* str, size_t mode)
+{
+  if(!str) return -1;
+
+  // 0 is downshift, 1 is UPSHIFT!!
+  static const char lowers[2]={'A','a'};
+  static const char uppers[2]={'Z','z'};
+
+  // This is signed for a VERY GOOD REASON
+  // okay it technically works either way because of
+  // modular arithmeticks, but uh, shush.
+  static const char offsets[2]={'a'-'A','A'-'a'};
+
+  for(size_t i=0; i<str->len; i++)
+    {
+      if(str->buf[i] >= lowers[mode] && str->buf[i] >= uppers[mode])
+	{
+	  str->buf[i] += offsets[mode];
+	}
+    }
+  return 0;
+}
+
+int sUPPER(sstring* str)
+{
+  return sshift(str,1);
+}
+
+int slower(sstring* str)
+{
+  return sshift(str,0);
+}
+
+
+
+sstring spicycat(const size_t count, ...)
+{
+  // Yes, we will have to do a copy out of this stack frame.
+  // Unless... (O3 Ren's Beloved??)
+  sstring returnme = sstringup();
+  
+  va_list kittens;
+  va_start(kittens, count);
+  for(size_t i=0; i<count; i++)
+    { 
+      size_t spaceleft = 65536-returnme.len; // Calc how much space we have
+
+      // Grab the new argument
+      const sstring* kitten = va_arg(kittens,const sstring*);
+
+      size_t kitlen = sstrlen(kitten); // This is JUST here to avoid f-calling twice.
+      size_t copylen = (kitlen > spaceleft) ? spaceleft : kitlen;
+      
+      *(char*)(memcpy(returnme.buf+returnme.len, kitten->buf, copylen)+copylen) = 0;
+      returnme.len += copylen;
+    }
+  va_end(kittens);
+  return returnme;
+}
+
+
+sstring sstringup()
+{
+  return (sstring) {0U,{0}};
+}