string.c File Reference

#include "arc/std/string.h"
#include "arc/std/bool.h"
#include "arc/std/errno.h"
#include <stdint.h>
#include <stdlib.h>

Go to the source code of this file.

Functions
void	ARC_String_Create (ARC_String **string, char *data, uint64_t length)
	creates ARC_String type
void	ARC_String_CreateWithStrlen (ARC_String **string, char *data)
	creates ARC_String type with strinlen
void	ARC_String_CreateEmpty (ARC_String **string, uint64_t length)
	creates an empty ARC_String type, useful if you want to add to the string over time without having to keep adding to the size
void	ARC_String_Destroy (ARC_String *string)
	destroys ARC_String type
void	ARC_String_Copy (ARC_String **copy, ARC_String *original)
	copy a ARC_String
void	ARC_String_CopySubstring (ARC_String **substring, ARC_String *original, uint64_t start, uint64_t length)
	copy a subtring from a givin ARC_String
void	ARC_String_ReplaceWithSubstring (ARC_String **string, uint64_t start, uint64_t length)
	replaces a string with a section of itself
void	ARC_String_RemoveSubstring (ARC_String **newString, ARC_String *original, ARC_String *substring)
	copy a subtring from a givin ARC_String
void	ARC_String_Append (ARC_String **string, ARC_String *append)
	appends to an ARC_String with an ARC_String
void	ARC_String_AppendCString (ARC_String **string, const char *cstring, uint64_t length)
	appends to an ARC_String with an ARC_String
void	ARC_String_AppendCStringWithStrlen (ARC_String **string, const char *cstring)
	appends to an ARC_String with an ARC_String
ARC_Bool	ARC_String_Equals (ARC_String *first, ARC_String *second)
	checks if two strings are the same
ARC_Bool	ARC_String_EqualsCString (ARC_String *string, const char *cstring, uint64_t length)
	check if ARC_String and cstring match
ARC_Bool	ARC_String_EqualsCStringWithStrlen (ARC_String *string, const char *cstring)
	check if ARC_String and cstring match
ARC_Bool	ARC_String_SubstringEquals (ARC_String *first, uint64_t offset, ARC_String *second)
	check if substring of first equals second string
ARC_Bool	ARC_String_SubstringEqualsCString (ARC_String *string, uint64_t offset, const char *cstring, uint64_t length)
	check if ARC_String and cstring match
ARC_Bool	ARC_String_IsAlpha (ARC_String *string)
	checks if string is alphabetic
ARC_Bool	ARC_String_IsNumeric (ARC_String *string)
	checks if string is made out of only numbers
uint64_t	ARC_String_ToUint64_t (ARC_String *string)
	converst substring from string to uint64_t
int64_t	ARC_String_ToInt64_t (ARC_String *string)
	converst substring from string to int64_t
double	ARC_String_ToDouble (ARC_String *string)
	converst substring from string to double
uint64_t	ARC_String_Find (ARC_String *string, ARC_String *substring)
	takes a given string, and assigns index and length for position of first matching substring
uint64_t	ARC_String_FindCString (ARC_String *string, const char *cstring, uint64_t length)
	takes given cstring and gives position of first matching
uint64_t	ARC_String_FindCStringWithStrlen (ARC_String *string, const char *cstring)
	takes given cstring and gives position of first matching
uint64_t	ARC_String_FindBack (ARC_String *string, ARC_String *substring)
	takes a given string, and assigns index and length for position of last matching substring
uint64_t	ARC_String_FindBackCString (ARC_String *string, const char *cstring, uint64_t length)
	takes a given cstring and give position of last matching
uint64_t	ARC_String_FindBackCStringWithStrlen (ARC_String *string, const char *cstring)
	takes a given cstring and give position of last matching
void	ARC_String_StripEnds (ARC_String **stripped, ARC_String *original, char charToStrip)
	strips the ends based on a given char
void	ARC_String_StripWhitespace (ARC_String **stripped, ARC_String *original)
	strips whitespace from a ARC_String
void	ARC_String_StripEndsWhitespace (ARC_String **stripped, ARC_String *original)
	strips the whitespace from the ends of a string
void	ARC_String_Merge (ARC_String **combined, ARC_String *first, ARC_String *second)
	merges two strings together
void	ARC_String_RemoveSection (ARC_String **newString, ARC_String *original, uint64_t removeIndex, uint64_t removeLength)
	copy a subtring from a givin ARC_String
void	ARC_String_ReplaceMatching (ARC_String **string, ARC_String *pattern, ARC_String *replacement)
	replaces characters in string matching the given pattern
void	ARC_String_CopyReplaceMatching (ARC_String **newString, ARC_String *original, ARC_String *pattern, ARC_String *replacement)
	replaces characters in a copy of a string matching the given pattern
void	ARC_String_ReplaceMatchingCString (ARC_String **string, char *patternCString, uint64_t patternLength, char *replacementCString, uint64_t replacementLength)
	replaces characters in string matching the given pattern
void	ARC_String_ReplaceMatchingCStringWithStrlen (ARC_String **string, char *patternCString, char *replacementCString)
	replaces characters in string matching the given pattern

Function Documentation

ARC_String_Append()

void ARC_String_Append	(	ARC_String **	string,
		ARC_String *	append )

appends to an ARC_String with an ARC_String

Note

this uses ARC_String_AppendCString, so debug logs will be thrown in that function not this one

Parameters

string	the string to add to, will not change on error
append	the string that will be added to the back of string

Definition at line 126 of file string.c.

                                                               {
    ARC_String_AppendCString(string, append->data, append->length);
}

References ARC_String_AppendCString(), ARC_String::data, and ARC_String::length.

Referenced by ARC_ParserData_HelperRecurseStringAdd(), and ARC_ParserLangParsedData_RecurseStringAdd().

ARC_String_AppendCString()

void ARC_String_AppendCString	(	ARC_String **	string,
		const char *	cstring,
		uint64_t	length )

appends to an ARC_String with an ARC_String

Parameters

string	the string to add to, will not change on error
cstring	the cstring that will be added to the back of string
length	the length of the cstring that is being added

Definition at line 130 of file string.c.

                                                                                        {
    char *data = (char *)malloc(sizeof(char) * ((*string)->length + length + 1));
 
    strncpy(data, (*string)->data, (*string)->length);
    strncpy(data + (*string)->length, cstring, length);
    data[(*string)->length + length] = '\0';
 
    free((*string)->data);
 
    (*string)->data = data;
    (*string)->length = (*string)->length + length;
}

Referenced by ARC_ParserLangParsedData_RecurseStringAdd(), ARC_Ssh_ExecStrInNewSessionAndGetResponse(), ARC_String_Append(), and ARC_String_AppendCStringWithStrlen().

ARC_String_AppendCStringWithStrlen()

void ARC_String_AppendCStringWithStrlen	(	ARC_String **	string,
		const char *	cstring )

appends to an ARC_String with an ARC_String

Note

this uses ARC_String_AppendCString, so debug logs will be thrown in that function not this one

Parameters

string	the string to add to, will not change on error
cstring	the cstring that will be added to the back of string

Definition at line 143 of file string.c.

                                                                                 {
    ARC_String_AppendCString(string, cstring, strlen(cstring));
}

References ARC_String_AppendCString().

Referenced by ARC_Config_FileIO().

ARC_String_Copy()

void ARC_String_Copy	(	ARC_String **	copy,
		ARC_String *	original )

copy a ARC_String

Parameters

copy	copy of oldString, will be set to NULL on error
original	original string that is being copied

Definition at line 62 of file string.c.

                                                             {
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *copy = NULL;
        return;
    }
 
    ARC_String_Create(copy, original->data, original->length);
}

References arc_errno, ARC_ERRNO_NULL, ARC_String_Create(), ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_RemoveAndRunCommands(), ARC_Config_StripComment(), ARC_LexerTokenRule_CreateAndReturnMatchCharInStringRule(), ARC_LexerTokenRule_CreateAndReturnMatchStringRule(), ARC_Parser_CreateFromString(), ARC_String_CopyReplaceMatching(), ARC_String_RemoveSection(), and ARC_Text_Create().

ARC_String_CopyReplaceMatching()

void ARC_String_CopyReplaceMatching	(	ARC_String **	newString,
		ARC_String *	original,
		ARC_String *	pattern,
		ARC_String *	replacement )

replaces characters in a copy of a string matching the given pattern

Note

original will not be modified

newString will need to be destroyed if it is not set to NULL

Parameters

newString	an empty string that this function will fill with a copy with replacements, will be set to NULL and arc_errno set on fail
original	the original string that will be copied
pattern	the pattern to replace in the string on match
replacement	the string that will replace the matched pattern

Definition at line 537 of file string.c.

                                                                                                                               {
    //TODO: probs want to check if the replacement goes over a uint64_t size
    if(original == NULL || pattern == NULL || replacement == NULL){
        arc_errno = ARC_ERRNO_NULL;
        ARC_DEBUG_LOG_ERROR("ARC_String_CopyReplaceMatching(newString, original, pattern, replacement), original, pattern, or replacement was null");
        return;
    }
 
    uint64_t numberOfMatches = 0;
    for(uint64_t originalIndex = 0; originalIndex < original->length; originalIndex++){
        if(ARC_String_SubstringEquals(original, originalIndex, pattern)){
            numberOfMatches++;
            originalIndex += pattern->length - 1;
        }
    }
 
    //no matches were found, but that isn't an error, so copy and return
    if(numberOfMatches == 0){
        ARC_String_Copy(newString, original);
        return;
    }
 
    (*newString) = (ARC_String *)malloc(sizeof(ARC_String));
    (*newString)->length = original->length + (replacement->length - pattern->length);
    (*newString)->data   = (char *)malloc(sizeof(char *) * original->length + 1);
 
    for(uint64_t originalIndex = 0, newIndex = 0; originalIndex < original->length; originalIndex++, newIndex++){
        if(ARC_String_SubstringEquals(original, originalIndex, pattern)){
            for(uint64_t replacementIndex = 0; replacementIndex < replacement->length; replacementIndex++){
                (*newString)->data[newIndex + replacementIndex] = replacement->data[replacementIndex];
            }
 
            originalIndex += pattern->length - 1;
            newIndex += replacement->length - 1;
            continue;
        }
 
        (*newString)->data[newIndex] = original->data[originalIndex];
    }
 
    (*newString)->data[(*newString)->length] = '\0';
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String_Copy(), ARC_String_SubstringEquals(), ARC_String::data, and ARC_String::length.

Referenced by ARC_String_ReplaceMatching().

ARC_String_CopySubstring()

void ARC_String_CopySubstring	(	ARC_String **	substring,
		ARC_String *	original,
		uint64_t	start,
		uint64_t	length )

copy a subtring from a givin ARC_String

Parameters

substring	new coppied substring, will be null on error
original	string to copy substring from
start	starting index in relation on original
length	length of substring that is being created

Definition at line 72 of file string.c.

                                                                                                            {
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *substring = NULL;
        return;
    }
 
    if(length == 0){
        *substring = NULL;
        return;
    }
 
    if(start + length > original->length){
        arc_errno = ARC_ERRNO_DATA;
        *substring = NULL;
        return;
    }
 
    char data[length];
    for(uint32_t i = 0; i < length; i++){
        data[i] = 0;
    }
 
    strncpy(data, original->data + start, length);
 
    ARC_String_Create(substring, data, length);
}

References arc_errno, ARC_ERRNO_DATA, ARC_ERRNO_NULL, ARC_String_Create(), ARC_String::data, and ARC_String::length.

Referenced by ARC_Audio_Read(), ARC_Config_Get(), ARC_Config_GetNameAndValue(), ARC_Config_Recurse(), ARC_Config_RemoveAndRunCommands(), ARC_Config_RunCommand(), ARC_Config_SetKeyGroup(), ARC_Config_StripComment(), ARC_Point_Read(), ARC_Rect_Read(), ARC_RectArray_Read(), ARC_RectArray_ReadRect(), ARC_SDL_Texture_Read(), ARC_Sprite_Delete(), ARC_Sprite_Read(), ARC_Spritesheet_Delete(), ARC_Spritesheet_Read(), ARC_Spritesheet_ReadTexture(), ARC_String_RemoveSection(), ARC_String_ReplaceWithSubstring(), and ARC_String_StripEndsWhitespace().

ARC_String_Create()

void ARC_String_Create	(	ARC_String **	string,
		char *	data,
		uint64_t	length )

creates ARC_String type

Parameters

string	ARC_String to create
data	cstring that will be stored in ARC_String
length	length of ARC_String

Definition at line 9 of file string.c.

                                                                        {
    //check if the size is too big to create and error if so
    if(length == ~(uint64_t)0){
        arc_errno = ARC_ERRNO_OVERFLOW;
        ARC_DEBUG_LOG_ERROR("ARC_String_Create(string, data, length), length was max uint64_t which is bigger than allowed");
        *string = NULL;
        return;
    }
 
    //create the string container and malloc the char array (this will allways be bigger than zero so there will be no issue if zero is passed in)
    *string           = (ARC_String *)malloc(sizeof(ARC_String));
    (*string)->data   = (char       *)malloc(sizeof(char) * (length + 1));
    (*string)->length = length;
 
    //if the string has a size, copy the string
    if(length > 0){
        strncpy((*string)->data, data, length);
    }
 
    //set the end of the string to \0 (to mirror how cstrings work)
    (*string)->data[length] = '\0';
}

References ARC_DEBUG_LOG_ERROR, arc_errno, and ARC_ERRNO_OVERFLOW.

Referenced by ARC_Config_RemoveAndRunCommands(), ARC_Config_RemoveComments(), ARC_Config_RunCommand(), ARC_ConsoleBuffer_AddChar(), ARC_ConsoleView_GetStringInput(), ARC_IO_FileToStr(), ARC_Lexer_AutomataMatchCharOrBetweenFn(), ARC_ParserCSVData_GetDataTag(), ARC_ParserLangParsedData_CreateTagString(), ARC_ParserLangParsedData_GetArgumentTag(), ARC_Ssh_ExecStrInNewSessionAndGetResponse(), ARC_String_Copy(), ARC_String_CopySubstring(), ARC_String_CreateWithStrlen(), ARC_String_Merge(), ARC_String_StripEnds(), ARC_String_StripWhitespace(), and TEST_ParserData_CreateStringFn().

ARC_String_CreateEmpty()

void ARC_String_CreateEmpty	(	ARC_String **	string,
		uint64_t	length )

creates an empty ARC_String type, useful if you want to add to the string over time without having to keep adding to the size

Parameters

string	ARC_String to create
length	length of ARC_String

Definition at line 37 of file string.c.

                                                                 {
    //check if the size is too big to create and error if so
    if(length == ~(uint64_t)0){
        arc_errno = ARC_ERRNO_OVERFLOW;
        ARC_DEBUG_LOG_ERROR("ARC_String_Create(string, data, length), length was max uint64_t which is bigger than allowed");
        *string = NULL;
        return;
    }
 
    //create the string container and initialize data with all 0s for the size
    *string           = (ARC_String *)malloc(sizeof(ARC_String));
    (*string)->data   = (char       *)calloc(sizeof(char), length + 1);
    (*string)->length = length;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, and ARC_ERRNO_OVERFLOW.

ARC_String_CreateWithStrlen()

void ARC_String_CreateWithStrlen	(	ARC_String **	string,
		char *	data )

creates ARC_String type with strinlen

Parameters

string	ARC_String to create
data	cstring that will be stored in ARC_String

Definition at line 32 of file string.c.

                                                                 {
    //create the string passing in the strlen of data for the length
    ARC_String_Create(string, data, strlen(data));
}

References ARC_String_Create().

Referenced by ARC_Chemical_Create(), ARC_Lexer_InitBasicTokenRules(), ARC_ParserCSV_CreateAsParser(), ARC_ParserLang_InitLexerRulesFn(), ARC_TEST(), ARC_TEST(), ARC_TEST(), ARC_TEST(), ARC_TEST(), ARC_TEST(), ARC_TEST(), ARC_TEST(), and ARC_TEST().

ARC_String_Destroy()

void ARC_String_Destroy

(

ARC_String *

string

)

destroys ARC_String type

Parameters

string

string that will be destroyed

Definition at line 52 of file string.c.

                                           {
    //check if the string's data exists and if so free it
    if(string->data != NULL){
        free(string->data);
    }
 
    //free the string itself
    free(string);
}

References ARC_String::data.

Referenced by ARC_Chemical_Create(), ARC_Config_FileIO(), ARC_Config_Get(), ARC_Config_GetNameAndValue(), ARC_Config_Recurse(), ARC_Config_RemoveAndRunCommands(), ARC_Config_RemoveComments(), ARC_Config_RunCommand(), ARC_Config_SetKeyGroup(), ARC_Config_StripComment(), ARC_ConsoleBuffer_AddChar(), ARC_ConsoleBuffer_Clear(), ARC_ConsoleBuffer_Destroy(), ARC_ConsoleShell_Destroy(), ARC_Lexer_InitBasicTokenRules(), ARC_Lexer_LexFile(), ARC_Lexer_LexString(), ARC_LexerToken_VectorDestroyDataFn(), ARC_LexerTokenRule_DestroyStringAutomataDataFn(), ARC_ParserCSV_CreateAsParser(), ARC_ParserCSVData_DestroyFn(), ARC_ParserCSVData_GetDataTag(), ARC_ParserLang_InitLexerRulesFn(), ARC_ParserLangParsedData_CreateBodyTag(), ARC_ParserLangParsedData_GetArgumentTag(), ARC_Point_Read(), ARC_Rect_Read(), ARC_RectArray_Read(), ARC_RectArray_ReadRect(), ARC_SDL_Texture_Read(), ARC_Sprite_Delete(), ARC_Sprite_Read(), ARC_Spritesheet_Delete(), ARC_Spritesheet_Read(), ARC_Spritesheet_ReadTexture(), ARC_Ssh_ExecStrInNewSessionAndGetResponse(), ARC_String_RemoveSection(), ARC_String_ReplaceMatching(), ARC_String_ReplaceMatchingCString(), ARC_String_ReplaceWithSubstring(), ARC_TEST(), ARC_Text_Destroy(), and TEST_ParserData_DestroyStringFn().

ARC_String_Equals()

ARC_Bool ARC_String_Equals	(	ARC_String *	first,
		ARC_String *	second )

checks if two strings are the same

Parameters

first	string to check against second
second	string to check against first

Returns

ARC_True if match, ARC_False if they don't match

Definition at line 147 of file string.c.

                                                                 {
    if(first->length != second->length){
        return ARC_False;
    }
 
    if(strncmp(first->data, second->data, first->length)){
        return ARC_False;
    }
 
    return ARC_True;
}

References ARC_False, ARC_True, ARC_String::data, and ARC_String::length.

ARC_String_EqualsCString()

ARC_Bool ARC_String_EqualsCString	(	ARC_String *	string,
		const char *	cstring,
		uint64_t	length )

check if ARC_String and cstring match

Parameters

string	ARC_string to check
cstring	cstring to check
length	length of cstring

Returns

ARC_True if match, ARC_False if they don't match

Definition at line 159 of file string.c.

                                                                                           {
    if(string->length != length){
        return ARC_False;
    }
 
    if(strncmp(string->data, cstring, string->length)){
        return ARC_False;
    }
 
    return ARC_True;
}

References ARC_False, ARC_True, ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_Recurse(), ARC_Config_RunCommand(), and ARC_String_EqualsCStringWithStrlen().

ARC_String_EqualsCStringWithStrlen()

ARC_Bool ARC_String_EqualsCStringWithStrlen	(	ARC_String *	string,
		const char *	cstring )

check if ARC_String and cstring match

Note

will use strlen to get the length of the cstring

Parameters

string	ARC_string to check
cstring	cstring to check

Returns

ARC_True if match, ARC_False if they don't match

Definition at line 171 of file string.c.

                                                                                    {
    return ARC_String_EqualsCString(string, cstring, strlen(cstring));
}

References ARC_String_EqualsCString().

Referenced by ARC_Chemical_GetStringIdFn(), ARC_ParserCSV_GetStringIdFn(), ARC_TEST(), TEST_Parser_GetStringIdFn(), and TEST_ParserLang_GetIdFn().

ARC_String_Find()

uint64_t ARC_String_Find	(	ARC_String *	string,
		ARC_String *	substring )

takes a given string, and assigns index and length for position of first matching substring

Parameters

string	the string that will be searched
substr	substring to find within string

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 231 of file string.c.

                                                                   {
    if(!string || !substring){
        ARC_DEBUG_LOG_ERROR("ARC_String_Find(string, substring), string or substring was null");
        arc_errno = ARC_ERRNO_NULL;
        return ~(uint64_t)0;
    }
 
    if(substring->length > string->length){
        return ~(uint64_t)0;
    }
 
    uint64_t max = string->length - (substring->length - 1);
    for(uint64_t i = 0; max; i++, max--){
        if(!strncmp(string->data + i, substring->data, substring->length)){
            return i;
        }
    }
 
    return ~(uint64_t)0;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_RemoveAndRunCommands(), ARC_Config_RunCommand(), ARC_Config_StripComment(), and ARC_String_RemoveSubstring().

ARC_String_FindBack()

uint64_t ARC_String_FindBack	(	ARC_String *	string,
		ARC_String *	substring )

takes a given string, and assigns index and length for position of last matching substring

Parameters

string	the string that will be searched
substr	substring to find within string

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 277 of file string.c.

                                                                       {
    if(!string || !substring){
        arc_errno = ARC_ERRNO_NULL;
        ARC_DEBUG_LOG_ERROR("ARC_String_FindBack(string, substring), string or substring was null");
        return ~(uint64_t)0;
    }
 
    if(substring->length > string->length){
        return ~(uint64_t)0;
    }
 
    uint64_t max = string->length - (substring->length - 1);
    for(; max; max--){
        if(!strncmp(string->data + (max - 1), substring->data, substring->length)){
            return max;
        }
    }
 
    return ~(uint64_t)0;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String::data, and ARC_String::length.

ARC_String_FindBackCString()

uint64_t ARC_String_FindBackCString	(	ARC_String *	string,
		const char *	cstring,
		uint64_t	length )

takes a given cstring and give position of last matching

Parameters

string	the string that will be searched
cstring	the cstring to find within string
length	the length of cstring

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 298 of file string.c.

                                                                                             {
    if(!string || !cstring){
        arc_errno = ARC_ERRNO_NULL;
        ARC_DEBUG_LOG_ERROR("ARC_String_FindBack(string, substring), string or substring was null");
        return ~(uint64_t)0;
    }
 
    if(length > string->length){
        return ~(uint64_t)0;
    }
 
    uint64_t max = string->length - (length - 1);
    for(; max; max--){
        if(!strncmp(string->data + (max - 1), cstring, length)){
            return max;
        }
    }
 
    return ~(uint64_t)0;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String::data, and ARC_String::length.

Referenced by ARC_String_FindBackCStringWithStrlen().

ARC_String_FindBackCStringWithStrlen()

uint64_t ARC_String_FindBackCStringWithStrlen	(	ARC_String *	string,
		const char *	cstring )

takes a given cstring and give position of last matching

Note

will use strlen to get the length of the cstring

Parameters

string	the string that will be searched
cstring	the cstring to find within string

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 319 of file string.c.

                                                                                      {
    return ARC_String_FindBackCString(string, cstring, strlen(cstring));
}

References ARC_String_FindBackCString().

ARC_String_FindCString()

uint64_t ARC_String_FindCString	(	ARC_String *	string,
		const char *	cstring,
		uint64_t	length )

takes given cstring and gives position of first matching

Parameters

string	the string that will be searched
cstring	the cstring to find within string
length	the length of cstring

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 252 of file string.c.

                                                                                         {
    if(!string || !cstring){
        arc_errno = ARC_ERRNO_NULL;
        ARC_DEBUG_LOG_ERROR("ARC_String_FindCString(string, cstring, length), string or cstring was null");
        return ~(uint64_t)0;
    }
 
    if(string->length < length){
        return ~(uint64_t)0;
    }
 
    uint64_t max = string->length - (length - 1);
    for(uint64_t i = 0; i < max; i++){
        if(!strncmp(string->data + i, cstring, length)){
            return i + 1;
        }
    }
 
    return ~(uint64_t)0;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_Get(), ARC_Config_GetNameAndValue(), ARC_Config_Recurse(), ARC_Config_SetKeyGroup(), ARC_GraphicsConfig_GetIndexAndErrorCheck(), ARC_MathConfig_GetIndexAndErrorCheck(), and ARC_String_FindCStringWithStrlen().

ARC_String_FindCStringWithStrlen()

uint64_t ARC_String_FindCStringWithStrlen	(	ARC_String *	string,
		const char *	cstring )

takes given cstring and gives position of first matching

Note

will use strlen to get the length of the cstring

Parameters

string	the string that will be searched
cstring	the cstring to find within string

Returns

~(uint64_t)0 on error, anything else on success

Definition at line 273 of file string.c.

                                                                                  {
    return ARC_String_FindCString(string, cstring, strlen(cstring));
}

References ARC_String_FindCString().

ARC_String_IsAlpha()

ARC_Bool ARC_String_IsAlpha

(

ARC_String *

string

)

checks if string is alphabetic

Parameters

string

string to check

Returns

ARC_True if alphabetic, ARC_False if not alphabetic

Definition at line 192 of file string.c.

                                               {
    for(uint64_t length = string->length; length; length--){
        if(string->data[length - 1] >= 'a' && string->data[length - 1] <= 'z'){
            continue;
        }
 
        if(string->data[length - 1] >= 'A' && string->data[length - 1] <= 'Z'){
            continue;
        }
 
        return ARC_True;
    }
 
    return ARC_False;
}

References ARC_False, ARC_True, ARC_String::data, and ARC_String::length.

ARC_String_IsNumeric()

ARC_Bool ARC_String_IsNumeric

(

ARC_String *

string

)

checks if string is made out of only numbers

Parameters

string

string to check

Returns

ARC_True if it is numeric, ARC_False if it is not numeric

Definition at line 208 of file string.c.

                                                 {
    for(uint64_t index = 0; index < string->length; index++){
        if(string->data[index] < '0' || string->data[index] > '9'){
            return ARC_False;
        }
    }
 
    return ARC_True;
}

References ARC_False, ARC_True, and ARC_String::data.

ARC_String_Merge()

void ARC_String_Merge	(	ARC_String **	combined,
		ARC_String *	first,
		ARC_String *	second )

merges two strings together

Parameters

combined	new ARC_String of combined strings frist + second
first	first part of string to combine
second	second part of string to combine

Definition at line 485 of file string.c.

                                                                                   {
    char data[first->length + second->length];
    for(uint32_t i = 0; i < first->length; i++){
        data[i] = first->data[i];
    }
 
    for(uint32_t i = 0; i < second->length; i++){
        data[i + first->length] = second->data[i];
    }
 
    ARC_String_Create(combined, data, first->length + second->length);
}

References ARC_String_Create(), ARC_String::data, and ARC_String::length.

Referenced by ARC_ConsoleBuffer_AddChar(), and ARC_String_RemoveSection().

ARC_String_RemoveSection()

void ARC_String_RemoveSection	(	ARC_String **	newString,
		ARC_String *	original,
		uint64_t	removeIndex,
		uint64_t	removeLength )

copy a subtring from a givin ARC_String

Parameters

newString	new string without specified section, will be NULL on error
original	string to remove section from
removeIndex	starting index in relation on original of what is to be removed
removeLength	length of section that is being removed

Definition at line 499 of file string.c.

                                                                                                                        {
    if(removeIndex == 0 && removeIndex + removeLength >= original->length){
        ARC_String_Copy(newString, original);
        return;
    }
 
    if(removeIndex == 0){
        ARC_String_CopySubstring(newString, original, removeLength, original->length - removeLength);
        return;
    }
 
    if(removeIndex + removeLength >= original->length){
        ARC_String_CopySubstring(newString, original, 0, removeIndex);
        return;
    }
 
    ARC_String *first, *second;
    ARC_String_CopySubstring(&first , original, 0                         , removeIndex                                    );
    ARC_String_CopySubstring(&second, original, removeIndex + removeLength, original->length - (removeIndex + removeLength));
 
    ARC_String_Merge(newString, first, second);
 
    ARC_String_Destroy(first );
    ARC_String_Destroy(second);
}

References ARC_String_Copy(), ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_Merge(), and ARC_String::length.

Referenced by ARC_Config_StripComment(), and ARC_String_RemoveSubstring().

ARC_String_RemoveSubstring()

void ARC_String_RemoveSubstring	(	ARC_String **	newString,
		ARC_String *	original,
		ARC_String *	substring )

copy a subtring from a givin ARC_String

Parameters

newString	string that doesn't have substring in it, will be null on error
original	string to remove substring from
substring	substring to remove

Definition at line 116 of file string.c.

                                                                                                    {
    uint64_t index = ARC_String_Find(original, substring);
    if(arc_errno){
        newString = NULL;
        return;
    }
 
    ARC_String_RemoveSection(newString, original, index, original->length);
}

References arc_errno, ARC_String_Find(), ARC_String_RemoveSection(), and ARC_String::length.

Referenced by ARC_Config_RemoveAndRunCommands().

ARC_String_ReplaceMatching()

void ARC_String_ReplaceMatching	(	ARC_String **	string,
		ARC_String *	pattern,
		ARC_String *	replacement )

replaces characters in string matching the given pattern

Note

this uses ARC_String_CopyReplaceMatching, so debug logs will be thrown in that function not this one

Parameters

string	the string that will be modified, will discard changes and set arc_errno on fail
pattern	the pattern to replace in the string on match
replacement	the string that will replace the matched pattern

Definition at line 525 of file string.c.

                                                                                                  {
    ARC_String *copyReplaced;
    ARC_String_CopyReplaceMatching(&copyReplaced, *string, pattern, replacement);
 
    if(arc_errno != 0 || copyReplaced == NULL){
        return;
    }
 
    ARC_String_Destroy(*string);
    *string = copyReplaced;
}

References arc_errno, ARC_String_CopyReplaceMatching(), and ARC_String_Destroy().

ARC_String_ReplaceMatchingCString()

void ARC_String_ReplaceMatchingCString	(	ARC_String **	string,
		char *	patternCString,
		uint64_t	patternLength,
		char *	replacementCString,
		uint64_t	replacementLength )

replaces characters in string matching the given pattern

Parameters

string	the string that will be modified, will discard changes and set arc_errno on fail
patternCString	the cstring pattern to replace in the string on match
patternLength	the lenght of the cstring pattern
replacementCstring	the cstring that will replace the matched pattern
replacementLength	the length of the cstring replacement

Definition at line 580 of file string.c.

                                                                                                                                                               {
    //TODO: probs want to check if the replacement goes over a uint64_t size
    if(*string == NULL || patternCString == NULL || replacementCString == NULL){
        arc_errno = ARC_ERRNO_NULL;
        ARC_DEBUG_LOG_ERROR("ARC_String_ReplaceMatchingCString(string, patternCString, patternLength, replacementCString, replacementLength), *string, patternCString, or replacementCString was null");
        return;
    }
 
    ARC_String *original = *string;
 
    uint64_t numberOfMatches = 0;
    for(uint64_t originalIndex = 0; originalIndex < original->length; originalIndex++){
        if(ARC_String_SubstringEqualsCString(original, originalIndex, patternCString, patternLength)){
            numberOfMatches++;
            originalIndex += patternLength - 1;
        }
    }
 
    //no matches were found, but that isn't an error, so nothing to do, return
    if(numberOfMatches == 0){
        return;
    }
 
    (*string) = (ARC_String *)malloc(sizeof(ARC_String));
    (*string)->length = original->length + (replacementLength - patternLength);
    (*string)->data   = (char *)malloc(sizeof(char *) * original->length + 1);
 
    for(uint64_t originalIndex = 0, newIndex = 0; originalIndex < original->length; originalIndex++, newIndex++){
        if(ARC_String_SubstringEqualsCString(original, originalIndex, patternCString, patternLength)){
            for(uint64_t replacementIndex = 0; replacementIndex < replacementLength; replacementIndex++){
                (*string)->data[newIndex + replacementIndex] = replacementCString[replacementIndex];
            }
 
            originalIndex += patternLength - 1;
            newIndex += replacementLength - 1;
            continue;
        }
 
        (*string)->data[newIndex] = original->data[originalIndex];
    }
 
    (*string)->data[(*string)->length] = '\0';
 
    //cleanup
    ARC_String_Destroy(original);
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_NULL, ARC_String_Destroy(), ARC_String_SubstringEqualsCString(), ARC_String::data, and ARC_String::length.

Referenced by ARC_String_ReplaceMatchingCStringWithStrlen().

ARC_String_ReplaceMatchingCStringWithStrlen()

void ARC_String_ReplaceMatchingCStringWithStrlen	(	ARC_String **	string,
		char *	patternCString,
		char *	replacement )

replaces characters in string matching the given pattern

Note

this uses ARC_String_ReplaceMatchingCString, so debug logs will be thrown in that function not this one

Parameters

string	the string that will be modified, will discard changes and set arc_errno on fail
patternCString	the cstring pattern to replace in the string on match
replacementCstring	the cstring that will replace the matched pattern

Definition at line 627 of file string.c.

                                                                                                                     {
    ARC_String_ReplaceMatchingCString(string, patternCString, strlen(patternCString), replacementCString, strlen(replacementCString));
}

References ARC_String_ReplaceMatchingCString().

ARC_String_ReplaceWithSubstring()

void ARC_String_ReplaceWithSubstring	(	ARC_String **	string,
		uint64_t	start,
		uint64_t	length )

replaces a string with a section of itself

Note

this uses ARC_String_CopySubstring so errors logs will be thrown in that function not this one

Parameters

string	the string to replace, will not change on error
start	the starting index of the substring
length	the length of the substring

Definition at line 100 of file string.c.

                                                                                          {
    ARC_String *substring;
    ARC_String_CopySubstring(&substring, *string, start, length);
 
    //if error or substring is null free memory and return
    if(arc_errno || substring == NULL){
        if(substring != NULL){
            ARC_String_Destroy(substring);
        }
        return;
    }
 
    ARC_String_Destroy(*string);
    *string = substring;
}

References arc_errno, ARC_String_CopySubstring(), and ARC_String_Destroy().

Referenced by ARC_Lexer_LexString().

ARC_String_StripEnds()

void ARC_String_StripEnds	(	ARC_String **	stripped,
		ARC_String *	original,
		char	charToStrip )

strips the ends based on a given char

Parameters

stripped	where to store the string which has witespace stripped will be null if there is an error
original	the string which whill have the matching char stripped from
charToStrip	the char that will be stripped from the ends

Definition at line 323 of file string.c.

                                                                                        {
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *stripped = NULL;
        return;
    }
 
    if(!original->length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }
 
    uint64_t length = original->length - 1;
    for(; length; length--){
        if(strncmp(original->data + (length - 1), &charToStrip, 1)){
            break;
        }
    }
 
    if(!length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }
 
    uint64_t start = 0;
    for(; start <= length; start++){
        if(strncmp(original->data + start, &charToStrip, 1)){
            break;
        }
    }
 
    if(start == length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }
 
    length -= start;
    ARC_String_Create(stripped, original->data + start, length);
}

References arc_errno, ARC_ERRNO_DATA, ARC_ERRNO_NULL, ARC_String_Create(), ARC_String::data, and ARC_String::length.

ARC_String_StripEndsWhitespace()

void ARC_String_StripEndsWhitespace	(	ARC_String **	stripped,
		ARC_String *	original )

strips the whitespace from the ends of a string

Parameters

stripped	where to store the string which has witespace stripped from the ends will be null if there is an error
original	the string which whill have the whitespace stripped from its ends

Definition at line 437 of file string.c.

                                                                                {
    uint64_t index;
    for(uint64_t i = 0; i < original->length; i++){
        if(original->data[i] == ' '){
            continue;
        }
 
        if(original->data[i] == '\n'){
            continue;
        }
 
        if(original->data[i] == '\t'){
            continue;
        }
 
        if(original->data[i] == '\r'){
            continue;
        }
 
        index = i;
        break;
    }
 
    uint64_t endIndex;
    for(uint64_t i = original->length;; i--){
        if(original->data[i - 1] == ' '){
            continue;
        }
 
        if(original->data[i - 1] == '\n'){
            continue;
        }
 
        if(original->data[i - 1] == '\t'){
            continue;
        }
 
        if(original->data[i - 1] == '\r'){
            continue;
        }
 
        endIndex = i;
        break;
    }
 
    ARC_String_CopySubstring(stripped, original, index, endIndex - index);
}

References ARC_String_CopySubstring(), ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_FileIO(), ARC_Config_GetNameAndValue(), ARC_Config_Recurse(), ARC_Config_SetKeyGroup(), ARC_Rect_Read(), ARC_RectArray_Read(), ARC_RectArray_ReadRect(), ARC_SDL_Texture_Read(), ARC_Sprite_Delete(), ARC_Sprite_Read(), ARC_Spritesheet_Delete(), ARC_Spritesheet_Read(), and ARC_Spritesheet_ReadTexture().

ARC_String_StripWhitespace()

void ARC_String_StripWhitespace	(	ARC_String **	stripped,
		ARC_String *	original )

strips whitespace from a ARC_String

Parameters

stripped	where to store the string which has witespace stripped will be null if there is an error
original	the string which whill have whitespace stripped from

Definition at line 366 of file string.c.

                                                                            {
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *stripped = NULL;
        return;
    }
 
    if(!original->length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }
 
    uint64_t length = 0;
    for(uint64_t i = 0; i < original->length; i++){
        if(original->data[i] == ' '){
            continue;
        }
 
        if(original->data[i] == '\n'){
            continue;
        }
 
        if(original->data[i] == '\t'){
            continue;
        }
 
        if(original->data[i] == '\r'){
            continue;
        }
 
        length++;
    }
 
    if(!length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }
 
    length++;
    char data[length];
    for(uint32_t i = 0; i < length; i++){
        data[i] = 0;
    }
 
    uint64_t start = 0;
    for(uint64_t i = 0; i < length; i++){
        if(original->data[i] == ' '){
            continue;
        }
 
        if(original->data[i] == '\n'){
            continue;
        }
 
        if(original->data[i] == '\t'){
            continue;
        }
 
        if(original->data[i] == '\r'){
            continue;
        }
 
        data[start] = original->data[i];
        start++;
    }
 
    ARC_String_Create(stripped, data, length);
}

References arc_errno, ARC_ERRNO_DATA, ARC_ERRNO_NULL, ARC_String_Create(), ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_RunCommand().

ARC_String_SubstringEquals()

ARC_Bool ARC_String_SubstringEquals	(	ARC_String *	first,
		uint64_t	offset,
		ARC_String *	second )

check if substring of first equals second string

Parameters

first	string to check against second
offset	postion based on first to start comparing against second
second	string to check against first

Returns

ARC_True if match, ARC_False if they don't match

Definition at line 175 of file string.c.

                                                                                           {
    return ARC_String_SubstringEqualsCString(first, offset, second->data, second->length);
}

References ARC_String_SubstringEqualsCString(), ARC_String::data, and ARC_String::length.

Referenced by ARC_Lexer_AutomataMatchStringFn(), and ARC_String_CopyReplaceMatching().

ARC_String_SubstringEqualsCString()

ARC_Bool ARC_String_SubstringEqualsCString	(	ARC_String *	string,
		uint64_t	offset,
		const char *	cstring,
		uint64_t	length )

check if ARC_String and cstring match

Parameters

string	ARC_string to check
offset	postion based on string to start comparing against cstring
cstring	cstring to check
length	length of cstring

Returns

ARC_True if match, ARC_False if they don't match

Definition at line 179 of file string.c.

                                                                                                                     {
    if(string->length - offset < length){
        return ARC_False;
    }
 
    if(strncmp(string->data + offset, cstring, length)){
        return ARC_False;
    }
 
    return ARC_True;
}

References ARC_False, ARC_True, ARC_String::data, and ARC_String::length.

Referenced by ARC_String_ReplaceMatchingCString(), and ARC_String_SubstringEquals().

ARC_String_ToDouble()

double ARC_String_ToDouble

(

ARC_String *

string

)

converst substring from string to double

Parameters

string

string to convert to double

Returns

double converted number

Definition at line 226 of file string.c.

                                              {
    return strtod(string->data, NULL);
}

References ARC_String::data.

ARC_String_ToInt64_t()

int64_t ARC_String_ToInt64_t

(

ARC_String *

string

)

converst substring from string to int64_t

Parameters

string

string to convert to int64_t

Returns

int64_t converted number

Definition at line 222 of file string.c.

                                                {
    return (int64_t) strtol(string->data, NULL, 10);
}

References ARC_String::data.

Referenced by ARC_Point_Read(), ARC_Rect_Read(), and TEST_ParserCSV_CastTypeFn().

ARC_String_ToUint64_t()

uint64_t ARC_String_ToUint64_t

(

ARC_String *

string

)

converst substring from string to uint64_t

Parameters

string

string to convert to uint64_t

Returns

uint64_t converted number

Definition at line 218 of file string.c.

                                                  {
    return (uint64_t) strtoul(string->data, NULL, 10);
}

References ARC_String::data.