You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
374 lines
11 KiB
374 lines
11 KiB
#include "types.h"
|
|
#include "configfile.h"
|
|
#include "configmodel.h"
|
|
#include "sectionstore.h"
|
|
|
|
#include "containers/stringarray.h"
|
|
#include "containers/sectionarray.h"
|
|
#include "containers/linearray.h"
|
|
#include <proto/exec.h>
|
|
#include <proto/dos.h>
|
|
#include <string.h>
|
|
// #include <stdio.h>
|
|
// #include <stdlib.h>
|
|
// #include <ctype.h>
|
|
|
|
#define ZERO ((BPTR)0)
|
|
|
|
STATIC LINEPTR configFileReadLine(BPTR file);
|
|
|
|
|
|
// - STRUCTS -----------------------------------------------------------------------------
|
|
struct ConfigFile
|
|
{
|
|
STRPTR filename;
|
|
SECTIONSTOREPTR sectionStore;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------
|
|
// - CONFIG FILE -------------------------------------------------------------------------
|
|
// ---------------------------------------------------------------------------------------
|
|
|
|
VOID ConfigFileFree(CONFIGFILEPTR abstractConfigFile)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
if( configFile->sectionStore != NULL )
|
|
{
|
|
SectionStoreFree(configFile->sectionStore);
|
|
}
|
|
if( configFile->filename != NULL )
|
|
{
|
|
FreeVec(configFile->filename);
|
|
}
|
|
FreeVec(configFile);
|
|
}
|
|
}
|
|
|
|
CONFIGFILEPTR ConfigFileRead(CONST_STRPTR filename)
|
|
{
|
|
struct ConfigFile* result = NULL;
|
|
BPTR configFile = Open(filename, MODE_OLDFILE);
|
|
if( configFile != ZERO )
|
|
{
|
|
|
|
LINEPTR line = NULL;
|
|
result = AllocVec(sizeof(struct ConfigFile), MEMF_CLEAR);
|
|
result->sectionStore = SectionStoreNew();
|
|
result->filename = AllocVec(strlen(filename)+1, MEMF_CLEAR);
|
|
CopyMem(filename, result->filename, strlen(filename));
|
|
while( (line = configFileReadLine(configFile)) != NULL )
|
|
{
|
|
SectionStoreAddLineToCurrentSection(result->sectionStore, line);
|
|
//LineDump(line);
|
|
}
|
|
Close(configFile);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
VOID ConfigFileSave(CONFIGFILEPTR abstractConfigFile)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
BPTR file = Open(configFile->filename, MODE_NEWFILE);
|
|
if( file != 0 )
|
|
{
|
|
ConfigFileWrite(abstractConfigFile, file);
|
|
Close(file);
|
|
}
|
|
}
|
|
|
|
VOID ConfigFileWrite(CONFIGFILEPTR abstractConfigFile, BPTR file)
|
|
{
|
|
ULONG index = 0;
|
|
ULONG count = 0;
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
count = SectionStoreSectionCount(configFile->sectionStore);
|
|
for( index = 0; index < count; index++ )
|
|
{
|
|
SECTIONPTR section = SectionStoreSectionAt(configFile->sectionStore, index);
|
|
SectionWrite(section, file);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
StringArray ConfigFileSubsectionsForSection(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR primarySection)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
return SectionStoreSubsectionsForSection(configFile->sectionStore, primarySection);
|
|
}
|
|
|
|
|
|
// a key is "foo.bar.baz.blah" where "foo" is the primary section name
|
|
// "bar.baz" is the secondary section name and "blah" is the variable name.
|
|
// this splits foo.bar.baz.blah into foo, bar.baz amd blah.
|
|
// section, subsection and variable.
|
|
// we'll get empty strings for the parts that arent present
|
|
StringArray ConfigFileSplitKeyCompletely(CONST_STRPTR key)
|
|
{
|
|
StringArray result = StringArrayNew();
|
|
StringArray parts = StringArrayNew();
|
|
ULONG numberOfParts = 0;
|
|
|
|
STRPTR token = NULL;
|
|
// we need to make a copy of the key because strtok modifies it.
|
|
STRPTR keyCopy = AllocVec(strlen(key)+1, MEMF_CLEAR);
|
|
CopyMem(key, keyCopy, strlen(key));
|
|
|
|
token = strtok(keyCopy, ".");
|
|
while (token != NULL)
|
|
{
|
|
StringArrayAppendAndRetain(parts, token);
|
|
token = strtok(NULL, ".");
|
|
}
|
|
FreeVec(keyCopy);
|
|
|
|
// now we join all but the first and last part
|
|
numberOfParts = SizeOfArray(parts);
|
|
if( numberOfParts == 1 ) //just a variable ["","","var"]
|
|
{
|
|
StringArrayAppendAndRetain(result, "");
|
|
StringArrayAppendAndRetain(result, "");
|
|
StringArrayAppendAndRetain(result, (STRPTR)ArrayBackValue(STRPTR, parts));
|
|
}
|
|
else if( numberOfParts == 2 ) // section and variable ["section","","var"]
|
|
{
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[0]);
|
|
StringArrayAppendAndRetain(result, "");
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[1]);
|
|
}
|
|
else if( numberOfParts == 3 ) // section and subsection and variable ["section","subsec","var"]
|
|
{
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[0]);
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[1]);
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[2]);
|
|
}
|
|
else if( numberOfParts > 3 ) // subsections needs dotted ["section", "subsec1.subsec2", "var""]
|
|
{
|
|
StringArrayAppendAndRetain(result, StringArrayValues(parts)[0]); //section
|
|
|
|
// start at index 1, and add (size -2 (start+end)) parts
|
|
StringArrayAppend(result, StringArrayJoinedParts(parts, '.', 1, SizeOfArray(parts)-2));
|
|
|
|
StringArrayAppendAndRetain(result, (STRPTR)ArrayBackValue(STRPTR, parts)); // variable
|
|
}
|
|
StringArrayFree(parts, TRUE);
|
|
return result;
|
|
}
|
|
|
|
StringArray ConfigFileSplitKeyForVar(CONST_STRPTR key)
|
|
{
|
|
// a key is "foo.bar.baz.blah" where "foo" is the primary section name
|
|
// "bar.baz" is the secondary section name and "blah" is the variable name.
|
|
// In this case we'll just break it down into the canonical section name,
|
|
// foo.bar.baz and the variable name blah.
|
|
|
|
StringArray result = StringArrayNew();
|
|
StringArray parts = StringArrayNew();
|
|
STRPTR sectionPart = NULL;
|
|
STRPTR varPart = NULL;
|
|
|
|
STRPTR token = NULL;
|
|
// we need to make a copy of the key because strtok modifies it.
|
|
STRPTR keyCopy = AllocVec(strlen(key)+1, MEMF_CLEAR);
|
|
CopyMem(key, keyCopy, strlen(key));
|
|
|
|
token = strtok(keyCopy, ".");
|
|
while (token != NULL)
|
|
{
|
|
StringArrayAppendAndRetain(parts, token);
|
|
token = strtok(NULL, ".");
|
|
}
|
|
FreeVec(keyCopy);
|
|
|
|
// now we join all but the last part
|
|
sectionPart = StringArrayJoinedParts(parts, '.', 0, SizeOfArray(parts)-1);
|
|
StringArrayAppend(result, sectionPart); // its been alloced so dont copy
|
|
varPart = (STRPTR)ArrayBackValue(STRPTR, parts);
|
|
StringArrayAppendAndRetain(result, varPart); // its a reference so copy
|
|
StringArrayFree(parts, TRUE);
|
|
return result;
|
|
}
|
|
|
|
STRPTR ConfigFileGet(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey)
|
|
{
|
|
STRPTR result = NULL;
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray split = ConfigFileSplitKeyForVar(compoundKey);
|
|
VARIABLEPTR var = SectionStoreGet(configFile->sectionStore, StringArrayValues(split)[0], StringArrayValues(split)[1]);
|
|
if( var != NULL )
|
|
{
|
|
CONST_STRPTR value = VariableGetRawValue(var);
|
|
result = AllocVec(strlen(value)+1, MEMF_CLEAR);
|
|
CopyMem(value, result, strlen(value));
|
|
}
|
|
StringArrayFree(split, TRUE);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
StringArray ConfigFileGetAll(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey)
|
|
{
|
|
StringArray result = StringArrayNew();
|
|
ULONG index = 0;
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray split = ConfigFileSplitKeyForVar(compoundKey);
|
|
VariableArray vars = SectionStoreGetAll(configFile->sectionStore, StringArrayValues(split)[0], StringArrayValues(split)[1]);
|
|
for( index = 0; index < SizeOfArray(vars); index++ )
|
|
{
|
|
StringArrayAppendAndRetain(result, VariableGetRawValue(VariableArrayValues(vars)[index]));
|
|
}
|
|
VariableArrayFree(vars, FALSE);
|
|
StringArrayFree(split, TRUE);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
VOID ConfigFileAddVariable(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey, CONST_STRPTR stringValue)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
SECTIONPTR section = NULL;
|
|
VARIABLEPTR var = NULL;
|
|
CONST_STRPTR varLine = NULL;
|
|
LINEPTR line = NULL;
|
|
|
|
StringArray canonicalParts = ConfigFileSplitKeyForVar(compoundKey);
|
|
var = VariableCreate(StringArrayValues(canonicalParts)[1], stringValue);
|
|
varLine = VariableSerialize(var);
|
|
line = LineNew(varLine);
|
|
LineSetInitialVariable(line, var);
|
|
FreeVec((STRPTR)varLine);
|
|
StringArrayFree(canonicalParts, TRUE);
|
|
|
|
// now get the section
|
|
section = SectionStoreFindOrCreateSection(configFile->sectionStore, compoundKey);
|
|
// add the line to the section
|
|
SectionAddLine(section, line, TRUE);
|
|
}
|
|
}
|
|
|
|
BOOL ConfigFileSet(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey, CONST_STRPTR stringValue)
|
|
{
|
|
BOOL result = FALSE;
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray parts = ConfigFileSplitKeyForVar(compoundKey);
|
|
LineArray lines = SectionStoreFindLines(configFile->sectionStore, StringArrayValues(parts)[0], StringArrayValues(parts)[1]);
|
|
if( SizeOfArray(lines) == 0 )
|
|
{
|
|
ConfigFileAddVariable(abstractConfigFile, compoundKey, stringValue);
|
|
result = TRUE;
|
|
}
|
|
else if( SizeOfArray(lines) == 1 )
|
|
{
|
|
LINEPTR line = (LINEPTR)ArrayBackValue(LINEPTR, lines);
|
|
if( line )
|
|
{
|
|
VARIABLEPTR var = VariableCreate(StringArrayValues(parts)[1], stringValue);
|
|
if( var )
|
|
{
|
|
LineSetVariable(line, var);
|
|
result = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else // more than one line, we error.
|
|
{
|
|
result = FALSE;
|
|
}
|
|
StringArrayFree(parts, TRUE);
|
|
LineArrayFree(lines, FALSE);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
VOID ConfigFileReplaceAll(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey, CONST_STRPTR stringValue)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray parts = ConfigFileSplitKeyForVar(compoundKey);
|
|
SectionStoreRemoveLines(configFile->sectionStore, StringArrayValues(parts)[0], StringArrayValues(parts)[1]);
|
|
ConfigFileAddVariable( abstractConfigFile, compoundKey, stringValue);
|
|
StringArrayFree(parts, TRUE);
|
|
}
|
|
}
|
|
|
|
VOID ConfigFileUnset(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey, CONST_STRPTR stringValue)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray parts = ConfigFileSplitKeyCompletely(compoundKey);
|
|
|
|
|
|
StringArrayFree(parts, TRUE);
|
|
}
|
|
}
|
|
|
|
VOID ConfigFileUnsetAll(CONFIGFILEPTR abstractConfigFile, CONST_STRPTR compoundKey, CONST_STRPTR stringValue)
|
|
{
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
StringArray parts = ConfigFileSplitKeyCompletely(compoundKey);
|
|
|
|
StringArrayFree(parts, TRUE);
|
|
}
|
|
}
|
|
|
|
VOID ConfigFileDump(CONFIGFILEPTR abstractConfigFile)
|
|
{
|
|
ULONG index = 0;
|
|
ULONG count = 0;
|
|
struct ConfigFile* configFile = (struct ConfigFile*)abstractConfigFile;
|
|
if( configFile != NULL )
|
|
{
|
|
count = SectionStoreSectionCount(configFile->sectionStore);
|
|
for( index = 0; index < count; index++ )
|
|
{
|
|
SECTIONPTR section = SectionStoreSectionAt(configFile->sectionStore, index);
|
|
SectionDump(section);
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC LINEPTR configFileReadLine(BPTR file)
|
|
{
|
|
UBYTE* buffer = AllocVec(512, MEMF_CLEAR);
|
|
ULONG bufLength = 512;
|
|
ULONG bytesReadTotal = 0;
|
|
UBYTE* read = NULL;
|
|
struct Line* result = NULL;
|
|
|
|
// read the whole line including continuation
|
|
do
|
|
{
|
|
read = FGets(file, &(buffer[bytesReadTotal]), bufLength-bytesReadTotal);
|
|
bytesReadTotal = strlen(buffer);
|
|
}
|
|
while( read != NULL && bytesReadTotal >= 2 && bytesReadTotal < bufLength && buffer[bytesReadTotal-1] == '\n' && buffer[bytesReadTotal-2] == '\\' );
|
|
|
|
|
|
// make a line
|
|
if( bytesReadTotal > 0 )
|
|
{
|
|
buffer[bytesReadTotal] = '\0';
|
|
result = LineNew(buffer);
|
|
}
|
|
|
|
FreeVec(buffer);
|
|
return result;
|
|
}
|
|
|