initial commit

1 files changed, 67 insertions, 0 deletions

diff --git a/sb.c b/sb.c
new file mode 100644
index 0000000..0353545
--- /dev/null
+++ b/sb.c
@@ -0,0 +1,67 @@
+#include <stdlib.h>
+#include <string.h>
+#include "sb.h"
+
+struct node{ // linked list, but strings don't have to be max size
+    size_t cap;
+    size_t len;
+    char* text;
+    node* next;
+};
+
+// malloc might fail, but the entire program should just crash if it does
+node* newsb(size_t cap){
+    node* sb;
+    sb = malloc(sizeof(node));
+    sb->text = malloc(sizeof(char)*cap);
+    sb->len = 0; sb->cap = cap;
+    sb->next = NULL;
+    return sb;
+}
+
+node* extendsb(node* tail){
+    tail->next = newsb(tail->cap*2);
+    return tail->next;
+}
+
+node* appendsb(node* tail, const char* str){
+    for (int i=0; str[i] != '\0'; i++){
+        if (tail->len == tail->cap) tail = extendsb(tail); // if full, extend
+        *(tail->text + tail->len) = str[i]; // copy str[i] to last open spot
+        tail->len++;
+    }
+    return tail;
+}
+///////// i want to prevent this duplication but cant figure out how :(
+
+node* addchrsb(node* tail, char chr){
+    if (tail->len == tail->cap) tail = extendsb(tail); // if full, extend
+    *(tail->text + tail->len) = chr; // copy str[i] to last open spot
+    tail->len++;
+    return tail;
+}
+
+char* tostr(node* head){ // destructive; frees the whole chain
+    int len;
+    char* str;
+    len = lensb(head);
+    str = malloc((len+1)*sizeof(char)); // need +1 for null terminator
+    str[len] = '\0';
+
+    len = 0; //controls progression through str
+    do {
+        strncpy(str+len, head->text, head->len);
+        len += head->len;
+        head = head->next;
+        free(head);
+    } while ( head != NULL);
+    return str;
+}
+
+int lensb(node* head){ // how much space do i need to concat all strings
+    int len = 0;
+    do {
+        len += head->len;
+    } while ( (head = head->next) != NULL);
+    return len;
+}