#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "conf.h"
typedef struct _SField
{
char *name;
int type;
union {
char *str_value;
int int_value;
double double_value;
HTable table_value;
} value;
struct _SField *next;
} SField;
typedef struct _STable
{
SField *fields;
char *stat_buf;
} STable;
typedef struct _STableIterator
{
HTable table;
SField *cur_field;
int before_start;
char *stat_buf;
} STableIterator;
HTable table_create()
{
HTable table;
table = (STable*)calloc(1, sizeof(STable));
return table;
}
static void free_field(SField *field)
{
if (! field)
return;
if (field->name)
free(field->name);
switch (field->type)
{
case TYPE_STRING: free(field->value.str_value); break;
case TYPE_TABLE: table_free(field->value.table_value); break;
}
free(field);
}
static SField* find_field(HTable table, const char *name)
{
SField *f;
if ((! table) || (! name))
return NULL;
f = table->fields;
while (f)
{
if (f->name && (! strcmp(f->name, name)))
return f;
f = f->next;
}
return NULL;
}
int table_remove_field(HTable table, char *field)
{
SField *f, *pf;
if ((! table) || (! field))
return -1;
f = find_field(table, field);
if (f)
{
if (table->fields == f)
table->fields = f->next;
else
{
pf = table->fields;
while (pf && (pf->next != f))
pf = pf->next;
if (pf)
pf->next = f->next;
}
free_field(f);
}
return 0;
}
static SField* add_empty_field(HTable table, const char *field)
{
SField *f, *nf;
if ((! table) || (! field))
return NULL;
f = find_field(table, field);
if (f)
table_remove_field(table, f->name);
nf = (SField*)calloc(1, sizeof(SField));
if (! nf) return NULL;
nf->name = strdup(field);
f = table->fields;
if (f)
{
while (f->next)
f = f->next;
f->next = nf;
}
else
table->fields = nf;
return nf;
}
int table_set_str(HTable table, const char *field, const char *value)
{
SField *f;
if ((! table) || (! field) || (! value))
return -1;
f = add_empty_field(table, field);
if (! f) return -1;
f->type = TYPE_STRING;
f->value.str_value = strdup(value);
return 0;
}
int table_set_int(HTable table, const char *field, int value)
{
SField *f;
if ((! table) || (! field))
return -1;
f = add_empty_field(table, field);
if (! f) return -1;
f->type = TYPE_INT;
f->value.int_value = value;
return 0;
}
int table_set_double(HTable table, const char *field, double value)
{
SField *f;
if ((! table) || (! field))
return -1;
f = add_empty_field(table, field);
if (! f) return -1;
f->type = TYPE_FLOAT;
f->value.double_value = value;
return 0;
}
int table_set_table(HTable table, const char *field, HTable value)
{
SField *f;
if ((! table) || (! field) || (! value))
return -1;
f = add_empty_field(table, field);
if (! f) return -1;
f->type = TYPE_TABLE;
f->value.table_value = value;
return 0;
}
static int skip_spaces(char *buf, long int *pos);
static int skip_multy_comment(char *buf, long int *pos)
{
while (buf[*pos])
{
if (buf[*pos] == '*')
{
(*pos)++;
if (buf[*pos] == '/')
{
(*pos)++;
return skip_spaces(buf, pos);
}
}
(*pos)++;
}
return -1;
}
static int skip_line_comment(char *buf, long int *pos)
{
while (buf[*pos] && ((buf[*pos]) != '\n'))
(*pos)++;
return skip_spaces(buf, pos);
}
static int is_cspace(char *buf, long int *pos)
{
if (isspace(buf[*pos]))
return 1;
if (buf[*pos] == '/')
{
if ((buf[(*pos) + 1] == '*') || (buf[(*pos) + 1] == '/'))
return 1;
}
return 0;
}
static int skip_spaces(char *buf, long int *pos)
{
while (buf[*pos] && isspace(buf[*pos]))
(*pos)++;
if (buf[*pos] == '/')
{
(*pos)++;
if (buf[*pos] == '*')
{
(*pos)++;
return skip_multy_comment(buf, pos);
}
else if (buf[*pos] == '/')
{
(*pos)++;
return skip_line_comment(buf, pos);
}
else
return -1;
}
return 0;
}
static int is_symbol(char sym)
{
static char syms[] = { '=', '{', '}', ';', '\'', '"', ',', '/', '\\' };
unsigned int i;
for (i = 0; i < sizeof(syms) / sizeof(char); i++)
{
if (sym == syms[i])
return 1;
}
return 0;
}
static char* read_string(char* buf, long int *pos)
{
int allocated=50, len=1;
char *b;
b = (char*)malloc(allocated);
if (! b) return NULL;
b[0] = buf[*pos];
(*pos)++;
while (buf[*pos])
{
if (len + 3 > allocated)
{
char *s = (char*)realloc(b, allocated+=20);
if (! s)
{
free(b);
return NULL;
}
b = s;
}
if ((buf[*pos] == '\\') && (buf[*pos + 1] == b[0]))
{
b[len++] = '\\';
b[len] = b[0];
}
else
{
b[len++] = buf[*pos];
if (buf[*pos] == b[0])
{
b[len] = 0;
(*pos)++;
return b;
}
}
(*pos)++;
}
free(b);
return NULL;
}
static char* read_word(char* buf, long int *pos)
{
int allocated=50, len=0;
char *b;
b = (char*)malloc(allocated);
if (! b) return NULL;
while (buf[*pos] && (! is_cspace(buf, pos)) && (! is_symbol(buf[*pos])))
{
if (len + 3 > allocated)
{
char *s = (char*)realloc(b, allocated+=20);
if (! s)
{
free(b);
return NULL;
}
b = s;
}
b[len++] = buf[*pos];
(*pos)++;
}
if (! len)
{
free(b);
return NULL;
}
b[len] = 0;
return b;
}
static char* read_token(char *buf, long int *pos)
{
if (skip_spaces(buf, pos) || (! buf[*pos]))
return NULL;
if ((buf[*pos] == '\'') || (buf[*pos] == '"'))
return read_string(buf, pos);
if (is_symbol(buf[*pos]))
{
char *b = (char*)malloc(2);
if (! b) return NULL;
b[0] = buf[*pos];
b[1] = 0;
(*pos)++;
return b;
}
return read_word(buf, pos);
}
static long int get_file_size(FILE *f)
{
long int len;
if (fseek(f, 0L, SEEK_END))
return -1;
len = ftell(f);
if (fseek(f, 0L, SEEK_SET))
return -1;
return len;
}
static char* read_file(const char *filename, long int *length)
{
FILE *f;
char *buf;
long int len;
f = fopen(filename, "rb");
if (! f) return NULL;
len = get_file_size(f);
if (len <= 0)
{
fclose(f);
return NULL;
}
buf = (char*)malloc(len + 1);
if (! buf)
{
fclose(f);
return NULL;
}
if (fread(buf, 1, len, f) != (unsigned)len)
{
free(buf);
fclose(f);
return NULL;
}
buf[len] = 0;
fclose(f);
*length = len + 1;
return buf;
}
static int get_next_index(HTable table)
{
SField *f;
int v, max_v=-1;
char *endptr;
for (f = table->fields; f; f = f->next)
{
v = strtol(f->name, &endptr, 10);
if ((! f->name[0]) || (endptr[0]))
continue;
if (v > max_v)
max_v = v;
}
return max_v + 1;
}
static int is_ident(char *str)
{
char *p;
if (! str)
return 0;
if (strlen(str) < 1)
return 0;
if (! isalpha(str[0]))
return 0;
for (p = str; *p; p++)
if (! (isalnum(*p) || (*p == '_') || (*p == '.')))
return 0;
return 1;
}
static int is_string_value(char *value)
{
int len;
if ((value[0] == '\'') || (value[0] == '"'))
{
if ((len = strlen(value)) >= 2)
{
if (value[len - 1] == value[0])
return 1;
}
}
return 0;
}
static int is_int_value(char *value)
{
char *p;
for (p = value; *p; p++)
{
if (! isdigit(*p))
{
if (p != value)
return 0;
else
if (! ((*p == '+') || (*p == '-')))
return 0;
}
}
return 1;
}
static int is_float_value(char *value)
{
char *p;
int pcount = 0;
for (p = value; *p; p++)
{
if (! isdigit(*p))
{
if (p != value)
{
if (*p != '.')
return 0;
else
{
pcount++;
if (pcount > 1)
return 0;
}
}
else
{
if (! ((*p == '+') || (*p == '-')))
return 0;
}
}
}
return 1;
}
static int get_value_type(char *value)
{
if ((! value) || (! value[0]))
return -1;
if (is_string_value(value))
return TYPE_STRING;
if (! strcmp(value, "{"))
return TYPE_TABLE;
if (is_int_value(value))
return TYPE_INT;
if (is_float_value(value))
return TYPE_FLOAT;
return -1;
}
static char* unescape_string(char *str)
{
char *buf, quote, *p;
int allocated=50, len=0;
buf = (char*)malloc(allocated);
quote = str[0];
p = str + 1;
while ((*p) && (*p != quote))
{
if (len + 10 > allocated)
{
char *s = (char*)realloc(buf, allocated+=20);
if (! s)
{
free(buf);
return NULL;
}
buf = s;
}
if (*p == '\\')
{
p++;
switch (*p)
{
case 'n': buf[len++] = '\n'; break;
case 't': buf[len++] = '\t'; break;
case 'r': buf[len++] = '\r'; break;
default: buf[len++] = *p;
}
}
else
buf[len++] = *p;
p++;
}
buf[len] = 0;
if ((*p == quote) && (*(p + 1)))
{
free(buf);
return NULL;
}
return buf;
}
static int parse_table(HTable table, char *buf, long int *pos, int top_level);
static int add_field(HTable table, char *name, char *value, char *buf, long int *pos)
{
int value_type;
char *s;
HTable tbl;
value_type = get_value_type(value);
switch (value_type)
{
case TYPE_INT:
table_set_int(table, name, atoi(value));
break;
case TYPE_STRING:
s = unescape_string(value);
if (! s)
return -1;
table_set_str(table, name, s);
free(s);
break;
case TYPE_FLOAT:
table_set_double(table, name, atof(value));
break;
case TYPE_TABLE:
tbl = table_create();
if (table_set_table(table, name, tbl))
{
table_free(tbl);
return -1;
}
if (parse_table(tbl, buf, pos, 0))
return -1;
break;
default:
return -1;
}
return 0;
}
static int add_field_to_array(HTable table, char *token, char *buf, long int *pos)
{
int idx = get_next_index(table);
char b[100];
sprintf(b, "%i", idx);
return add_field(table, b, token, buf, pos);
}
/*
* TODO: add field as in array highly unoptimized. it scans for max index
* number on every element addition, converting idexes from strings
* to numbers where it possible. optimizations method: process
* indexes in batch
*/
static int parse_table(HTable table, char *buf, long int *pos, int top_level)
{
char *token=NULL;
char *name;
int res;
while (1)
{
if (! token)
token = read_token(buf, pos);
if (! token)
{
if (top_level)
return 0;
else
return -1;
}
if (! strcmp(token, "{"))
{
if (add_field_to_array(table, token, buf, pos))
{
free(token);
return -1;
}
free(token);
token = read_token(buf, pos);
if (! token)
{
if (top_level)
return 0;
else
return -1;
}
if ((! strcmp(token, ";")) || (! strcmp(token, ",")))
{
free(token);
token = NULL;
}
continue;
}
else if (! strcmp(token, "}"))
{
free(token);
if (top_level)
return -1;
else
return 0;
}
name = token;
token = read_token(buf, pos);
if (token && (! strcmp(token, "=")))
{
free(token);
if (! is_ident(name))
{
free(name);
return -1;
}
token = read_token(buf, pos);
if (! token)
{
free(name);
return -1;
}
res = add_field(table, name, token, buf, pos);
free(name);
free(token);
if (res)
{
return -1;
}
token = read_token(buf, pos);
if (! token)
{
if (top_level)
return 0;
else
return -1;
}
if ((! strcmp(token, ";")) || (! strcmp(token, ",")))
{
free(token);
token = NULL;
}
else
if (strcmp(token, "}"))
{
free(token);
return -1;
}
}
else
{
if ((! token) && (! top_level))
{
free(name);
return -1;
}
if (! (token && ((! strcmp(token, ";")) || (! strcmp(token, ","))
|| (! strcmp(token, "}")))))
{
free(name);
if (token) free(token);
return -1;
}
res = add_field_to_array(table, name, buf, pos);
free(name);
if (res)
{
free(token);
return -1;
}
if ((! token) || (! strcmp(token, "}")))
{
if (token) free(token);
return 0;
}
if (token && ((! strcmp(token, ",")) || ((! strcmp(token, ";")))))
{
free(token);
token = NULL;
}
}
}
return 0;
}
HTable table_read(const char *filename)
{
long int len, pos;
char *buf;
HTable table;
int res;
buf = read_file(filename, &len);
if (! buf) return NULL;
pos = 0;
table = table_create();
res = parse_table(table, buf, &pos, 1);
if (res)
{
table_free(table);
table = NULL;
}
free(buf);
return table;
}
void table_free(HTable table)
{
SField *f, *nf;
if (! table) return;
f = table->fields;
while (f)
{
nf = f->next;
free_field(f);
f = nf;
}
if (table->stat_buf)
free(table->stat_buf);
free(table);
}
HTableIterator table_get_iter(HTable table)
{
HTableIterator it;
it = (HTableIterator)calloc(sizeof(STableIterator), 1);
if (! it) return NULL;
it->table = table;
it->before_start = 1;
return it;
}
void table_free_iter(HTableIterator iterator)
{
if (! iterator) return;
if (iterator->stat_buf) free(iterator->stat_buf);
free(iterator);
}
int table_iter_next(HTableIterator iterator)
{
if (! iterator)
return 0;
if (iterator->before_start)
{
iterator->before_start = 0;
iterator->cur_field = iterator->table->fields;
}
else
{
if (iterator->cur_field)
iterator->cur_field = iterator->cur_field->next;
}
if (! iterator->cur_field)
return 0;
return 1;
}
char* table_iter_get_name(HTableIterator iterator)
{
if ((! iterator) || (! iterator->cur_field))
return NULL;
return iterator->cur_field->name;
}
int table_iter_get_type(HTableIterator iterator)
{
if ((! iterator) || (! iterator->cur_field))
return -1;
return iterator->cur_field->type;
}
static char* encode_string(char *str)
{
char *buf, *s;
int allocated, len;
if (! str)
return strdup("''");
allocated = 20;
buf = (char*)malloc(allocated);
if (! buf) return NULL;
buf[0] = '\'';
len = 1;
for (s = str; *s; s++)
{
if (len + 2 < allocated - 2)
{
char *m = (char*)realloc(buf, allocated += 20);
if (! m)
{
free(buf);
return NULL;
}
buf = m;
}
switch (*s)
{
case '\n': buf[len++] = '\\'; buf[len++] = 'n'; break;
case '\r': buf[len++] = '\\'; buf[len++] = 'r'; break;
case '\'': buf[len++] = '\\'; buf[len++] = '\''; break;
case '\\': buf[len++] = '\\'; buf[len++] = '\\'; break;
default:
buf[len++] = *s;
}
}
buf[len++] = '\'';
buf[len] = 0;
return buf;
}
static char* print_field(SField *field, int butify, int spaces)
{
char buf[100];
if (! field) return NULL;
switch (field->type)
{
case TYPE_STRING:
return encode_string(field->value.str_value);
case TYPE_INT:
sprintf(buf, "%i", field->value.int_value);
return strdup(buf);
case TYPE_FLOAT:
sprintf(buf, "%g", field->value.double_value);
if (! strchr(buf, '.'))
strcat(buf, ".0");
return strdup(buf);
case TYPE_TABLE:
return table_to_str(field->value.table_value, 1, butify, spaces);
}
return NULL;
}
static int isSimpleArray(HTable table)
{
SField *f;
char buf[50];
int i;
for (f = table->fields, i = 0; f; f = f->next, i++)
{
sprintf(buf, "%i", i);
if (! (f && f->name && (! strcmp(f->name, buf))))
return 0;
}
return 1;
}
#define APPEND_BUF(buf, s) { int l = strlen(s); \
if (len + l > allocated - 5) { \
char *nb; \
allocated += l + 50; \
nb = (char*)realloc(buf, allocated); \
if (! nb) { \
free(buf); \
return NULL; \
} \
buf = nb; \
} \
strcat(buf, s); \
len += l; \
}
#define APPEND_SPACES(buf, n) \
for (int i = 0; i < n; i++) { APPEND_BUF(buf, " "); }
char* table_to_str(HTable table, int print_braces, int butify, int spaces)
{
char *b, *fs;
int len=0, allocated;
SField *f;
if (! table) return NULL;
allocated = 100;
b = (char*)malloc(allocated);
if (! b) return NULL;
if (print_braces) {
if (butify)
strcpy(b, "{\n");
else
strcpy(b, "{ ");
} else
strcpy(b, "");
len = strlen(b);
int printNames = ! isSimpleArray(table);
for (f = table->fields; f; f = f->next) {
if (butify) {
APPEND_SPACES(b, spaces);
} else
if (f != table->fields) {
APPEND_BUF(b, " ");
}
if (printNames) {
APPEND_BUF(b, f->name);
APPEND_BUF(b, " = ");
}
fs = print_field(f, butify, spaces + 4);
APPEND_BUF(b, fs);
free(fs);
if (butify) {
APPEND_BUF(b, ";\n");
} else {
APPEND_BUF(b, ";");
}
}
if (print_braces) {
if (! butify) {
APPEND_BUF(b, " }");
} else {
APPEND_SPACES(b, spaces);
APPEND_BUF(b, "}");
}
}
return b;
}
static char* get_field_str(SField *field, int *err)
{
char buf[100];
if (err) *err = 0;
if (! field)
{
if (err) *err = 1;
return NULL;
}
switch (field->type)
{
case TYPE_STRING:
return strdup(field->value.str_value);
case TYPE_INT:
sprintf(buf, "%i", field->value.int_value);
return strdup(buf);
case TYPE_FLOAT:
sprintf(buf, "%f", field->value.double_value);
return strdup(buf);
case TYPE_TABLE:
return table_to_str(field->value.table_value, 1, 0, 0);;
}
if (err) *err = 1;
return NULL;
}
char* table_iter_get_str(HTableIterator iterator, int *err)
{
if ((! iterator) || (! iterator->cur_field))
{
if (err) *err = 1;
return NULL;
}
return get_field_str(iterator->cur_field, err);
}
char* table_iter_get_strs(HTableIterator iterator, int *err)
{
if ((! iterator) || (! iterator->cur_field))
{
if (err) *err = 1;
return NULL;
}
if (iterator->stat_buf)
free(iterator->stat_buf);
iterator->stat_buf = get_field_str(iterator->cur_field, err);
return iterator->stat_buf;
}
static int get_field_int(SField *field, int *err)
{
char *endptr;
int n;
if (err) *err = 0;
if (! field)
{
if (err) *err = 1;
return 0;
}
switch (field->type)
{
case TYPE_STRING:
n = strtol(field->value.str_value, &endptr, 10);
if ((! field->value.str_value[0]) || (endptr[0]))
{
if (err) *err = 1;
return 0;
}
return n;
case TYPE_INT:
return field->value.int_value;
case TYPE_FLOAT:
return (int)field->value.double_value;
}
if (err) *err = 1;
return 0;
}
int table_iter_get_int(HTableIterator iterator, int *err)
{
if ((! iterator) || (! iterator->cur_field))
{
if (err) *err = 1;
return 0;
}
return get_field_int(iterator->cur_field, err);
}
static double get_field_double(SField *field, int *err)
{
char *endptr;
double n;
if (err) *err = 0;
if (! field)
{
if (err) *err = 1;
return 0.0;
}
switch (field->type)
{
case TYPE_STRING:
n = strtod(field->value.str_value, &endptr);
if ((! field->value.str_value[0]) || (endptr[0]))
{
if (err) *err = 1;
return 0.0;
}
return n;
case TYPE_INT:
return field->value.int_value;
case TYPE_FLOAT:
return field->value.double_value;
}
if (err) *err = 1;
return 0.0;
}
double table_iter_get_double(HTableIterator iterator, int *err)
{
if ((! iterator) || (! iterator->cur_field))
{
if (err) *err = 1;
return 0.0;
}
return get_field_double(iterator->cur_field, err);
}
HTable table_iter_get_table(HTableIterator iterator, int *err)
{
if ((! iterator) || (! iterator->cur_field))
{
if (err) *err = 1;
return NULL;
}
if (iterator->cur_field->type != TYPE_TABLE)
{
if (err) *err = 1;
return NULL;
}
if (err) *err = 0;
return iterator->cur_field->value.table_value;
}
int table_is_field_exists(HTable table, char *name)
{
SField *f;
f = find_field(table, name);
if (f)
return 1;
else
return 0;
}
int table_get_field_type(HTable table, char *field)
{
SField *f;
f = find_field(table, field);
if (! f)
return -1;
return f->type;
}
char* table_get_str(HTable table, char *field, char *dflt, int *err)
{
SField *f;
char *s;
int e;
f = find_field(table, field);
if (! f)
{
if (err) *err = 1;
if (dflt)
return strdup(dflt);
else
return NULL;
}
s = get_field_str(f, &e);
if (err) *err = e;
if (e)
{
if (dflt)
return strdup(dflt);
else
return NULL;
}
else
{
if (s)
return strdup(s);
else
return NULL;
}
}
char* table_get_strs(HTable table, char *field, char *dflt, int *err)
{
SField *f;
char *s;
int e;
if (! table)
{
if (err) *err = 1;
return dflt;
}
if (table->stat_buf)
{
free(table->stat_buf);
table->stat_buf = NULL;
}
f = find_field(table, field);
if (! f)
{
if (err) *err = 1;
return dflt;
}
s = get_field_str(f, &e);
table->stat_buf = s;
if (err) *err = e;
if (e)
s = dflt;
return s;
}
int table_get_int(HTable table, char *field, int dflt, int *err)
{
SField *f;
int v, e;
f = find_field(table, field);
if (! f)
{
if (err) *err = 1;
return dflt;
}
v = get_field_int(f, &e);
if (err) *err = e;
if (e)
v = dflt;
return v;
}
double table_get_double(HTable table, char *field, double dflt, int *err)
{
SField *f;
double v;
int e;
f = find_field(table, field);
if (! f)
{
if (err) *err = 1;
return dflt;
}
v = get_field_double(f, &e);
if (err) *err = e;
if (e)
v = dflt;
return v;
}
HTable table_get_table(HTable table, char *field, HTable dflt, int *err)
{
SField *f;
HTable v;
f = find_field(table, field);
if ((! f) || (f->type != TYPE_TABLE))
{
if (err) *err = 1;
return dflt;
}
v = f->value.table_value;
if (err) *err = 0;
return v;
}
int table_append_str(HTable table, const char *val)
{
int idx;
char b[100];
if ((! table) || (! val))
return -1;
idx = get_next_index(table);
sprintf(b, "%i", idx);
table_set_str(table, b, val);
return 0;
}
int table_append_int(HTable table, int val)
{
int idx;
char b[100];
if ((! table) || (! val))
return -1;
idx = get_next_index(table);
sprintf(b, "%i", idx);
table_set_int(table, b, val);
return 0;
}
int table_append_double(HTable table, double val)
{
int idx;
char b[100];
if ((! table) || (! val))
return -1;
idx = get_next_index(table);
sprintf(b, "%i", idx);
table_set_double(table, b, val);
return 0;
}
int table_append_table(HTable table, HTable val)
{
int idx;
char b[100];
if ((! table) || (! val))
return -1;
idx = get_next_index(table);
sprintf(b, "%i", idx);
table_set_table(table, b, val);
return 0;
}
