Loading...
Searching...
No Matches
ciniparser.c
Go to the documentation of this file.
/* Copyright (c) 2000-2007 by Nicolas Devillard.
* Copyright (x) 2009 by Tim Post <tinkertim@gmail.com>
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <ctype.h>
#include <ciniparser.h>
#define ASCIILINESZ (1024)
#define INI_INVALID_KEY ((char*)NULL)
typedef enum _line_status_ {
LINE_UNPROCESSED,
LINE_ERROR,
LINE_EMPTY,
LINE_COMMENT,
LINE_SECTION,
LINE_VALUE
} line_status;
static char* strlwc(const char* s)
{
static char l[ASCIILINESZ + 1];
int i;
if (s == NULL)
return NULL;
for (i = 0; s[i] && i < ASCIILINESZ; i++)
l[i] = tolower(s[i]);
l[i] = '\0';
return l;
}
static char* strstrip(const char* s)
{
static char l[ASCIILINESZ + 1];
unsigned int i, numspc;
if (s == NULL)
return NULL;
while (isspace(*s))
s++;
for (i = numspc = 0; s[i] && i < ASCIILINESZ; i++) {
l[i] = s[i];
if (isspace(l[i]))
numspc++;
else
numspc = 0;
}
l[i - numspc] = '\0';
return l;
}
static
line_status ciniparser_line(char* input_line, char* section,
char* key, char* value)
{
line_status sta = LINE_ERROR;
char line[ASCIILINESZ + 1];
int len;
strcpy(line, strstrip(input_line));
len = (int)strlen(line);
if (len < 1) {
/* Empty line */
sta = LINE_EMPTY;
} else if (line[0] == '#') {
/* Comment line */
sta = LINE_COMMENT;
} else if (line[0] == '[' && line[len - 1] == ']') {
/* Section name */
if (sscanf(line, "[%[^]]", section) == 1) {
strcpy(section, strstrip(section));
strcpy(section, strlwc(section));
sta = LINE_SECTION;
}
} else if (sscanf(line, "%[^=] = \"%[^\"]\"", key, value) == 2
|| sscanf(line, "%[^=] = '%[^\']'", key, value) == 2
|| sscanf(line, "%[^=] = %[^;#]", key, value) == 2) {
/* Usual key=value, with or without comments */
strcpy(key, strstrip(key));
strcpy(key, strlwc(key));
strcpy(value, strstrip(value));
/*
* sscanf cannot handle '' or "" as empty values
* this is done here
*/
if (!strcmp(value, "\"\"") || (!strcmp(value, "''")))
value[0] = 0;
sta = LINE_VALUE;
} else if (sscanf(line, "%[^=] = %[;#]", key, value) == 2
|| sscanf(line, "%[^=] %[=]", key, value) == 2) {
/*
* Special cases:
* key=
* key=;
* key=#
*/
strcpy(key, strstrip(key));
strcpy(key, strlwc(key));
value[0] = 0;
sta = LINE_VALUE;
} else {
/* Generate syntax error */
sta = LINE_ERROR;
}
return sta;
}
/* The remaining public functions are documented in ciniparser.h */
int ciniparser_getnsec(dictionary* d)
{
int i;
int nsec;
if (d == NULL)
return -1;
nsec = 0;
for (i = 0; i < d->size; i++) {
if (d->key[i] == NULL)
continue;
if (strchr(d->key[i], ':') == NULL)
nsec++;
}
return nsec;
}
const char* ciniparser_getsecname(dictionary* d, int n)
{
int i;
int foundsec;
if (d == NULL || n < 0)
return NULL;
if (n == 0)
n++;
foundsec = 0;
for (i = 0; i < d->size; i++) {
if (d->key[i] == NULL)
continue;
if (!strchr(d->key[i], ':')) {
foundsec++;
if (foundsec >= n)
break;
}
}
if (foundsec == n)
return d->key[i];
return (char*)NULL;
}
void ciniparser_dump(dictionary* d, FILE* f)
{
int i;
if (d == NULL || f == NULL)
return;
for (i = 0; i < d->size; i++) {
if (d->key[i] == NULL)
continue;
if (d->val[i] != NULL)
fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]);
else
fprintf(f, "[%s]=UNDEF\n", d->key[i]);
}
}
void ciniparser_dump_ini(dictionary* d, FILE* f)
{
int i, j;
char keym[ASCIILINESZ + 1];
int nsec;
const char* secname;
int seclen;
if (d == NULL || f == NULL)
return;
memset(keym, 0, ASCIILINESZ + 1);
nsec = ciniparser_getnsec(d);
if (nsec < 1) {
/* No section in file: dump all keys as they are */
for (i = 0; i < d->size; i++) {
if (d->key[i] == NULL)
continue;
fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
}
return;
}
for (i = 0; i < nsec; i++) {
secname = ciniparser_getsecname(d, i);
seclen = (int)strlen(secname);
fprintf(f, "\n[%s]\n", secname);
snprintf(keym, ASCIILINESZ + 1, "%s:", secname);
for (j = 0; j < d->size; j++) {
if (d->key[j] == NULL)
continue;
if (!strncmp(d->key[j], keym, seclen + 1)) {
fprintf(f, "%-30s = %s\n",
d->key[j] + seclen + 1,
d->val[j] ? d->val[j] : "");
}
}
}
fprintf(f, "\n");
}
const char* ciniparser_getstring(dictionary* d, const char* key, char* def)
{
char* lc_key;
const char* sval;
if (d == NULL || key == NULL)
return def;
lc_key = strlwc(key);
sval = dictionary_get(d, lc_key, def);
return sval;
}
int ciniparser_getint(dictionary* d, const char* key, int notfound)
{
const char* str;
str = ciniparser_getstring(d, key, INI_INVALID_KEY);
if (str == INI_INVALID_KEY)
return notfound;
return (int)strtol(str, NULL, 10);
}
double ciniparser_getdouble(dictionary* d, const char* key, double notfound)
{
const char* str;
str = ciniparser_getstring(d, key, INI_INVALID_KEY);
if (str == INI_INVALID_KEY)
return notfound;
return atof(str);
}
int ciniparser_getboolean(dictionary* d, const char* key, int notfound)
{
const char* c;
int ret;
c = ciniparser_getstring(d, key, INI_INVALID_KEY);
if (c == INI_INVALID_KEY)
return notfound;
switch (c[0]) {
case 'y': case 'Y': case '1': case 't': case 'T':
ret = 1;
break;
case 'n': case 'N': case '0': case 'f': case 'F':
ret = 0;
break;
default:
ret = notfound;
break;
}
return ret;
}
int ciniparser_find_entry(dictionary* ini, const char* entry)
{
int found = 0;
if (ciniparser_getstring(ini, entry, INI_INVALID_KEY) != INI_INVALID_KEY)
found = 1;
return found;
}
int ciniparser_set(dictionary* d, const char* entry, const char* val)
{
return dictionary_set(d, strlwc(entry), val);
}
void ciniparser_unset(dictionary* ini, char* entry)
{
dictionary_unset(ini, strlwc(entry));
}
dictionary* ciniparser_load(const char* ininame)
{
FILE* in;
char line[ASCIILINESZ + 1];
char section[ASCIILINESZ + 1];
char key[ASCIILINESZ + 1];
char tmp[ASCIILINESZ + 1];
char val[ASCIILINESZ + 1];
int last = 0, len, lineno = 0, errs = 0;
dictionary* dict;
in = fopen(ininame, "r");
if (in == NULL) {
fprintf(stderr, "ciniparser: cannot open %s\n (ignored)",
ininame);
return NULL;
}
dict = dictionary_new(0);
if (!dict) {
fclose(in);
return NULL;
}
memset(line, 0, ASCIILINESZ + 1);
memset(section, 0, ASCIILINESZ + 1);
memset(key, 0, ASCIILINESZ + 1);
memset(val, 0, ASCIILINESZ + 1);
last = 0;
while (fgets(line + last, ASCIILINESZ - last, in) != NULL) {
lineno++;
len = (int)strlen(line) - 1;
/* Safety check against buffer overflows */
if (line[len] != '\n') {
fprintf(stderr,
"ciniparser: input line too long in %s (%d)\n",
ininame,
lineno);
dictionary_del(dict);
fclose(in);
return NULL;
}
/* Get rid of \n and spaces at end of line */
while ((len >= 0) &&
((line[len] == '\n') || (isspace(line[len])))) {
line[len] = 0;
len--;
}
/* Detect multi-line */
if (len >= 0 && line[len] == '\\') {
/* Multi-line value */
last = len;
continue;
}
switch (ciniparser_line(line, section, key, val)) {
case LINE_EMPTY:
case LINE_COMMENT:
break;
case LINE_SECTION:
errs = dictionary_set(dict, section, NULL);
break;
case LINE_VALUE:
snprintf(tmp, ASCIILINESZ + 1, "%s:%s", section, key);
errs = dictionary_set(dict, tmp, val);
break;
case LINE_ERROR:
fprintf(stderr, "ciniparser: syntax error in %s (%d):\n",
ininame, lineno);
fprintf(stderr, "-> %s\n", line);
errs++;
break;
default:
break;
}
memset(line, 0, ASCIILINESZ);
last = 0;
if (errs < 0) {
fprintf(stderr, "ciniparser: memory allocation failure\n");
break;
}
}
if (errs) {
dictionary_del(dict);
dict = NULL;
}
fclose(in);
return dict;
}
void ciniparser_freedict(dictionary* d)
{
dictionary_del(d);
}
ciniparser.h
Parser for ini files.
line_status
enum _line_status_ line_status
This enum stores the status for each parsed line (internal use only).
ciniparser_set
int ciniparser_set(dictionary *d, const char *entry, const char *val)
Set an item in the dictionary.
Definition ciniparser.c:358
ciniparser_load
dictionary * ciniparser_load(const char *ininame)
Parse an ini file and return an allocated dictionary object.
Definition ciniparser.c:368
ciniparser_getboolean
int ciniparser_getboolean(dictionary *d, const char *key, int notfound)
Get the string associated to a key, convert to a boolean.
Definition ciniparser.c:324
dictionary_unset
void dictionary_unset(dictionary *d, const char *key)
Delete a key in a dictionary.
Definition dictionary.c:206
_line_status_
_line_status_
This enum stores the status for each parsed line (internal use only).
Definition ciniparser.c:44
ciniparser_getnsec
int ciniparser_getnsec(dictionary *d)
Get number of sections in a dictionary.
Definition ciniparser.c:179
dictionary
struct _dictionary_ dictionary
Dictionary object.
ciniparser_getint
int ciniparser_getint(dictionary *d, const char *key, int notfound)
Get the string associated to a key, convert to an int.
Definition ciniparser.c:300
ciniparser_getsecname
const char * ciniparser_getsecname(dictionary *d, int n)
Get name for section n in a dictionary.
Definition ciniparser.c:198
dictionary_new
dictionary * dictionary_new(int size)
Create a new dictionary object.
Definition dictionary.c:92
dictionary_get
const char * dictionary_get(dictionary *d, const char *key, const char *def)
Get a value from a dictionary.
Definition dictionary.c:128
dictionary_del
void dictionary_del(dictionary *d)
Delete a dictionary object.
Definition dictionary.c:109
dictionary_set
int dictionary_set(dictionary *d, const char *key, const char *val)
Set a value in a dictionary.
Definition dictionary.c:147
ciniparser_getdouble
double ciniparser_getdouble(dictionary *d, const char *key, double notfound)
Get the string associated to a key, convert to a double.
Definition ciniparser.c:312
ciniparser_dump
void ciniparser_dump(dictionary *d, FILE *f)
Dump a dictionary to an opened file pointer.
Definition ciniparser.c:227
ciniparser_unset
void ciniparser_unset(dictionary *ini, char *entry)
Delete an entry in a dictionary.
Definition ciniparser.c:363
ciniparser_freedict
void ciniparser_freedict(dictionary *d)
Free all memory associated to an ini dictionary.
Definition ciniparser.c:468
ciniparser_getstring
const char * ciniparser_getstring(dictionary *d, const char *key, char *def)
Get the string associated to a key.
Definition ciniparser.c:286
ciniparser_dump_ini
void ciniparser_dump_ini(dictionary *d, FILE *f)
Save a dictionary to a loadable ini file.
Definition ciniparser.c:244
ciniparser_find_entry
int ciniparser_find_entry(dictionary *ini, const char *entry)
Finds out if a given entry exists in a dictionary.
Definition ciniparser.c:348