make string header only

src/strings/gryphn_string.cpp

@@ -1 +0,0 @@
-//#include "gryphn_string.h"

src/strings/gryphn_string.h

@@ -1,18 +1,10 @@
 #pragma once
-#include <utils/gryphn_access_level.h>
+#include <stdlib.h>
-#include <utils/gryphn_bool.h>
+#include <string.h>
-#include <cstring>
+#include "../gryphn_bool.h"
 
-typedef char gnChar; // OpenGL does it so I do it
+static char* add_string_to_string(char* str1, char* str2) {
-
+    char* buffer = (char*)malloc(sizeof(char) * (strlen(str1) + strlen(str2) + 1));
-struct gnString;
-static const char* gnToCString(const gnString& string);
-
-// apis for char buffers togethers
-// wack ass name idk what it means but im keepin it
-// this just adds to char buffers into one big buffer
-static char* add_string(char* str1, char* str2) {
-    char* buffer = new char[strlen(str1) + strlen(str2) + 1];
     strcpy(buffer, str1);
     strcat(buffer, str2);
     buffer[strlen(str1) + strlen(str2)] = '\0';
@@ -20,29 +12,29 @@ static char* add_string(char* str1, char* str2) {
 }
 // add char to char buffer
 // better name
-static char* add_string(char* str1, char str2) {
+static char* add_char_to_string(char* str1, char str2) {
-    char* buffer = new char[strlen(str1) + 2];
+    char* buffer = (char*)malloc(sizeof(char) * (strlen(str1) + 2));
     strcpy(buffer, str1);
     buffer[strlen(str1)] = str2;
     buffer[strlen(str1) + 1] = '\0';
     return buffer;
 }
 
-struct gnString {
+
-ACCESS_LEVEL:
+typedef char gnChar;
-    gnChar* value = new gnChar[1]{ '\0' };
+
-public:
+typedef struct gnString {
+    char* value;
+
+#ifdef GN_UTILS_CPP
     gnString(const gnChar* input) {
         this->value = new gnChar[strlen(input) + 1]; // so like my dumbass forgot to put this earlier and some shit was broken but now it fixed
                                                      // I was wondering why one specific string crashed my program, it was my fault
-
-        char* converted_input = const_cast<char*>(input); // yea un const that const value, this line cost me hours cuz I cant read error codes
         strcpy(this->value, input);
         this->value[strlen(input)] = '\0';
     }
     gnString(gnChar* input) {
         this->value = new gnChar[strlen(input) + 1];
-
         strcpy(this->value, input);
         this->value[strlen(input)] = '\0';
     }
@@ -56,83 +48,73 @@ public:
         this->value[0] = '\0';
     }
 
-    friend int gnStringLength(const gnString& length);
+    operator const char*() const { return value; }
-    friend int gnStringFind(const gnString& string, const gnChar& letter);
-    friend int gnStringFind(const gnString& string, const gnString& value);
-    friend const char* gnToCString(const gnString& string); // dumb ass name but this shit gets used so much
-    friend gnString gnSubstring(const gnString& string, int index1, int index2);
 
-    friend int gnLetterCount(const gnString& string, const gnChar& letter);
-    friend gnChar gnGetCharAt(const gnString& string, int index);
-    friend void gnSetCharAt(gnString& string, int index, gnChar letter);
-
-    friend void gnAddToString(gnString& string, char val);
-    friend void gnAddToString(gnString& string, char* val);
-    friend void gnAddToString(gnString& string, const char* val);
-    friend void gnAddToString(gnString& string, const gnString& val);
-
-    friend gnString gnCombineStrings(const gnString& string, char val); // this shit is not combining a string but im lazy, fuck off
-    friend gnString gnCombineStrings(const gnString& string, char* val);
-    friend gnString gnCombineStrings(const gnString& string, const char* val);
-    friend gnString gnCombineStrings(const gnString& string, const gnString& val);
-
-    friend gnBool gnStringEquals(const gnString& string, char* val);
-    friend gnBool gnStringEquals(const gnString& string, const char* val);
-    friend gnBool gnStringEquals(const gnString& string, const gnString& val);
-
-    friend void gnSetString(gnString& string, const gnString& input);
-    friend void gnSetString(gnString& string, const gnChar* input);
-    friend void gnSetString(gnString& string, gnChar* input);
-    friend void gnSetString(gnString& string, gnChar input);
-public:
     char operator[](int index) { return value [index]; }
     const char operator[](int index) const { return value [index]; }
-    void operator +=(char val) { value = add_string(value, val); }
+    // void operator +=(gnChar val) { value = add_string(value, val); }
-    void operator +=(char* val) { value = add_string(value, val); }
+    // void operator +=(gnChar* val) { value = add_string(value, val); }
-    void operator +=(const char* val) { value = add_string(value, const_cast<char*>(val)); }
+    // void operator +=(const gnChar* val) { value = add_string(value, const_cast<char*>(val)); }
-    void operator +=(const gnString& string) { value = add_string(value, const_cast<char*>(gnToCString(string))); }
+    // void operator +=(const gnString& string) { value = add_string(value, const_cast<char*>(gnToCString(string))); }
 
-    gnString operator +(char val) { return gnString(add_string(value, val)); }
+    // gnString operator +(gnChar val) { return gnString(add_string(value, val)); }
-    gnString operator +(char* val){ return gnString(add_string(value, val)); }
+    // gnString operator +(gnChar* val){ return gnString(add_string(value, val)); }
-    gnString operator +(const char* val) { return gnString(add_string(value, const_cast<char*>(val))); }
+    // gnString operator +(const gnChar* val) { return gnString(add_string(value, const_cast<char*>(val))); }
-    gnString operator +(const gnString& val) { return gnString(add_string(value, const_cast<char*>(val.value))); }
+    // gnString operator +(const gnString& val) { return gnString(add_string(value, const_cast<char*>(val.value))); }
 
-    gnBool operator ==(char* val) { return (strcmp(value, val) == 0); }
+#endif
-    gnBool operator ==(const char* val) { return (strcmp(value, const_cast<char*>(val)) == 0); }
+} gnString;
-    gnBool operator ==(const gnString& val) { return (strcmp(value, const_cast<char*>(val.value)) == 0); }
 
-    void operator =(char val) {
+gnString gnCreateStringFromConstCharPtr(const gnChar* input) {
-        this->value = new char[2];
+    gnString string;
-        this->value[0] = val;
+    string.value = (char*)malloc(sizeof(char) * (strlen(input) + 1));
-        this->value[1] = '\0';
+    strcpy(string.value, input);
-    }
+    string.value[strlen(input)] = '\0';
-    void operator =(char* val) { this->value = val; }
+    return string;
-    void operator =(const char* val) { this->value = const_cast<char*>(val); }
+}
-    void operator =(const gnString& val) { this->value = val.value; }
+gnString gnCreateStringFromCharPtr(gnChar* input) {
-};
+    gnString sting;
+    sting.value = (char*)malloc(sizeof(char) * (strlen(input) + 1));
+    strcpy(sting.value, input);
+    sting.value[strlen(input)] = '\0';
+    return sting;
+}
+gnString gnCreateStringFromChar(gnChar input) {
+    gnString string;
+    string.value = (char*)malloc(sizeof(char) * 2);
+    string.value[0] = input;
+    string.value[1] = '\0';
+    return string;
+}
+gnString gnCreateEmptyString() {
+    gnString string;
+    string.value = (char*)malloc(sizeof(char));
+    string.value[0] = '\0';
+    return string;
+}
 
-inline gnString gnCreateString(const gnChar* input) { return gnString(input); }
+#define gnCreateString(input) _Generic((input), \
-inline gnString gnCreateString(gnChar* input) { return gnString(input); }
+    const gnChar*: gnCreateStringFromConstCharPtr, \
-inline gnString gnCreateString(gnChar input) { return gnString(input); }
+    gnChar*: gnCreateStringFromCharPtr, \
-inline gnString gnCreateString() { return gnString(); }
+    gnChar: gnCreateStringFromChar \
+)(input)
 
-inline int gnStringLength(const gnString& string) { return strlen(string.value); }
+const char* gnToCString(const gnString string) { return string.value; }
-inline const char* gnToCString(const gnString& string) { return string.value; } // this is what Bjarne Stroustrup Sausage man intented me to do with his language
+int gnStringLength(const gnString string) { return strlen(string.value); }
-
+int gnStringFindChar(const gnString string, const gnChar letter) {
-inline int gnStringFind(const gnString& string, const gnChar& letter) {
     for (int i = 0; i < strlen(string.value); i++)
         if (string.value[i] == letter)
             return i;
     return -1;
 }
-inline int gnStringFind(const gnString& string, const gnString& value) {
+int gnStringFindString(const gnString string, const gnString value) {
     char first_char = value.value[0];
     for (int i = 0; i < strlen(string.value); i++)
         if (string.value[i] == first_char) {
-            bool same = true;
+            gnBool same = gnTrue;
             for (int c = 1; c < strlen(value.value); c++)
                 if (string.value[i + c] != value.value[c]) {
-                    same = false;
+                    same = gnFalse;
                     break;
                 }
 
@@ -141,41 +123,90 @@ inline int gnStringFind(const gnString& string, const gnString& value) {
         }
     return -1;
 }
-
+gnString gnSubstring(const gnString string, int index1, int index2) {
-inline gnString gnSubstring(const gnString& string, int index1, int index2) {
     if (index2 == -1) index2 = gnStringLength(string);
-    char* out_value = new char[(index2 - index1) + 1];
+    char* out_value = (char*)malloc(sizeof(char) * ((index2 - index1) + 1));
     for (int i = 0; i < (index2 - index1); i++)
         out_value[i] = string.value[i + index1];
     out_value[(index2 - index1)] = '\0';
     return gnCreateString(out_value); // zero error checking on this function should really add that in later but like I dont have a logging library that I want to use
                                       // my code never breaks either so I dont need error checks, il just not make errors cuz im not tim
 }
-
+int gnLetterCount(const gnString string, const gnChar letter) {
-inline int gnLetterCount(const gnString& string, const gnChar& letter) {
     int count = 0;
     for (int i = 0; i < gnStringLength(string); i++) if (string.value[i] == letter) count++;
     return count;
 }
 
-inline void gnAddToString(gnString& string, char val) { string += val; }
+#define gnStringFind(string, value) _Generic((value), \
-inline void gnAddToString(gnString& string, char* val) { string += val; }
+    const gnChar: gnStringFindChar, \
-inline void gnAddToString(gnString& string, const char* val) { string += val; }
+    const gnString: gnStringFindValue \
-inline void gnAddToString(gnString& string, const gnString& val) { string += val; }
+)(string, value)
+gnString gnSubstring(const gnString string, int index1, int index2);
 
-inline gnString gnCombineStrings(const gnString& string, char val) { return gnCreateString(add_string(string.value, val)); }
+void gnAddCharToString(gnString string, gnChar val) {
-inline gnString gnCombineStrings(const gnString& string, char* val) { return gnCreateString(add_string(string.value, val)); }
+    string.value = add_char_to_string(string.value, val);
-inline gnString gnCombineStrings(const gnString& string, const char* val) { return gnCreateString(add_string(string.value, const_cast<char*>(val))); }
+}
-inline gnString gnCombineStrings(const gnString& string, const gnString& val) { return gnCreateString(add_string(string.value, const_cast<char*>(val.value))); }
+void gnAddCharPtrToString(gnString string, gnChar* val) {
+    string.value = add_string_to_string(string.value, val);
+}
+void gnAddConstCharPtrToString(gnString string, const gnChar* val) {
+    string.value = add_string_to_string(string.value, (gnChar*)val);
+}
+void gnAddContGnStringToString(gnString string, gnString val) {
+    string.value = add_string_to_string(string.value, val.value);
+}
 
-inline gnBool gnStringEquals(const gnString& string, char* val) { return (strcmp(string.value, val) == 0); }
+#define gnAddToString(string, value) _Generic((value), \
-inline gnBool gnStringEquals(const gnString& string,const char* val) { return (strcmp(string.value, const_cast<char*>(val)) == 0); }
+    gnChar: gnAddCharToString, \
-inline gnBool gnStringEquals(const gnString& string, const gnString& val) { return (strcmp(string.value, const_cast<char*>(val.value)) == 0); }
+    int: gnAddCharToString, \
+    gnChar*: gnAddCharPtrToString, \
+    const gnChar*: gnAddConstCharPtrToString, \
+    gnString: gnAddContGnStringToString \
+)(string, value)
 
-inline gnChar gnGetCharAt(const gnString& string, int index) { return string.value[0]; }
+gnString gnCombineStringsChar(const gnString string, gnChar val) {
-inline void gnSetCharAt(gnString& string, int index, gnChar letter) { string.value[0] = letter; }
+     return gnCreateString(add_char_to_string(string.value, val));
+}
+gnString gnCombineStringsCharPtr(const gnString string, gnChar* val) {
+    return gnCreateString(add_string_to_string(string.value, val));
+}
+gnString gnCombineStringsConstCharPtr(const gnString string, const gnChar* val) {
+    return gnCreateString(add_string_to_string(string.value, (gnChar*)val));
+}
+gnString gnCombineStringsString(const gnString string, const gnString val) {
+    return gnCreateString(add_string_to_string(string.value, val.value));
+}
 
-inline void gnSetString(gnString& string, const gnString& input) { string.value = input.value; }
+#define gnCombineStrings(string, value) _Generic((value), \
-inline void gnSetString(gnString& string, const gnChar* input) { string.value = const_cast<char*>(input); }
+    gnChar: gnCombineStringsChar, \
-inline void gnSetString(gnString& string, gnChar* input) { string.value = input; }
+    int: gnCombineStringsChar, \
-inline void gnSetString(gnString& string, gnChar input) { string = input; }
+    gnChar*: gnCombineStringsCharPtr, \
+    const gnChar*: gnCombineStringsConstCharPtr, \
+    gnString: gnCombineStringsString \
+)(string, value)
+//     gnBool operator ==(char* val) { return (strcmp(value, val) == 0); }
+//     gnBool operator ==(const char* val) { return (strcmp(value, const_cast<char*>(val)) == 0); }
+//     gnBool operator ==(const gnString& val) { return (strcmp(value, const_cast<char*>(val.value)) == 0); }
+
+//     void operator =(char val) {
+//         this->value = new char[2];
+//         this->value[0] = val;
+//         this->value[1] = '\0';
+//     }
+//     void operator =(char* val) { this->value = val; }
+//     void operator =(const char* val) { this->value = const_cast<char*>(val); }
+//     void operator =(const gnString& val) { this->value = val.value; }
+// };
+
+// inline gnBool gnStringEquals(const gnString& string, char* val) { return (strcmp(string.value, val) == 0); }
+// inline gnBool gnStringEquals(const gnString& string,const char* val) { return (strcmp(string.value, const_cast<char*>(val)) == 0); }
+// inline gnBool gnStringEquals(const gnString& string, const gnString& val) { return (strcmp(string.value, const_cast<char*>(val.value)) == 0); }
+
+// inline gnChar gnGetCharAt(const gnString& string, int index) { return string.value[0]; }
+// inline void gnSetCharAt(gnString& string, int index, gnChar letter) { string.value[0] = letter; }
+
+// inline void gnSetString(gnString& string, const gnString& input) { string.value = input.value; }
+// inline void gnSetString(gnString& string, const gnChar* input) { string.value = const_cast<char*>(input); }
+// inline void gnSetString(gnString& string, gnChar* input) { string.value = input; }
+// inline void gnSetString(gnString& string, gnChar input) { string = input; }