config.c File Reference

#include "arc/std/config.h"
#include "arc/std/errno.h"
#include "arc/std/hashtable.h"
#include "arc/std/io.h"
#include "arc/std/string.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>

Go to the source code of this file.

Data Structures
struct	ARC_Config
struct	ARC_ConfigKey
struct	ARC_ConfigTypeTemplate
struct	ARC_ConfigDeleteKeyArgs

Typedefs
typedef struct ARC_ConfigKey	ARC_ConfigKey
typedef struct ARC_ConfigTypeTemplate	ARC_ConfigTypeTemplate
typedef struct ARC_ConfigDeleteKeyArgs	ARC_ConfigDeleteKeyArgs

Functions
int8_t	ARC_Config_KeyComp (void *key1, size_t *key1size, void *key2, size_t *key2size)
void	ARC_Config_CreateGroup (ARC_Config *config, ARC_String *name)
void	ARC_Config_DestroyGroup (ARC_HashtableNode *group, void *userdata)
void	ARC_Config_DestroyGroupNode (ARC_HashtableNode *node, void *userdata)
void	ARC_Config_RemoveKey (ARC_HashtableNode *node, void *userdata)
void	ARC_Config_AddKey (ARC_Config *config, ARC_String *type, ARC_ConfigKeyRead keyRead, ARC_ConfigKeyDelete keyDelete)
	adds a usable key to ARC_Config
void	ARC_Config_AddKeyCString (ARC_Config *config, const char *type, uint64_t length, ARC_ConfigKeyRead keyRead, ARC_ConfigKeyDelete keyDelete)
	adds a key from a cstring
void	ARC_Config_Create (ARC_Config **config)
	creates ARC_Config type
void	ARC_Config_Destroy (ARC_Config *config)
	destroys ARC_Config type
void	ARC_Config_SetGroup (ARC_Config *config, ARC_String *groupname)
	sets current group in config
void	ARC_Config_Get (ARC_Config *config, ARC_String *keyname, void **value)
	get a value from a given keyname
void	ARC_Config_Recurse (ARC_Config *config, ARC_String **data, ARC_String *groupstr, uint8_t *command)
void	ARC_Config_SetKeyGroup (ARC_Config *config, ARC_String **data, uint8_t *command)
void	ARC_Config_LoadFromKey (ARC_Config *config, ARC_String *keyType, ARC_String *name, ARC_String *value)
void	ARC_Config_UnloadFromKey (ARC_Config *config, ARC_String *keyType, ARC_String *name, ARC_String *value)
void	ARC_Config_GetNameAndValue (ARC_String *data, ARC_String **name, ARC_String **value)
void	ARC_Config_StripComment (ARC_String *original, ARC_String **stripped, ARC_String *lineStart, ARC_String *lineEnd)
void	ARC_Config_RemoveComments (ARC_String *original, ARC_String **commentRemoved)
void	ARC_Config_RunCommand (ARC_Config *config, ARC_String *command)
void	ARC_Config_RemoveAndRunCommands (ARC_Config *config, ARC_String *original, ARC_String **commandRemoved)
void	ARC_Config_FileIO (ARC_Config *config, ARC_String *path, uint8_t command)
	handles file io for ARC_Config Type

Typedef Documentation

ARC_ConfigDeleteKeyArgs

typedef struct ARC_ConfigDeleteKeyArgs ARC_ConfigDeleteKeyArgs

ARC_ConfigKey

typedef struct ARC_ConfigKey ARC_ConfigKey

ARC_ConfigTypeTemplate

typedef struct ARC_ConfigTypeTemplate ARC_ConfigTypeTemplate

Function Documentation

ARC_Config_AddKey()

void ARC_Config_AddKey	(	ARC_Config *	config,
		ARC_String *	type,
		ARC_ConfigKeyRead	keyRead,
		ARC_ConfigKeyDelete	keyDelete )

adds a usable key to ARC_Config

Parameters

config	ARC_Config to add keys to
type	string of key type
keyRead	function for reading/creating key from string
keyDelete	function for deleting stored key

Definition at line 45 of file config.c.

                                                                                                                      {
    ARC_ConfigKey *newKey = (ARC_ConfigKey *)malloc(sizeof(ARC_ConfigKey));
    newKey->Read   = keyRead;
    newKey->Delete = keyDelete;
 
    char *typeval = (char *)malloc(sizeof(char) * type->length);
    strncpy(typeval, type->data, type->length);
    ARC_Hashtable_Add(config->keys, (void *)typeval, type->length, newKey);
}

References ARC_Hashtable_Add(), ARC_String::data, ARC_ConfigKey::Delete, ARC_Config::keys, ARC_String::length, and ARC_ConfigKey::Read.

ARC_Config_AddKeyCString()

void ARC_Config_AddKeyCString	(	ARC_Config *	config,
		const char *	type,
		uint64_t	length,
		ARC_ConfigKeyRead	keyRead,
		ARC_ConfigKeyDelete	keyDelete )

adds a key from a cstring

Parameters

config	ARC_Config to add keys to
type	cstring of key type
length	length of cstring
keyRead	function for reading/creating key from string
keyDelete	function for deleting stored key

Definition at line 55 of file config.c.

                                                                                                                                              {
    ARC_ConfigKey *newKey = (ARC_ConfigKey *)malloc(sizeof(ARC_ConfigKey));
    newKey->Read   = keyRead;
    newKey->Delete = keyDelete;
 
    char *typeval = (char *)malloc(sizeof(char) * length);
    strncpy(typeval, type, length);
    ARC_Hashtable_Add(config->keys, (void *)typeval, length, newKey);
}

References ARC_Hashtable_Add(), ARC_ConfigKey::Delete, ARC_Config::keys, and ARC_ConfigKey::Read.

Referenced by ARC_AudioConfig_Init(), ARC_GraphicsConfig_Init(), and ARC_MathConfig_Init().

ARC_Config_Create()

void ARC_Config_Create

(

ARC_Config **

config

)

creates ARC_Config type

Parameters

config

ARC_Config to initialize

Definition at line 65 of file config.c.

                                           {
    *config = (ARC_Config *)malloc(sizeof(ARC_Config));
    (*config)->currgroup = NULL;
 
    ARC_Hashtable *groups;
    ARC_Hashtable_Create(&groups, ARC_GROUP_BUCKET_SIZE, NULL, ARC_Config_KeyComp);
    (*config)->groups = groups;
    ARC_Config_CreateGroup(*config, NULL); 
 
    ARC_Hashtable *keys;
    ARC_Hashtable_Create(&keys, ARC_KEY_BUCKET_SIZE, NULL, ARC_Config_KeyComp);
    (*config)->keys = keys;
 
#ifdef ARC_DEFAULT_CONFIG
    ARC_Defaults_ConfigKey_Create(*config);
#endif
}

References ARC_Config_CreateGroup(), ARC_Config_KeyComp(), ARC_Defaults_ConfigKey_Create(), ARC_GROUP_BUCKET_SIZE, ARC_Hashtable_Create(), ARC_KEY_BUCKET_SIZE, and ARC_Config::currgroup.

ARC_Config_CreateGroup()

void ARC_Config_CreateGroup	(	ARC_Config *	config,
		ARC_String *	name )

Definition at line 565 of file config.c.

                                                                 {
    ARC_Hashtable *data;
    ARC_Hashtable_Create(&data, ARC_GROUP_DATA_BUCKET_SIZE, NULL, ARC_Config_KeyComp);
 
    if(name){
        char *nameval = (char *)malloc(sizeof(char) * name->length);
        strncpy(nameval, name->data, name->length);
        ARC_Hashtable_Add(config->groups, nameval, name->length, (void *)data);
        return;
    }
 
    char *emptyGroup = (char *)malloc(sizeof(char));
    emptyGroup[0] = ' ';
    ARC_Hashtable_Add(config->groups, emptyGroup, 1, (void *)data);
}

References ARC_Config_KeyComp(), ARC_GROUP_DATA_BUCKET_SIZE, ARC_Hashtable_Add(), ARC_Hashtable_Create(), ARC_String::data, ARC_Config::groups, and ARC_String::length.

Referenced by ARC_Config_Create(), and ARC_Config_SetGroup().

ARC_Config_Destroy()

void ARC_Config_Destroy

(

ARC_Config *

config

)

destroys ARC_Config type

Definition at line 83 of file config.c.

                                           {
    ARC_ConfigDeleteKeyArgs keyArgs = {
        .config = config,
        .string = NULL,
    };
 
    ARC_Hashtable_Destroy(config->groups, ARC_Config_DestroyGroup, (void *)&keyArgs);
    ARC_Hashtable_Destroy(config->keys  , ARC_Config_RemoveKey   , NULL            );
    free(config);
}

References ARC_Config_DestroyGroup(), ARC_Config_RemoveKey(), ARC_Hashtable_Destroy(), ARC_Config::groups, and ARC_Config::keys.

ARC_Config_DestroyGroup()

void ARC_Config_DestroyGroup	(	ARC_HashtableNode *	group,
		void *	userdata )

Definition at line 581 of file config.c.

                                                                      {
    free((char *)group->key);
    ARC_Hashtable_Destroy((ARC_Hashtable *)group->data, ARC_Config_DestroyGroupNode, userdata);
}

References ARC_Config_DestroyGroupNode(), ARC_Hashtable_Destroy(), ARC_HashtableNode::data, and ARC_HashtableNode::key.

Referenced by ARC_Config_Destroy().

ARC_Config_DestroyGroupNode()

void ARC_Config_DestroyGroupNode	(	ARC_HashtableNode *	node,
		void *	userdata )

Definition at line 586 of file config.c.

                                                                         {
    free((char *)node->key);
 
    ARC_ConfigTypeTemplate *temp = (ARC_ConfigTypeTemplate *)node->data;
    if(temp->Delete && temp->data && userdata){
        ARC_ConfigDeleteKeyArgs *args = (ARC_ConfigDeleteKeyArgs *)userdata;
 
        temp->Delete(args->config, args->string, temp->data);
    }
 
    free(temp);
    node->data = NULL;
}

References ARC_ConfigDeleteKeyArgs::config, ARC_ConfigTypeTemplate::data, ARC_HashtableNode::data, ARC_ConfigTypeTemplate::Delete, ARC_HashtableNode::key, and ARC_ConfigDeleteKeyArgs::string.

Referenced by ARC_Config_DestroyGroup(), and ARC_Config_UnloadFromKey().

ARC_Config_FileIO()

void ARC_Config_FileIO	(	ARC_Config *	config,
		ARC_String *	path,
		uint8_t	command )

handles file io for ARC_Config Type

Parameters

config	ARC_Config where io operations will take place
path	file path for io

Definition at line 528 of file config.c.

                                                                             {
    arc_errno = 0; //TODO: Remove this, just testing
    ARC_String *data;
    ARC_IO_FileToStr(path, &data);
    if(arc_errno){
        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("ARC_IO_FileToStr(%s, &data, &size);\n", path->data);
        return;
    }
 
    ARC_String_AppendCStringWithStrlen(&data, "\n");
 
    ARC_String *temp = data;
    ARC_Config_RemoveComments(temp, &data);
    ARC_String_Destroy(temp);
 
    temp = data;
    ARC_Config_RemoveAndRunCommands(config, temp, &data);
    ARC_String_Destroy(temp);
 
    temp = data;
    ARC_String_StripEndsWhitespace(&data, temp);
    ARC_String_Destroy(temp);
 
    ARC_Config_Recurse(config, &data, NULL, &command);
    if(data){
        ARC_String_Destroy(data);
    }
}

References ARC_Config_Recurse(), ARC_Config_RemoveAndRunCommands(), ARC_Config_RemoveComments(), ARC_DEBUG_LOG_ERROR_WITH_VARIABLES, arc_errno, ARC_IO_FileToStr(), ARC_String_AppendCStringWithStrlen(), ARC_String_Destroy(), ARC_String_StripEndsWhitespace(), and ARC_String::data.

Referenced by ARC_Config_RunCommand().

ARC_Config_Get()

void ARC_Config_Get	(	ARC_Config *	config,
		ARC_String *	keyname,
		void **	value )

get a value from a given keyname

Note

name may be prefaced with <group>:: to specify group

Parameters

config	ARC_Config to get value from
keyname	name of key to get from config
value	data retrieved from config

Definition at line 124 of file config.c.

                                                                          {
    ARC_ConfigTypeTemplate *temp = NULL;
 
    uint64_t length = ARC_String_FindCString(keyname, "::", 2);
    if(arc_errno){
        //TODO: Debug info here
        ARC_DEBUG_LOG_ERROR("in ARC_Config_Get(config, keyname, value); length threw error");
        *value = NULL;
        return;
    }
 
    if(length != ~((uint64_t)0)){
        length--;
        ARC_String *group = NULL;
 
        if(length != 0){
            ARC_String_CopySubstring(&group, keyname, 0, length);
        }
 
        ARC_Hashtable *currgroup = config->currgroup;
        ARC_Config_SetGroup(config, group);
        if(arc_errno){
            ARC_DEBUG_LOG_ERROR("in ARC_Config_Get(config, keyname, value); setting group threw error");
            ARC_String_Destroy(group);
            *value = NULL;
            return;
        }
 
        ARC_String *name;
        ARC_String_CopySubstring(&name, keyname, length + 2, keyname->length - (length + 2));
        ARC_Hashtable_Get(config->currgroup, (void *)name->data, name->length, (void **)&temp);
        ARC_String_Destroy(name);
 
        config->currgroup = currgroup;
        if(group){
            ARC_String_Destroy(group);
        }
 
        if(temp == NULL){
            *value = NULL;
            return;
        }
 
        *value = temp->data;
        return;
    }
 
    if(!keyname){
        *value = NULL;
        return;
    }
 
    ARC_Hashtable_Get(config->currgroup, (void *)keyname->data, keyname->length, (void **)&temp);
    if(arc_errno || temp == NULL){
        *value = NULL;
        return;
    }
 
    *value = temp->data;
}

References ARC_Config_SetGroup(), ARC_DEBUG_LOG_ERROR, arc_errno, ARC_Hashtable_Get(), ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_FindCString(), ARC_Config::currgroup, ARC_ConfigTypeTemplate::data, ARC_String::data, and ARC_String::length.

Referenced by ARC_Audio_Read(), 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(), and ARC_Spritesheet_ReadTexture().

ARC_Config_GetNameAndValue()

void ARC_Config_GetNameAndValue	(	ARC_String *	data,
		ARC_String **	name,
		ARC_String **	value )

Definition at line 251 of file config.c.

                                                                                        {
        uint64_t index = ARC_String_FindCString(data, "=", 1);
        if(arc_errno || index == ~(uint64_t)0){
            *name  = NULL;
            *value = NULL;
            return;
        }
 
        ARC_String_CopySubstring(name, data, 0, index - 1);
        index++;
 
        ARC_String *dataTemp = *name;
        ARC_String_StripEndsWhitespace(name, dataTemp);
        ARC_String_Destroy(dataTemp);
 
        ARC_String_CopySubstring(&dataTemp, data, index, data->length - index);
        ARC_String_StripEndsWhitespace(value, dataTemp);
        ARC_String_Destroy(dataTemp);
}

References arc_errno, ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_FindCString(), ARC_String_StripEndsWhitespace(), and ARC_String::length.

Referenced by ARC_Config_Recurse().

ARC_Config_KeyComp()

int8_t ARC_Config_KeyComp	(	void *	key1,
		size_t *	key1size,
		void *	key2,
		size_t *	key2size )

Definition at line 557 of file config.c.

                                                                                     {
    if(*key1size - *key2size){
        return -1;
    }
 
    return strncmp((const char *)key1, (const char *)key2, *key1size);
}

Referenced by ARC_Config_Create(), and ARC_Config_CreateGroup().

ARC_Config_LoadFromKey()

void ARC_Config_LoadFromKey	(	ARC_Config *	config,
		ARC_String *	keyType,
		ARC_String *	name,
		ARC_String *	value )

Definition at line 211 of file config.c.

                                                                                                         {
    ARC_ConfigKey *key; 
    ARC_Hashtable_Get(config->keys, keyType->data, keyType->length, (void **)&key);
    if(key == NULL){
        arc_errno = ARC_ERRNO_DATA;
        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("in ARC_Config_LoadFromKey(config, string, value); no matching key: %s", keyType->data);
    }
 
    if(arc_errno){
        return;
    }
 
    ARC_ConfigTypeTemplate *templateVal = (ARC_ConfigTypeTemplate *) malloc(sizeof(ARC_ConfigTypeTemplate));
    templateVal->Delete = NULL;
    templateVal->data = NULL;
 
    uint8_t reference = key->Read(config, value, &(templateVal->data));
    if(!reference){
        templateVal->Delete = key->Delete;
    }
 
    if(arc_errno){
        return;
    }
 
    char *nameval = (char *)malloc(sizeof(char) * name->length + 1);
    strncpy(nameval, name->data, name->length);
    nameval[name->length] = '\0';
    ARC_Hashtable_Add(config->currgroup, nameval, name->length, (void *)templateVal);
}

References ARC_DEBUG_LOG_ERROR_WITH_VARIABLES, arc_errno, ARC_ERRNO_DATA, ARC_Hashtable_Add(), ARC_Hashtable_Get(), ARC_Config::currgroup, ARC_ConfigTypeTemplate::data, ARC_String::data, ARC_ConfigKey::Delete, ARC_ConfigTypeTemplate::Delete, ARC_Config::keys, ARC_String::length, and ARC_ConfigKey::Read.

Referenced by ARC_Config_Recurse().

ARC_Config_Recurse()

void ARC_Config_Recurse	(	ARC_Config *	config,
		ARC_String **	data,
		ARC_String *	groupstr,
		uint8_t *	command )

Definition at line 271 of file config.c.

                                                                                                      {
    ARC_Config_SetGroup(config, groupstr);
    if(arc_errno){
        return;
    }
 
    ARC_Hashtable *group = config->currgroup;
 
    while(*data && (*data)->length){
        ARC_String *dataTemp = *data;
        ARC_String_StripEndsWhitespace(data, dataTemp);
        ARC_String_Destroy(dataTemp);
 
        // break out of current group
        if((*data)->data[0] == '}'){
            config->currgroup = NULL;
 
            dataTemp = *data;
            ARC_String_CopySubstring(data, dataTemp, 1, dataTemp->length - 1);
            ARC_String_Destroy(dataTemp);
            return;
        }
 
        // set group
        if(!(config->currgroup)){
            config->currgroup = group;
        }
 
        // get keys type
        uint64_t index = ARC_String_FindCString(*data, " ", 1);
        if(arc_errno || index == ~(uint64_t)0){
            return;
        }
 
        ARC_String *keyType, *keyTypeTemp;
        ARC_String_CopySubstring(&keyTypeTemp, *data, 0, index);
        ARC_String_StripEndsWhitespace(&keyType, keyTypeTemp);
        ARC_String_Destroy(keyTypeTemp);
 
        if(ARC_String_EqualsCString(keyType, "group", 5)){
            ARC_Config_SetKeyGroup(config, data, command);
            ARC_String_Destroy(keyType);
            config->currgroup = group;
            if(arc_errno){
                return;
            }
 
            continue;
        }
 
        // get and copy up to the ;
        ARC_String *nameAndValue;
        uint64_t nextIndex = ARC_String_FindCString(*data, ";", 1);
        if(nextIndex == ~(uint64_t)0){
            arc_errno = ARC_ERRNO_DATA;
        }
 
        if(arc_errno){
            ARC_String_Destroy(keyType);
            return;
        }
 
        ARC_String_CopySubstring(&nameAndValue, *data, index, nextIndex - (index + 1));
        if(arc_errno){
            ARC_String_Destroy(keyType);
            return;
        }
 
        // remove up to the ; from data string
        dataTemp = *data;
        ARC_String_CopySubstring(data, dataTemp, nextIndex, (*data)->length - nextIndex);
        ARC_String_Destroy(dataTemp);
        if(arc_errno){
            ARC_String_Destroy(keyType);
            ARC_String_Destroy(nameAndValue);
            return;
        }
 
        // get name and value of string
        ARC_String *name, *value;
        ARC_Config_GetNameAndValue(nameAndValue, &name, &value);
        ARC_String_Destroy(nameAndValue);
        if(arc_errno){
            ARC_String_Destroy(keyType);
            return;
        }
 
        // load from key
        if(*command == ARC_CONFIG_FILE_IO_LOAD){
            ARC_Config_LoadFromKey(config, keyType, name, value);
 
            ARC_String_Destroy(keyType);
            ARC_String_Destroy(name   );
            ARC_String_Destroy(value  );
 
            if(arc_errno){
                return;
            }
 
            continue;
        }
 
        // unload from key
        if(*command == ARC_CONFIG_FILE_IO_UNLOAD){
            ARC_Config_UnloadFromKey(config, keyType, name, value);
 
            ARC_String_Destroy(keyType);
            ARC_String_Destroy(name   );
            ARC_String_Destroy(value  );
 
            if(arc_errno){
                return;
            }
 
            continue;
        }
 
        // config file wasn't loaded correctly
        ARC_String_Destroy(keyType);
        ARC_String_Destroy(name   );
        ARC_String_Destroy(value  );
        arc_errno = ARC_ERRNO_DATA;
        return;
    }
 
    config->currgroup = group;
}

References ARC_CONFIG_FILE_IO_LOAD, ARC_CONFIG_FILE_IO_UNLOAD, ARC_Config_GetNameAndValue(), ARC_Config_LoadFromKey(), ARC_Config_SetGroup(), ARC_Config_SetKeyGroup(), ARC_Config_UnloadFromKey(), arc_errno, ARC_ERRNO_DATA, ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_EqualsCString(), ARC_String_FindCString(), ARC_String_StripEndsWhitespace(), ARC_Config::currgroup, and ARC_String::length.

Referenced by ARC_Config_FileIO(), and ARC_Config_SetKeyGroup().

ARC_Config_RemoveAndRunCommands()

void ARC_Config_RemoveAndRunCommands	(	ARC_Config *	config,
		ARC_String *	original,
		ARC_String **	commandRemoved )

Definition at line 491 of file config.c.

                                                                                                           {
    ARC_String *current;
    ARC_String_Copy(&current, original);
 
    ARC_String *lineStart, *lineEnd;
    ARC_String_Create(&lineStart, "#" , 1);
    ARC_String_Create(&lineEnd  , "\n", 1);
 
    uint64_t index = ARC_String_Find(current, lineStart);
 
    while(index != ~(uint64_t)0){
        uint64_t endIndex = ARC_String_Find(current, lineEnd);
        if(endIndex == ~(uint64_t)0){
            arc_errno = ARC_ERRNO_DATA;
            ARC_String_Destroy(current  );
            ARC_String_Destroy(lineStart);
            ARC_String_Destroy(lineEnd  );
            *commandRemoved = NULL;
            return;
        }
 
        ARC_String *command;
        ARC_String_CopySubstring(&command, current, index + lineStart->length, endIndex - (index + lineStart->length));
        ARC_Config_RunCommand(config, command);
 
        ARC_String *currentTemp = current;
        ARC_String_RemoveSubstring(&current, currentTemp, command);
        ARC_String_Destroy(command);
        ARC_String_Destroy(currentTemp);
    }
 
    ARC_String_Destroy(lineStart);
    ARC_String_Destroy(lineEnd  );
 
    *commandRemoved = current;
}

References ARC_Config_RunCommand(), arc_errno, ARC_ERRNO_DATA, ARC_String_Copy(), ARC_String_CopySubstring(), ARC_String_Create(), ARC_String_Destroy(), ARC_String_Find(), ARC_String_RemoveSubstring(), and ARC_String::length.

Referenced by ARC_Config_FileIO().

ARC_Config_RemoveComments()

void ARC_Config_RemoveComments	(	ARC_String *	original,
		ARC_String **	commentRemoved )

Definition at line 428 of file config.c.

                                                                                 {
    ARC_String *lineStart, *lineEnd;
 
    //Single Line Comment
    ARC_String_Create(&lineStart, "//", 2);
    ARC_String_Create(&lineEnd  , "\n", 1);
 
    ARC_String *singleLineStripped;
    ARC_Config_StripComment(original, &singleLineStripped, lineStart, lineEnd);
 
    ARC_String_Destroy(lineStart);
    ARC_String_Destroy(lineEnd  );
 
    if(arc_errno){
        commentRemoved = NULL;
        return;
    }
 
    //Multi Line Comment
    ARC_String_Create(&lineStart, "/*", 2);
    ARC_String_Create(&lineEnd  , "*/", 2);
 
    ARC_Config_StripComment(singleLineStripped, commentRemoved, lineStart, lineEnd);
    ARC_String_Destroy(singleLineStripped);
 
    ARC_String_Destroy(lineStart);
    ARC_String_Destroy(lineEnd  );
}

References ARC_Config_StripComment(), arc_errno, ARC_String_Create(), and ARC_String_Destroy().

Referenced by ARC_Config_FileIO().

ARC_Config_RemoveKey()

void ARC_Config_RemoveKey	(	ARC_HashtableNode *	node,
		void *	userdata )

Definition at line 600 of file config.c.

                                                                  {
    free((char *)node->key);
 
    if(!node->data){
        arc_errno = ARC_ERRNO_NULL;
        return;
    }
 
    free((ARC_ConfigKey *)node->data);
}

References arc_errno, ARC_ERRNO_NULL, ARC_HashtableNode::data, and ARC_HashtableNode::key.

Referenced by ARC_Config_Destroy().

ARC_Config_RunCommand()

void ARC_Config_RunCommand	(	ARC_Config *	config,
		ARC_String *	command )

Definition at line 457 of file config.c.

                                                                   {
    ARC_String *space;
    ARC_String_Create(&space, " " , 1);
 
    uint64_t index = ARC_String_Find(command, space);
    if(index == ~(uint64_t)0){
        arc_errno = ARC_ERRNO_DATA;
        ARC_String_Destroy(space);
        return;
    }
 
    ARC_String *commandOpt;
    ARC_String_CopySubstring(&commandOpt, command, 0, index);
 
    ARC_String *commandArgTemp, *commandArg;
    ARC_String_CopySubstring(&commandArgTemp, command, index + space->length, command->length - (index + space->length));
    ARC_String_StripWhitespace(&commandArg, commandArgTemp);
    ARC_String_Destroy(commandArgTemp);
 
    if(ARC_String_EqualsCString(command, "load", 4)){
        ARC_Config_FileIO(config, commandArg, ARC_CONFIG_FILE_IO_LOAD);
    }
    else if(ARC_String_EqualsCString(command, "unload", 6)){
        ARC_Config_FileIO(config, commandArg, ARC_CONFIG_FILE_IO_UNLOAD);
    }
    else {
        arc_errno = ARC_ERRNO_DATA;
    }
 
    ARC_String_Destroy(commandOpt);
    ARC_String_Destroy(commandArg);
    ARC_String_Destroy(space     );
}

References ARC_CONFIG_FILE_IO_LOAD, ARC_CONFIG_FILE_IO_UNLOAD, ARC_Config_FileIO(), arc_errno, ARC_ERRNO_DATA, ARC_String_CopySubstring(), ARC_String_Create(), ARC_String_Destroy(), ARC_String_EqualsCString(), ARC_String_Find(), ARC_String_StripWhitespace(), and ARC_String::length.

Referenced by ARC_Config_RemoveAndRunCommands().

ARC_Config_SetGroup()

void ARC_Config_SetGroup	(	ARC_Config *	config,
		ARC_String *	groupname )

sets current group in config

Note

ARC_Config_Get will use this set group

Parameters

config	ARC_Config we are setting current group in
groupname	name of group that will be set

Definition at line 95 of file config.c.

                                                                   {
    if(!config){
        return;
    }
 
    if(groupname == NULL){
        ARC_Hashtable_Get(config->groups, (void *)" ", 1, (void **)&(config->currgroup));
        return;
    }
 
    ARC_Hashtable_Get(config->groups, (void *)groupname->data, groupname->length, (void **)&(config->currgroup));
    arc_errno = 0;
 
//    if(arc_errno && arc_errno != ARC_ERRNO_NULL){
//        return;
//    }
 
    if(config->currgroup){
        return;
    }
 
    ARC_Config_CreateGroup(config, groupname);
    if(arc_errno){
        return;
    }
 
    ARC_Hashtable_Get(config->groups, (void *)groupname->data, groupname->length, (void **)&(config->currgroup));
}

References ARC_Config_CreateGroup(), arc_errno, ARC_Hashtable_Get(), ARC_Config::currgroup, ARC_String::data, ARC_Config::groups, and ARC_String::length.

Referenced by ARC_Config_Get(), and ARC_Config_Recurse().

ARC_Config_SetKeyGroup()

void ARC_Config_SetKeyGroup	(	ARC_Config *	config,
		ARC_String **	data,
		uint8_t *	command )

Definition at line 187 of file config.c.

                                                                                    {
    uint64_t index     = ARC_String_FindCString(*data, " ", 1);
    uint64_t nextIndex = ARC_String_FindCString(*data, "{", 1);
    if(index == ~(uint64_t)0 || nextIndex == ~(uint64_t)0){
        arc_errno = ARC_ERRNO_DATA;
    }
 
    if(arc_errno){
        return;
    }
 
    ARC_String *name, *temp;
    ARC_String_CopySubstring(&temp, *data, index, nextIndex - index - 1);
    ARC_String_StripEndsWhitespace(&name, temp);
    ARC_String_Destroy(temp);
 
    temp = *data;
    ARC_String_CopySubstring(data, temp, nextIndex + 1, (*data)->length - (nextIndex + 1));
    ARC_String_Destroy(temp);
 
    ARC_Config_Recurse(config, data, name, command);
    ARC_String_Destroy(name);
}

References ARC_Config_Recurse(), arc_errno, ARC_ERRNO_DATA, ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_FindCString(), ARC_String_StripEndsWhitespace(), and ARC_String::length.

Referenced by ARC_Config_Recurse().

ARC_Config_StripComment()

void ARC_Config_StripComment	(	ARC_String *	original,
		ARC_String **	stripped,
		ARC_String *	lineStart,
		ARC_String *	lineEnd )

Definition at line 399 of file config.c.

                                                                                                                     {
    ARC_String *current = NULL;
    ARC_String_Copy(&current, original);
 
    uint64_t index = ARC_String_Find(original, lineStart);
    while(index != ~(uint64_t)0){
        ARC_String *commentString;
        ARC_String_CopySubstring(&commentString, current, index + lineStart->length, current->length - (index + lineStart->length));
 
        uint64_t endIndex = ARC_String_Find(commentString, lineEnd);
        ARC_String_Destroy(commentString);
        if(endIndex == ~(uint64_t)0){
            ARC_DEBUG_LOG_ERROR("ARC_Config_RemoveComments(original, commentRemoved); No newline found when stripping single line comment");
            arc_errno = ARC_ERRNO_DATA;
            ARC_String_Destroy(current);
            *stripped = NULL;
            break;
        }
 
        ARC_String *currentTemp = current;
        ARC_String_RemoveSection(&current, currentTemp, index, endIndex + lineStart->length + lineEnd->length);
        ARC_String_Destroy(currentTemp);
 
        index = ARC_String_Find(current, lineStart);
    }
 
    *stripped = current;
}

References ARC_DEBUG_LOG_ERROR, arc_errno, ARC_ERRNO_DATA, ARC_String_Copy(), ARC_String_CopySubstring(), ARC_String_Destroy(), ARC_String_Find(), ARC_String_RemoveSection(), and ARC_String::length.

Referenced by ARC_Config_RemoveComments().

ARC_Config_UnloadFromKey()

void ARC_Config_UnloadFromKey	(	ARC_Config *	config,
		ARC_String *	keyType,
		ARC_String *	name,
		ARC_String *	value )

Definition at line 242 of file config.c.

                                                                                                           {
    ARC_ConfigDeleteKeyArgs keyArgs = {
        .config = config,
        .string = value,
    };
 
    ARC_Hashtable_Remove(config->currgroup, name->data, name->length, ARC_Config_DestroyGroupNode, &keyArgs);
}

References ARC_Config_DestroyGroupNode(), ARC_Hashtable_Remove(), ARC_Config::currgroup, ARC_String::data, and ARC_String::length.

Referenced by ARC_Config_Recurse().