Modfiying corrected cstring interface, much smoother, and updated Makefile to test

include/cstl/cstring.h

@@ -1,33 +1,7 @@
 #ifndef CSTL_CSTRING_H
 #define CSTL_CSTRING_H
 
-#include <string.h>
-
-/**
- * Guarantees copying lim-1 chars to the destination string, reserving at least
- * one for a null character ('\0'). Strings copied are thus guaranteed to be
- * null-terminated, and provides safety by truncating silently.
- */
-void safestrcpy(char* dest, const char* src, size_t lim);
-
-/**
- * Guarantees concatenating as many characters as possible from src to dest.
- * This is intended to act as a convenience macro, to mimic safestrcpy's usage.
- */
-#define safestrcat(dest, src, dest_lim) strncat(dest, src, dest_lim - strlen(dest) - 1)
-
-/**
- * fstrcat, as in, "fast" strcat.
- * Returns a pointer to the last element, to try to alleviate future O(n) calls.
- */
-char* fstrcat(char* dest, const char* src);
-
-/**
- * sfstrcat, as in, "safe-fast" strcat.
- * Guarantees concatenating as many characters as possible from src to dest.
- * Returns a pointer to the last element, to try to alleviate future O(n) calls.
- */
-char* sfstrcat(char* dest, const char* src, size_t lim);
+#include <stdlib.h>
 
 /**
  * String OO-like functions: cstring
@@ -42,28 +16,17 @@ char* sfstrcat(char* dest, const char* src, size_t lim);
  * NULL, and reserve deinit/destroy for the actual calling of cstring_destroy.
  */
 
-/**
- * Options for supplanting a user-defined malloc/realloc equivalent for vectors.
- */
-#ifndef CSTL_MALLOC
-#define CSTL_MALLOC malloc
-#include <stdlib.h>
-#endif
-
-#ifndef CSTL_REALLOC
-#define CSTL_REALLOC realloc
-#include <stdlib.h>
-#endif
-
-#ifndef CSTL_FREE
-#define CSTL_FREE free
-#include <stdlib.h>
-#endif
-
 /**
  * Initialize a c-string to a valid state, or, NULL.
+ *
+ * NOTE: The true interface for this function is:
+ *
+ * void cstring_init(char* s)
+ *
+ * Macros have simply been use to unify the interface.
  */
-void cstring_init(char** s);
+#define cstring_init(s) cstring_init_(&s)
+void cstring_init_(char** s);
 
 /**
  * Create a new c-string, and fill it with the contents of c-string s.
@@ -77,12 +40,49 @@ char* cstring_create(const char* s);
  * This will cause a deallocation, if s1 already has been filled.
  * As NULL is a valid state for a char*, this is checked for; if s2 is NULL,
  * then s1 will simply be freed and will stay as NULL.
+ * 
+ * NOTE: The true interface for this function is:
+ *
+ * void cstring_asn(char* s1, const char* s2)
  */
-void cstring_asn(char** s1, const char* s2);
+#define cstring_asn(s1, s2) cstring_asn_(&s1, s2)
+void cstring_asn_(char** s1, const char* s2);
 
 /**
  * Destroys and releases the memory for a c-string.
  */
 void cstring_destroy(char* s);
 
+
+/**
+ * Utility functions for handling c-strings
+ */
+
+/**
+ * Guarantees copying lim-1 chars to the destination string, reserving at least
+ * one for a null character ('\0'). Strings copied are thus guaranteed to be
+ * null-terminated, and provides safety by truncating silently.
+ */
+void safestrcpy(char* dest, const char* src, size_t lim);
+
+/**
+ * Guarantees concatenating as many characters as possible from src to dest.
+ * This is intended to act as a convenience macro, to mimic safestrcpy's usage.
+ */
+#define safestrcat(dest, src, dest_lim) strncat(dest, src, dest_lim - strlen(dest) - 1)
+
+/**
+ * fstrcat, as in, "fast" strcat.
+ * Returns a pointer to the last element, to try to alleviate future O(n) calls.
+ */
+char* fstrcat(char* dest, const char* src);
+
+/**
+ * sfstrcat, as in, "safe-fast" strcat.
+ * Guarantees concatenating as many characters as possible from src to dest.
+ * Returns a pointer to the last element, to try to alleviate future O(n) calls.
+ */
+char* sfstrcat(char* dest, const char* src, size_t lim);
+
+
 #endif

src/cstring.c

@@ -1,6 +1,30 @@
 #include "../include/cstl/cstring.h"
+#include "../include/cstl/memory.h"
 #include <string.h>
 
+void cstring_init_(char** s) {
+    *s = NULL;
+}
+
+char* cstring_create(const char* s) {
+    char* st = cstl_malloc(strlen(s) + 1);
+    strcpy(st, s);
+    return st;
+}
+
+void cstring_asn_(char** s1, const char* s2) {
+    cstl_free(*s1);
+    if(s2) {
+        *s1 = cstring_create(s2);
+    } else {
+        *s1 = NULL;
+    }
+}
+
+void cstring_destroy(char* s) {
+    cstl_free(s);
+}
+
 void safestrcpy(char* dest, const char* src, size_t lim) {
     //Minor dev-note; *dest++ = *src++ can resolve to '\0'
     //being set, rendering the final statement potentially pointless
@@ -26,26 +50,3 @@ char* sfstrcat(char* dest, const char* src, size_t lim) {
         ;
     return dest;
 }
-
-void cstring_init(char** s) {
-    *s = NULL;
-}
-
-char* cstring_create(const char* s) {
-    char* st = CSTL_MALLOC(strlen(s) + 1);
-    strcpy(st, s);
-    return st;
-}
-
-void cstring_asn(char** s1, const char* s2) {
-    CSTL_FREE(*s1);
-    if(s2) {
-        *s1 = cstring_create(s2);
-    } else {
-        *s1 = NULL;
-    }
-}
-
-void cstring_destroy(char* s) {
-    CSTL_FREE(s);
-}

src/string.c

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#define CSTL_VECTOR_ALLOC_SZ(sz) ((sz) + 1)
+#define CSTL_VECTOR_ALLOC_SZ(sz) ((sz) + STRING_CAPACITY_EXTRA)
 #define CSTL_VECTOR_INIT(v) string_init_capacity(v, 4)
 #include "../include/cstl/string.h"
 #include "../include/cstl/algorithm.h"

test/Makefile

@@ -9,12 +9,12 @@ string:
 	$(CC) $(CFLAGS) ./src/string/*.c ../src/*.c lib/*.c && ./a.out
 vector: vector-int vector-struct-point
 vector-int:
-	$(CC) $(CFLAGS) ./src/vector/test-vector-int.c ./src/vector/vector-int.c lib/*.c && ./a.out
+	$(CC) $(CFLAGS) ./src/vector/test-vector-int.c ./src/vector/vector-int.c ../src/*.c lib/*.c && ./a.out
 vector-struct-point:
-	$(CC) $(CFLAGS) ./src/vector/test-vector-struct-point.c ./src/vector/vector-struct-point.c lib/*.c && ./a.out
+	$(CC) $(CFLAGS) ./src/vector/test-vector-struct-point.c ./src/vector/vector-struct-point.c ../src/*.c lib/*.c && ./a.out
 valgrind:
-	$(CC) $(INCLUDE_FLAGS) ./src/vector/test-vector-int.c ./src/vector/vector-int.c lib/*.c && valgrind ./a.out
-	$(CC) $(INCLUDE_FLAGS) ./src/vector/test-vector-struct-point.c ./src/vector/vector-struct-point.c lib/*.c && valgrind ./a.out
+	$(CC) $(INCLUDE_FLAGS) ./src/vector/test-vector-int.c ./src/vector/vector-int.c ../src/* lib/*.c && valgrind ./a.out
+	$(CC) $(INCLUDE_FLAGS) ./src/vector/test-vector-struct-point.c ./src/vector/vector-struct-point.c ../src/* lib/*.c && valgrind ./a.out
 	$(CC) $(INCLUDE_FLAGS) ./src/string/*.c ../src/*.c lib/*.c && valgrind ./a.out
 
 .PHONY: clean