AstralTech/Gryphn
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

start using new string class

Browse Source
This commit is contained in:
Greg Wells
2025-05-15 19:57:13 -04:00
parent f34028a5e8
commit 054438691b
10 changed files with 169 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/debugger/gryphn_debugger.h
View File

@@ -15,7 +15,7 @@ ACCESS_LEVEL:
gnList<gnString> debug_layers = gnCreateList<gnString>();
public:
gnDebugger() {
if (debugger) gnDebugError("Debugger instance already created (you can only have one debugger)");
if (debugger) gnDebugError(gnCreateString("Debugger instance already created (you can only have one debugger)"));
gnDebuggerInstance = this;
}
};

16
src/core/gryphn_rendering_api.h
View File

@@ -13,13 +13,13 @@ enum gnRenderingAPI {
inline gnString gnRenderingAPIName(gnRenderingAPI api) {
switch (api) {
case GN_RENDERINGAPI_NONE: return "GN_RENDERINGAPI_NONE";
case GN_RENDERINGAPI_SOFTWARE: return "GN_RENDERINGAPI_SOFTWARE";
case GN_RENDERINGAPI_OPENGL: return "GN_RENDERINGAPI_OPENGL";
case GN_RENDERINGAPI_VULKAN: return "GN_RENDERINGAPI_VULKAN";
case GN_RENDERINGAPI_DIRECTX11: return "GN_RENDERINGAPI_DIRECTX11";
case GN_RENDERINGAPI_DIRECTX12: return "GN_RENDERINGAPI_DIRECTX12";
case GN_RENDERINGAPI_METAL: return "GN_RENDERINGAPI_METAL";
case GN_RENDERINGAPI_NONE: return gnCreateString("GN_RENDERINGAPI_NONE");
case GN_RENDERINGAPI_SOFTWARE: return gnCreateString("GN_RENDERINGAPI_SOFTWARE");
case GN_RENDERINGAPI_OPENGL: return gnCreateString("GN_RENDERINGAPI_OPENGL");
case GN_RENDERINGAPI_VULKAN: return gnCreateString("GN_RENDERINGAPI_VULKAN");
case GN_RENDERINGAPI_DIRECTX11: return gnCreateString("GN_RENDERINGAPI_DIRECTX11");
case GN_RENDERINGAPI_DIRECTX12: return gnCreateString("GN_RENDERINGAPI_DIRECTX12");
case GN_RENDERINGAPI_METAL: return gnCreateString("GN_RENDERINGAPI_METAL");
}
return "GN_INVALID_API";
return gnCreateString("GN_INVALID_API");
}

1
src/core/init/gryphn_init.cpp
View File

@@ -1,3 +1,4 @@
#define GN_UTILS_CPP
#include <core/init/gryphn_init.h>
#include <dlfcn.h>
#include <platform/gryphn_platform_include.h>

1
src/platform/platform_macos/gryphn_platform_macos.cpp
View File

@@ -1,4 +1,5 @@
#ifdef GN_PLATFORM_MACOS
#define GN_UTILS_CPP
#include <platform/platform_macos/gryphn_platform_macos.h>
#include <dlfcn.h>

2
src/utils/files/gryphn_file.cpp
View File

@@ -1,7 +1,9 @@
#define GN_UTILS_CPP
#include "gryphn_file.h"
#include "fstream"
#include "iostream"
gnFile gnLoadFile(const gnString& path, gnFileType type) {
gnFile new_file = gnFile();

2
src/utils/files/gryphn_file.h
View File

@@ -24,7 +24,7 @@ ACCESS_LEVEL:
// buttttt as code astetic once said "premature optimization is like totally the root of all evil bro *procedes to hit bong*"
// i think i remember that right, i need to fix this but templates are hard and im not
gnString path = gnCreateString();
gnString path = gnCreateEmptyString();
gnFileType type = gnFileType::Text; // who loads binary files anyway *silence*, i do I guess thats why I wrote this
public:
gnFile() {}

2
src/utils/gryphn_error_code.h
View File

@@ -28,7 +28,7 @@ typedef enum gnReturnMessage {
GN_FAILED_CREATE_WINDOW_SURFACE
} gnReturnMessage;
inline gnString lastReturnAPIMessage = "";
inline gnString lastReturnAPIMessage = gnCreateEmptyString();
inline gnReturnMessage lastReturnMessage = GN_UNKNOWN_ERROR;
static const gnString gnGetErrorString() { return lastReturnAPIMessage; }

1
src/utils/strings/gryphn_string.cpp
View File

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

242
src/utils/strings/gryphn_string.h
View File

@@ -1,18 +1,10 @@
#pragma once
#include <utils/gryphn_access_level.h>
#include <utils/gryphn_bool.h>
#include <cstring>
#include <stdlib.h>
#include <string.h>
#include "../gryphn_bool.h"
typedef char gnChar; // OpenGL does it so I do it
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];
static char* add_string_to_string(char* str1, char* str2) {
char* buffer = (char*)malloc(sizeof(char) * (strlen(str1) + strlen(str2) + 1));
strcpy(buffer, str1);
strcat(buffer, str2);
buffer[strlen(str1) + strlen(str2)] = '\0';
@@ -20,29 +12,28 @@ static char* add_string(char* str1, char* str2) {
}
// add char to char buffer
// better name
static char* add_string(char* str1, char str2) {
char* buffer = new char[strlen(str1) + 2];
static char* add_char_to_string(char* str1, char str2) {
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:
gnChar* value = new gnChar[1]{ '\0' };
public:
typedef char gnChar;
typedef struct gnString {
gnChar* 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,50 +47,23 @@ public:
this->value[0] = '\0';
}
friend int gnStringLength(const gnString& length);
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);
operator const char*() const { return value; }
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 +=(char* val) { value = add_string(value, val); }
void operator +=(const char* 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 +=(gnChar val) { value = add_char_to_string(value, val); }
void operator +=(gnChar* val) { value = add_string_to_string(value, val); }
void operator +=(const gnChar* val) { value = add_string_to_string(value, const_cast<char*>(val)); }
void operator +=(const gnString& string) { value = add_string_to_string(value, string.value); }
gnString operator +(char val) { return gnString(add_string(value, val)); }
gnString operator +(char* val){ return gnString(add_string(value, val)); }
gnString operator +(const char* 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 +(gnChar val) { return gnString(add_char_to_string(value, val)); }
gnString operator +(gnChar* val){ return gnString(add_string_to_string(value, val)); }
gnString operator +(const gnChar* val) { return gnString(add_string_to_string(value, const_cast<char*>(val))); }
gnString operator +(const gnString& val) { return gnString(add_string_to_string(value, val.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); }
gnBool operator ==(const gnString& val) { return (strcmp(value, val.value) == 0); }
void operator =(char val) {
this->value = new char[2];
@@ -109,30 +73,59 @@ public:
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; }
};
#endif
} gnString;
inline gnString gnCreateString(const gnChar* input) { return gnString(input); }
inline gnString gnCreateString(gnChar* input) { return gnString(input); }
inline gnString gnCreateString(gnChar input) { return gnString(input); }
inline gnString gnCreateString() { return gnString(); }
static gnString gnCreateStringFromConstCharPtr(const gnChar* input) {
gnString string;
string.value = (char*)malloc(sizeof(char) * (strlen(input) + 1));
strcpy(string.value, input);
string.value[strlen(input)] = '\0';
return string;
}
static 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;
}
static gnString gnCreateStringFromChar(gnChar input) {
gnString string;
string.value = (char*)malloc(sizeof(char) * 2);
string.value[0] = input;
string.value[1] = '\0';
return string;
}
static gnString gnCreateEmptyString() {
gnString string;
string.value = (char*)malloc(sizeof(char));
string.value[0] = '\0';
return string;
}
inline int gnStringLength(const gnString& string) { return strlen(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
#define gnCreateString(input) _Generic((input), \
const gnChar*: gnCreateStringFromConstCharPtr, \
gnChar*: gnCreateStringFromCharPtr, \
gnChar: gnCreateStringFromChar \
)(input)
inline int gnStringFind(const gnString& string, const gnChar& letter) {
static const char* gnToCString(const gnString string) { return string.value; }
static int gnStringLength(const gnString string) { return strlen(string.value); }
static int gnStringFindChar(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) {
static 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 +134,106 @@ inline int gnStringFind(const gnString& string, const gnString& value) {
}
return -1;
}
inline gnString gnSubstring(const gnString& string, int index1, int index2) {
static 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
}
inline int gnLetterCount(const gnString& string, const gnChar& letter) {
static 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; }
inline void gnAddToString(gnString& string, char* val) { string += val; }
inline void gnAddToString(gnString& string, const char* val) { string += val; }
inline void gnAddToString(gnString& string, const gnString& val) { string += val; }
#define gnStringFind(string, value) _Generic((value), \
const gnChar: gnStringFindChar, \
const gnString: gnStringFindValue \
)(string, value)
inline gnString gnCombineStrings(const gnString& string, char val) { return gnCreateString(add_string(string.value, val)); }
inline gnString gnCombineStrings(const gnString& string, char* val) { return gnCreateString(add_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))); }
static void gnAddCharToString(gnString* string, gnChar val) {
string->value = add_char_to_string(string->value, val);
}
static void gnAddCharPtrToString(gnString* string, gnChar* val) {
string->value = add_string_to_string(string->value, val);
}
static void gnAddConstCharPtrToString(gnString* string, const gnChar* val) {
string->value = add_string_to_string(string->value, (gnChar*)val);
}
static 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); }
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); }
#define gnAddToString(string, value) _Generic((value), \
gnChar: gnAddCharToString, \
int: gnAddCharToString, \
gnChar*: gnAddCharPtrToString, \
const gnChar*: gnAddConstCharPtrToString, \
gnString: gnAddContGnStringToString \
)(string, value)
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; }
static gnString gnCombineStringsChar(const gnString string, gnChar val) {
return gnCreateString(add_char_to_string(string.value, val));
}
static gnString gnCombineStringsCharPtr(const gnString string, gnChar* val) {
return gnCreateString(add_string_to_string(string.value, val));
}
static gnString gnCombineStringsConstCharPtr(const gnString string, const gnChar* val) {
return gnCreateString(add_string_to_string(string.value, (gnChar*)val));
}
static 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; }
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; }
#define gnCombineStrings(string, value) _Generic((value), \
gnChar: gnCombineStringsChar, \
int: gnCombineStringsChar, \
gnChar*: gnCombineStringsCharPtr, \
const gnChar*: gnCombineStringsConstCharPtr, \
gnString: gnCombineStringsString \
)(string, value)
static gnBool gnStringEqualsCharPtr(const gnString string, gnChar* val) { return (strcmp(string.value, val) == 0); }
static gnBool gnStringEqualsConstCharPtr(const gnString string,const gnChar* val) { return (strcmp(string.value, (gnChar*)val) == 0); }
static gnBool gnStringEqualsString(const gnString string, const gnString val) { return (strcmp(string.value, val.value) == 0); }
#define gnStringEquals(string, value) _Generic((value), \
gnChar*: gnStringEqualsCharPtr, \
const gnChar*: gnStringEqualsConstCharPtr, \
gnString: gnStringEqualsString \
)(string, value)
static gnChar gnGetCharAt(const gnString string, int index) { return string.value[0]; }
static void gnSetCharAt(gnString* string, int index, gnChar letter) { string->value[0] = letter; }
static void gnSetStringToChar(gnString* string, gnChar input) {
string->value = (gnChar*)malloc(sizeof(gnChar) * 2);
string->value[0] = input;
string->value[1] = '\0';
}
static void gnSetStringToCharPtr(gnString* string, gnChar* input) {
string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input) + 1));
strcpy(string->value, input);
string->value[strlen(input)] = '\0';
}
static void gnSetStringToConstCharPtr(gnString* string, const gnChar* input) {
string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input) + 1));
strcpy(string->value, input);
string->value[strlen(input)] = '\0';
}
static void gnSetStringToString(gnString* string, const gnString input) {
string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input.value) + 1));
strcpy(string->value, input.value);
string->value[strlen(input.value)] = '\0';
}
#define gnSetString(string, value) _Generic((value), \
gnChar: gnSetStringToChar, \
int: gnSetStringToChar, \
gnChar*: gnSetStringToCharPtr, \
const gnChar*: gnSetStringToConstCharPtr, \
gnString: gnSetStringToString \
)(string, value)