what are approaches to work with settings - c

Question

What are some approaches to work with custom setting files in C.
For example, I plan to do it like this.
Say I have file settings.ext and I want to store 3 string parameters
inside. What I will do is: assuming my string parameters are at most
32 bytes length, I will assume that my parameters inside file are stored
like this (in binary mode):
32 byte 32 byte 32 byte
---------------------------------------------
| 1 param || 2 param || 3 param |
Then if I want second string parameter, I will read 32 bytes starting from index: 32,
again in binary mode.
I think I will have separate file for string parameters and separate
file for int parameters (I will work with int parameters in similar manner).
Does this sound reasonable?
ps. I am programming on some embedded device

Answer 1

I wouldn't use a binary file for saving settings, of the top of my head there are the following reasons not to:
It's not very portable because of endianness etc.
It's not not very easy to extend, you might not need any extra config parameters right now, but you might do later.
It's hard to edit and read from other programs, it's nice to be able to install and configure your software with scripts.
Instead I'd use a plain text config file, and something like libconfig, there is no reason to reinvent the wheel, especially if make it worse ;-)

Answer 2

There are a couple of standard library functions which make parsing simple tag/value configuration files easy. Read about strtok and atoi/atof, and you might find that a simple configuration file like this easy to parse. You can comingle string and numeric values in your configuration, and support longer strings.
name1=value1
name2=value2
name3=value3
...
This offers the benefits that it is both easily read/edited by humans, and parsed by a fairly simple configuration parser. And passing a filename to read makes this fairly self-contained.
int
cfgparse(char *cfgname)
{
FILE* cfgfh;
if(!cfgname) return -1;
if( !(cfgfh=fopen(cfgname,"r")) ) {
printf("error: cannot open %s\n",cfgname);
return -2;
}
char buffer[256]; //pick an acceptable max size
while( fgets(buffer,sizeof(buffer),cfgfh) )
{
//check for comments, empty lines
char* tag = strtok(buffer,"=");
char* val = strtok(NULL,";\n");
//strip leading/trailing whitespace, handle empty lines,
//do something with tag, value here
Cfgadd(tag,value);
}
}
You can implement a simple configuration store in an array. A list would be dynamic, and a tree or hash would improve performance.
#define MaxKeyLen (200)
#define MaxValLen (200)
typedef struct
{
char* key; //a array would work here
char* value; //a union would allow string, int, and float
} ConfigObj;
#define CONFIGMAX (200)
const int ConfigMax=CONFIGMAX;
typedef struct
{
ConfigObj tab[CONFIGMAX]; //or make this a pointer or a list
int NextAvail;
} ConfigStoreObj;
ConfigStoreObj cfg; //or make this a pointer or a list
static int ConfigFind(ConfigStoreObj* cfg, char* key)
{
int n;
for( n=0; (n<cfg->NextAvail) && (cfg->tab[n].key); n++ )
{
if( strcmp(cfg->tab[n].key,key)==0 ) //found it
{
return n;
}
}
return -1;
}
const char* ConfigGet(ConfigStoreObj* cfg, char* key)
{
int n = ConfigFind(cfg,key);
if( n<0 ) return NULL; //or ""?
return cfg->tab[n].value;
}
int ConfigSet(ConfigStoreObj* cfg, char* key, char* value)
{
char* newvalue;
int n=ConfigFind(cfg,key);
if( n<0 ) return -1; //error
printf("dup(%s)\n",value); fflush(stdout);
if( !(newvalue = strndup(value,MaxValLen)) ) {
printf("error, cannot store %s:%s\n",key,value);
return -3;
}
{
if(cfg->tab[n].value) free(cfg->tab[n].value);
cfg->tab[n].value = newvalue;
}
//return cfg->tab[n].value;
return n;
}
int ConfigAdd(ConfigStoreObj* cfg, char*key, char*value)
{
char *newkey=NULL, *newvalue=NULL;
int n = ConfigFind(cfg,key);
if( n<0 )
{
if( n<ConfigMax )
{
n = cfg->NextAvail++;
printf("dup(%s)\n",key); fflush(stdout);
if( !(newkey = strndup(key,MaxKeyLen)) ) {
printf("error, cannot store %s:%s\n",key,value);
return -3;
}
}
else return -1;
}
printf("dup(%s)\n",value); fflush(stdout);
if( !(newvalue = strndup(value,MaxValLen)) ) {
printf("error, cannot store %s:%s\n",key,value);
if(newkey) free(newkey);
return -3;
}
{
if(cfg->tab[n].value) free(cfg->tab[n].value);
cfg->tab[n].value = newvalue;
}
//return cfg->tab[n].value;
return n;
}
You may also want,
ConfigStoreObj* ConfigStoreNew(int size);
char* ConfigDel(ConfigStoreObj* cfg, char*key);
int ConfigPrint(ConfigStoreObj* cfg);
Opening a config file for reading is fairly easy, as shown above. And here is a
main(int argc, char* argv[])
{
//...
char configname[200];
strcpy(configname,"yourconfigfilename.cfg");
cfgparse(configname); //of course, you need a ConfigStoreObj ...
//...
}
And there are libraries that make even complex configuration easy.