Initial commit

lstring.h

@@ -0,0 +1,94 @@
+// LCZ libraries v0.1b
+
+#ifndef _LCZ_STRING_H_
+#define _LCZ_STRING_H_
+
+#ifndef _LCZ_TYPES_H_
+#include "types.h"
+#endif
+
+
+/* String: constant length string.
+ * DString: dynamic length string.
+ * RString: raw c-style string. Not an actual type.
+ *
+ * USAGE INTERFACE:
+ * Length does not include '\0', but most strings should still be zero-terminated.
+ *
+ * DString is purposefully made to have the same memory layout as String,
+ * so you can use DString everywhere you can use String (but not vice-versa) by converting it with TO_STRING(dstr).
+ *
+ * Advanced: Actually String is not constant length. It's just unknown how much space has been allocated for it.
+ * Make sure you have enough space before modifying the lenght.
+ * DStrings change their size automatically if you use the functions in this library.
+ *
+ * IMPLEMENTER INTERFACE
+ * The "text" pointer should always be valid, unless you are building the String objects yourself.
+ * "capacity" and "length" do not include the zero terminator of the string. Make sure you malloc 1 more byte to fit it.
+ *
+
+
+ * String and DString are small containers, so they are not expensive to copy around.
+ * (It's PROBABLY more expensive to dereference a pointer than to copy a String container. Did not profile though.)
+ */
+
+/* @TODO: Add allocator function to parameters?
+ * @TODO: Use String type instead of passing text + length everywhere?
+ *
+ * @Note: I considered adding a SString (Static string, immutable), but it would be so inconvenient to use
+ * that I decided to leave it out (it's just like the "const" keyword)
+ */
+
+struct String
+{
+    char *text;
+    u64   length;
+};
+
+struct DString
+{
+    char *text;
+    u64   length;
+    u64   capacity;
+};
+
+typedef struct String  String;
+typedef struct DString DString;
+
+
+#define TO_STRING(dstr) (*((String*)&dstr))
+
+// String building / constructors
+String string_take(char *src);
+DString dstring_take(char *src);
+String string_copy(const char *src, u64 length);
+DString dstring_copy(const char *src, u64 length);
+DString dstring_new(u64 capacity);
+// n = number of strings, ... = , const char *src1, u64 length1, ...
+String string_concat(u32 n, ...);
+// n = number of strings, ... = , const char *src1, u64 length1, ...
+DString dstring_concat(u32 n, ...);
+
+// Compute string length, excluding zero-terminator
+u64 rstring_length(const char *src);
+
+// Comparison
+int rstring_compare(const char *left, const char *right);
+bool string_equal(String left, String right);
+bool string_find(String str, u64 start_index, String to_find, u64 *found_index);
+
+// String specific operations
+// Warning: You have to make sure the space pointed by str is big enough to fit to_append.
+void string_append(String *str, const char *to_append, u64 count);
+String string_substring(String *str, u64 start, u64 end);
+String string_trim(String *str);
+
+// DString specific operations
+void dstring_reserve(DString *dstr, u64 new_length);
+void dstring_append(DString *dstr, const char *to_append, u64 count);
+void dstring_insert(DString *dstr, u64 index, const char *to_insert, u64 count);
+void dstring_erase(DString *dstr, u64 index, u64 count);
+void dstring_replace(DString *dstr, u64 index, u64 rem_count, const char *to_insert, u64 ins_count);
+
+
+#endif