diff --git a/src/util/conf.c b/src/util/conf.c index de56d5e..b168167 100644 --- a/src/util/conf.c +++ b/src/util/conf.c @@ -1,24 +1,25 @@ #include "conf.h" +#include #include #include #include #include #include +#include +#include "../error.h" #include "atrb.h" -int conf_procbuf(char const* restrict buf, size_t buflen, struct conf_entry const* opts, size_t optc) { - enum { - ERR_ABSENT = 1, - ERR_NOMATCH = 2, - ERR_INVALID_TYPE = 3, - }; +int conf_procbuf(char const* restrict buf, char* restrict kout, char* restrict vout, size_t len) { + // length data storage + unsigned idx = 0; // index to the data below - unsigned idx = 0; // index to the data below - char const* dat[2] = {0}; // stores key-value data - unsigned len[2] = {0}; // stores the length of the data - for (size_t i = 0; i < buflen; i++) { + // data traversal + char* pos = kout; // will point to the next point in the buffer, where we'll write data + + // acquire data + for (size_t i = 0; i < len; i++) { // handling of termination tokens bool brk = false; // whether we broke out of the loop, and are done reading switch (buf[i]) { @@ -33,41 +34,90 @@ int conf_procbuf(char const* restrict buf, size_t buflen, struct conf_entry cons // everything after `=` is interpreted as a value if (buf[i] == '=' && !idx) { + *pos = '\0'; // terminate string + pos = vout; // move pointer to start of value data idx++; continue; } - - // set the value pointer to the current buffer char - dat[idx] = dat[idx] ? dat[idx] : &buf[i]; - len[idx]++; + *pos = buf[i]; // copy over the buffer's data + pos++; // increment the position pointer } - if (!(dat[0] && dat[1])) return ERR_ABSENT; + if (pos == kout) return 0; // line was ignored if pos didn't move + // null-terminate what we've got now (yes, there should be enough space for this since \0 isn't stored) + *pos = '\0'; + return 0; +} + +struct conf_entry const* conf_matchopt(struct conf_entry const* opts, size_t optc, char const* restrict key) { // find a match for the current key size_t i = 0; for (; i < optc; i++) { - if (strcmp(opts[i].key, dat[0]) == 0) break; + if (strcmp(opts[i].key, key) == 0) + return opts + i; } - if (i >= optc) return ERR_NOMATCH; // no match was found + return NULL; +} - // TODO: keys and vals are not stored as null-terminated strings, thus we should do that - switch (opts[i].type) { - case CONF_I8: break; - case CONF_I16: break; - case CONF_I32: break; - case CONF_I64: break; - case CONF_U8: break; - case CONF_U16: break; - case CONF_U32: break; - case CONF_U64: break; - case CONF_F32: break; - case CONF_F64: break; - case CONF_STR: break; - case CONF_FSTR: break; - default: return ERR_INVALID_TYPE; +int conf_procval(struct conf_entry const* opt, char const* restrict val) { + // parse the data + errno = 0; + char* end; + int8_t dat[sizeof(long)]; + + switch (opt->type) { + // signed integer data parsing + case CONF_I8: + case CONF_I16: + case CONF_I32: + case CONF_I64: + *(long*)dat = strtol(val, &end, 10); + break; + // unsigned integer data parsing + case CONF_U8: + case CONF_U16: + case CONF_U32: + case CONF_U64: + *(ulong*)dat = strtoul(val, &end, 10); + break; + + // floating-point data parsing + case CONF_F32: *(float*)dat = strtof(val, &end); break; + case CONF_F64: *(double*)dat = strtod(val, &end); break; + + // string data parsing + case CONF_STR: + if (*(char**)opt->out) { + free(*(char**)opt->out); // if the same key is given multiple times, free the memory so we don't leak. + warn("encountered a dynamic string multiple times, this is sub-optimal."); + } + *(char**)opt->out = strdup(val); + return 0; + case CONF_FSTR: { + struct conf_fstr* s = opt->out; + strncpy(s->out, val, s->len); + s->out[s->len - 1] = '\0'; // ensure the string is null-terminated + return 0; + } + default: return CONF_EINVALIDTYPE; // return error code indicating function not implemented } - return 0; + if (errno || end == val || *end != '\0') { + error("failed to parse '%s' as a numeric value", val); + return CONF_EPARSE; + } + + switch (opt->type) { + case CONF_U8: + case CONF_I8: *(int8_t*)opt->out = *(int8_t*)dat; return 0; + case CONF_U16: + case CONF_I16: *(int16_t*)opt->out = *(int16_t*)dat; return 0; + case CONF_U32: + case CONF_I32: *(int32_t*)opt->out = *(int32_t*)dat; return 0; + case CONF_U64: + case CONF_I64: *(int64_t*)opt->out = *(int64_t*)dat; return 0; + default: abort(); // abort; this shouldn't be possible, so I blame the programmer + } } /* utility function for conf_getpat to concatenate 3 strings, where we already know the size */ diff --git a/src/util/conf.h b/src/util/conf.h index cc52853..33bb2cd 100644 --- a/src/util/conf.h +++ b/src/util/conf.h @@ -6,8 +6,17 @@ #include "atrb.h" +/* error codes */ +enum conf_err { + CONF_ENODAT = -1, // no data was found + CONF_ESYNTAX = 1, // couldn't extract clear key/val data + CONF_ENOMATCH = 2, // couldn't find a match for the inputted key + CONF_EINVALIDTYPE = 3, // the type inputted in conf_entry was invalid + CONF_EPARSE = 4, // something went wrong whilst parsing +}; + /* defines the primitive types available in the config file */ -enum config_primitive { +enum conf_primitive { CONF_STR = 0, // expects: `char**`, will output malloc'd data !!must be freed!! CONF_I8 = 1, // expects: `int8_t*`, will point to a location in memory where an i8 is stored. CONF_I16 = 2, // expects: `int16_t*`, will point to a location in memory where an i16 is stored. @@ -25,7 +34,7 @@ enum config_primitive { /* for outputting a fixed string as this config field */ struct conf_fstr { size_t len; // length in BYTES of the output data - char* datl; // where we will output the data + char* out; // where we will output the data }; /* defines the structure of a config file entry */ @@ -35,9 +44,20 @@ struct conf_entry { uint8_t type; // the primitive type which we are querying for }; -/* processes an incoming buffer for conf_entry - * returns 0 upon success, 1 upon failure*/ -int conf_procbuf(char const*, size_t, struct conf_entry const*, size_t); +/* processes an incoming buffer. + * `buf`, `kout` and `vout` mustn't overlap, and must be (at least) `len` bytes long! + * `kout` and `vout` will contain a null-terminated string if the function returned successfully. + * returns `0` on success, `<0` when no data was found. `>0` when data was invalid but something went wrong. + * see `CONF_E*` or `enum conf_err` */ +int conf_procbuf(char const* restrict buf, char* restrict kout, char* restrict vout, size_t len); + +/* matches the key with one of the options and returns the pointer. Returns NULL if none could be found. */ +struct conf_entry const* conf_matchopt(struct conf_entry const* opts, size_t optc, char const* restrict key); + +/* processes the value belonging to the key and outputs the result to opts. + * - `val` points to a null-terminated string which contains the key and value. + * returns `0` upon success, non-zero upon failure. For information about specific error codes, see `enum conf_err` */ +int conf_procval(struct conf_entry const* opts, char const* restrict val); /* acquires the config file path, appending str to the end (you need to handle path separators yourself) * expecting str to be null-terminated