From ae96c724e905181ca10441a63b1dfe9c2fc5d2ea Mon Sep 17 00:00:00 2001 From: John Tsiombikas Date: Tue, 4 Dec 2018 05:51:07 +0200 Subject: [PATCH] added treestore and started a bit on the tilesets for the maze parts --- src/hairball.c | 29 ++- src/mesh.c | 12 + src/mesh.h | 3 + src/tilemaze.c | 96 +++++++- src/treestor.c | 748 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/treestor.h | 145 +++++++++++ src/ts_text.c | 361 +++++++++++++++++++++++++++ 7 files changed, 1390 insertions(+), 4 deletions(-) create mode 100644 src/treestor.c create mode 100644 src/treestor.h create mode 100644 src/ts_text.c diff --git a/src/hairball.c b/src/hairball.c index 11e4444..89c45c3 100644 --- a/src/hairball.c +++ b/src/hairball.c @@ -1,6 +1,7 @@ #include #include #include +#include #include "demo.h" #include "3dgfx.h" #include "vmath.h" @@ -74,7 +75,7 @@ struct screen *hairball_screen(void) static int init(void) { - int i; + int i, j, numpt = 0; gen_sphere_mesh(&sphmesh, 1.0f, 12, 6); @@ -87,8 +88,30 @@ static int init(void) return -1; } - for(i=0; i best_dist) { + spawnpos[numpt] = pos; + best_dist = mindist; + } + } + + spawndir[numpt] = spawnpos[numpt]; + ++numpt; } return 0; diff --git a/src/mesh.c b/src/mesh.c index ce26e68..88c6edc 100644 --- a/src/mesh.c +++ b/src/mesh.c @@ -5,6 +5,18 @@ #include "mesh.h" #include "3dgfx.h" +void free_mesh(struct g3d_mesh *mesh) +{ + destroy_mesh(mesh); + free(mesh); +} + +void destroy_mesh(struct g3d_mesh *mesh) +{ + free(mesh->varr); + free(mesh->iarr); +} + static struct { int prim; struct g3d_vertex *varr; diff --git a/src/mesh.h b/src/mesh.h index e80c090..7744ae7 100644 --- a/src/mesh.h +++ b/src/mesh.h @@ -10,6 +10,9 @@ struct g3d_mesh { int vcount, icount; }; +void free_mesh(struct g3d_mesh *mesh); +void destroy_mesh(struct g3d_mesh *mesh); + int load_mesh(struct g3d_mesh *mesh, const char *fname); int save_mesh(struct g3d_mesh *mesh, const char *fname); diff --git a/src/tilemaze.c b/src/tilemaze.c index 1d413d9..7407bd4 100644 --- a/src/tilemaze.c +++ b/src/tilemaze.c @@ -1,6 +1,10 @@ +#include #include +#include #include "tilemaze.h" #include "mesh.h" +#include "treestor.h" +#include "dynarr.h" struct object { char *name; @@ -13,6 +17,7 @@ struct object { }; struct tile { + char *name; struct object *objlist; }; @@ -23,6 +28,7 @@ struct tilemaze { struct object *objects; }; +void free_object(struct object *obj); struct tilemaze *load_tilemaze(const char *fname) { @@ -31,7 +37,6 @@ struct tilemaze *load_tilemaze(const char *fname) if(!(tmz = calloc(sizeof *tmz, 1))) { return 0; } - /* TODO */ return tmz; } @@ -60,3 +65,92 @@ void update_tilemaze(struct tilemaze *tmz) void draw_tilemaze(struct tilemaze *tmz) { } + +struct tile *load_tileset(const char *fname, int *count) +{ + int i; + struct tile *tiles = 0, *tile; + struct ts_node *ts = 0, *node; + struct ts_attr *attr; + struct object *obj; + + if(!(ts = ts_load(fname))) { + fprintf(stderr, "load_tileset: failed to load: %s\n", fname); + goto err; + } + if(strcmp(ts->name, "tileset") != 0) { + fprintf(stderr, "load_tileset: %s is not a tileset file\n", fname); + goto err; + } + + if(!(tiles = dynarr_alloc(sizeof *tiles, 0))) { + fprintf(stderr, "load_tileset: failed to create tiles array\n"); + goto err; + } + + node = ts->child_list; + while(node) { + if(strcmp(node->name, "tile") != 0) { + fprintf(stderr, "load_tileset: skipping unexpected node %s in %s\n", node->name, fname); + node = node->next; + continue; + } + + if(!(tile = malloc(sizeof *tile))) { + fprintf(stderr, "load_tileset: failed to allocate tile\n"); + goto err; + } + if(!(tile->name = malloc(strlen(node->name) + 1))) { + fprintf(stderr, "load_tileset: failed to allocate tile name\n"); + free(tile); + goto err; + } + strcpy(tile->name, node->name); + tile->objlist = 0; + + attr = node->attr_list; + while(attr) { + /* + if(strcmp(attr->name, "scn") == 0) { + struct object *last; + if(!(obj = load_objlist(attr->value.str, &last))) { + free(tile); + goto err; + } + last->next = tile->objlist; + tile->objlist = obj; + } + */ + attr = attr->next; + } + + node = node->next; + } + +err: + if(tiles) { + for(i=0; inext; + free_object(obj); + } + } + dynarr_free(tiles); + } + if(ts) ts_free_tree(ts); + return 0; +} + +void free_object(struct object *obj) +{ + if(!obj) return; + + free(obj->name); + free(obj->texels); + destroy_mesh(&obj->mesh); + + free(obj); +} diff --git a/src/treestor.c b/src/treestor.c new file mode 100644 index 0000000..bad0ea7 --- /dev/null +++ b/src/treestor.c @@ -0,0 +1,748 @@ +#include +#include +#include +#include +#include "treestor.h" + +#ifdef WIN32 +#include +#else +#include +#endif + +struct ts_node *ts_text_load(FILE *fp); +int ts_text_save(struct ts_node *tree, FILE *fp); + +/* ---- ts_value implementation ---- */ + +int ts_init_value(struct ts_value *tsv) +{ + memset(tsv, 0, sizeof *tsv); + return 0; +} + +void ts_destroy_value(struct ts_value *tsv) +{ + int i; + + free(tsv->str); + free(tsv->vec); + + for(i=0; iarray_size; i++) { + ts_destroy_value(tsv->array + i); + } + free(tsv->array); +} + + +struct ts_value *ts_alloc_value(void) +{ + struct ts_value *v = malloc(sizeof *v); + if(!v || ts_init_value(v) == -1) { + free(v); + return 0; + } + return v; +} + +void ts_free_value(struct ts_value *tsv) +{ + ts_destroy_value(tsv); + free(tsv); +} + + +int ts_copy_value(struct ts_value *dest, struct ts_value *src) +{ + int i; + + if(dest == src) return 0; + + *dest = *src; + + dest->str = 0; + dest->vec = 0; + dest->array = 0; + + if(src->str) { + if(!(dest->str = malloc(strlen(src->str) + 1))) { + goto fail; + } + strcpy(dest->str, src->str); + } + if(src->vec && src->vec_size > 0) { + if(!(dest->vec = malloc(src->vec_size * sizeof *src->vec))) { + goto fail; + } + memcpy(dest->vec, src->vec, src->vec_size * sizeof *src->vec); + } + if(src->array && src->array_size > 0) { + if(!(dest->array = calloc(src->array_size, sizeof *src->array))) { + goto fail; + } + for(i=0; iarray_size; i++) { + if(ts_copy_value(dest->array + i, src->array + i) == -1) { + goto fail; + } + } + } + return 0; + +fail: + free(dest->str); + free(dest->vec); + if(dest->array) { + for(i=0; iarray_size; i++) { + ts_destroy_value(dest->array + i); + } + free(dest->array); + } + return -1; +} + +#define MAKE_NUMSTR_FUNC(type, fmt) \ + static char *make_##type##str(type x) \ + { \ + static char scrap[128]; \ + char *str; \ + int sz = snprintf(scrap, sizeof scrap, fmt, x); \ + if(!(str = malloc(sz + 1))) return 0; \ + sprintf(str, fmt, x); \ + return str; \ + } + +MAKE_NUMSTR_FUNC(int, "%d") +MAKE_NUMSTR_FUNC(float, "%g") + + +struct val_list_node { + struct ts_value val; + struct val_list_node *next; +}; + +int ts_set_value_str(struct ts_value *tsv, const char *str) +{ + char *endp; + + if(tsv->str) { + ts_destroy_value(tsv); + if(ts_init_value(tsv) == -1) { + return -1; + } + } + + tsv->type = TS_STRING; + if(!(tsv->str = malloc(strlen(str) + 1))) { + return -1; + } + strcpy(tsv->str, str); + +#if 0 + /* try to parse the string and see if it fits any of the value types */ + if(*str == '[' || *str == '{') { + /* try to parse as a vector */ + struct val_list_node *list = 0, *tail = 0, *node; + int nelem = 0; + char endsym = *str++ + 2; /* ']' is '[' + 2 and '}' is '{' + 2 */ + + while(*str && *str != endsym) { + float val = strtod(str, &endp); + if(endp == str || !(node = malloc(sizeof *node))) { + break; + } + ts_init_value(&node->val); + ts_set_valuef(&node->val, val); + node->next = 0; + + if(list) { + tail->next = node; + tail = node; + } else { + list = tail = node; + } + ++nelem; + str = endp; + } + + if(nelem && (tsv->array = malloc(nelem * sizeof *tsv->array)) && + (tsv->vec = malloc(nelem * sizeof *tsv->vec))) { + int idx = 0; + while(list) { + node = list; + list = list->next; + + tsv->array[idx] = node->val; + tsv->vec[idx] = node->val.fnum; + ++idx; + free(node); + } + tsv->type = TS_VECTOR; + } + + } else if((tsv->fnum = strtod(str, &endp)), endp != str) { + /* it's a number I guess... */ + tsv->type = TS_NUMBER; + } +#endif + + return 0; +} + +int ts_set_valuei_arr(struct ts_value *tsv, int count, const int *arr) +{ + int i; + + if(count < 1) return -1; + if(count == 1) { + if(!(tsv->str = make_intstr(*arr))) { + return -1; + } + + tsv->type = TS_NUMBER; + tsv->fnum = (float)*arr; + tsv->inum = *arr; + return 0; + } + + /* otherwise it's an array, we need to create the ts_value array, and + * the simplified vector + */ + if(!(tsv->vec = malloc(count * sizeof *tsv->vec))) { + return -1; + } + tsv->vec_size = count; + + for(i=0; ivec[i] = arr[i]; + } + + if(!(tsv->array = malloc(count * sizeof *tsv->array))) { + free(tsv->vec); + } + tsv->array_size = count; + + for(i=0; iarray + i); + ts_set_valuef(tsv->array + i, arr[i]); + } + + tsv->type = TS_VECTOR; + return 0; +} + +int ts_set_valueiv(struct ts_value *tsv, int count, ...) +{ + int res; + va_list ap; + va_start(ap, count); + res = ts_set_valueiv_va(tsv, count, ap); + va_end(ap); + return res; +} + +int ts_set_valueiv_va(struct ts_value *tsv, int count, va_list ap) +{ + int i, *vec; + + if(count < 1) return -1; + if(count == 1) { + int num = va_arg(ap, int); + ts_set_valuei(tsv, num); + return 0; + } + + vec = alloca(count * sizeof *vec); + for(i=0; istr = make_floatstr(*arr))) { + return -1; + } + + tsv->type = TS_NUMBER; + tsv->fnum = *arr; + tsv->inum = (int)*arr; + return 0; + } + + /* otherwise it's an array, we need to create the ts_value array, and + * the simplified vector + */ + if(!(tsv->vec = malloc(count * sizeof *tsv->vec))) { + return -1; + } + tsv->vec_size = count; + + for(i=0; ivec[i] = arr[i]; + } + + if(!(tsv->array = malloc(count * sizeof *tsv->array))) { + free(tsv->vec); + } + tsv->array_size = count; + + for(i=0; iarray + i); + ts_set_valuef(tsv->array + i, arr[i]); + } + + tsv->type = TS_VECTOR; + return 0; +} + +int ts_set_valuefv(struct ts_value *tsv, int count, ...) +{ + int res; + va_list ap; + va_start(ap, count); + res = ts_set_valuefv_va(tsv, count, ap); + va_end(ap); + return res; +} + +int ts_set_valuefv_va(struct ts_value *tsv, int count, va_list ap) +{ + int i; + float *vec; + + if(count < 1) return -1; + if(count == 1) { + float num = va_arg(ap, double); + ts_set_valuef(tsv, num); + return 0; + } + + vec = alloca(count * sizeof *vec); + for(i=0; iarray = malloc(count * sizeof *tsv->array))) { + return -1; + } + tsv->array_size = count; + + for(i=0; iarray + i, (struct ts_value*)arr + i) == -1) { + while(--i >= 0) { + ts_destroy_value(tsv->array + i); + } + free(tsv->array); + tsv->array = 0; + return -1; + } + } + + if(allnum) { + if(!(tsv->vec = malloc(count * sizeof *tsv->vec))) { + ts_destroy_value(tsv); + return -1; + } + tsv->type = TS_VECTOR; + + for(i=0; ivec[i] = tsv->array[i].fnum; + } + } else { + tsv->type = TS_ARRAY; + } + return 0; +} + +int ts_set_valuev(struct ts_value *tsv, int count, ...) +{ + int res; + va_list ap; + va_start(ap, count); + res = ts_set_valuev_va(tsv, count, ap); + va_end(ap); + return res; +} + +int ts_set_valuev_va(struct ts_value *tsv, int count, va_list ap) +{ + int i; + + if(count <= 1) return -1; + + if(!(tsv->array = malloc(count * sizeof *tsv->array))) { + return -1; + } + tsv->array_size = count; + + for(i=0; iarray + i, src) == -1) { + while(--i >= 0) { + ts_destroy_value(tsv->array + i); + } + free(tsv->array); + tsv->array = 0; + return -1; + } + } + return 0; +} + + +/* ---- ts_attr implementation ---- */ + +int ts_init_attr(struct ts_attr *attr) +{ + memset(attr, 0, sizeof *attr); + return ts_init_value(&attr->val); +} + +void ts_destroy_attr(struct ts_attr *attr) +{ + free(attr->name); + ts_destroy_value(&attr->val); +} + +struct ts_attr *ts_alloc_attr(void) +{ + struct ts_attr *attr = malloc(sizeof *attr); + if(!attr || ts_init_attr(attr) == -1) { + free(attr); + return 0; + } + return attr; +} + +void ts_free_attr(struct ts_attr *attr) +{ + ts_destroy_attr(attr); + free(attr); +} + +int ts_copy_attr(struct ts_attr *dest, struct ts_attr *src) +{ + if(dest == src) return 0; + + if(ts_set_attr_name(dest, src->name) == -1) { + return -1; + } + + if(ts_copy_value(&dest->val, &src->val) == -1) { + ts_destroy_attr(dest); + return -1; + } + return 0; +} + +int ts_set_attr_name(struct ts_attr *attr, const char *name) +{ + char *n = malloc(strlen(name) + 1); + if(!n) return -1; + strcpy(n, name); + + free(attr->name); + attr->name = n; + return 0; +} + + +/* ---- ts_node implementation ---- */ + +int ts_init_node(struct ts_node *node) +{ + memset(node, 0, sizeof *node); + return 0; +} + +void ts_destroy_node(struct ts_node *node) +{ + if(!node) return; + + free(node->name); + + while(node->attr_list) { + struct ts_attr *attr = node->attr_list; + node->attr_list = node->attr_list->next; + ts_free_attr(attr); + } +} + +struct ts_node *ts_alloc_node(void) +{ + struct ts_node *node = malloc(sizeof *node); + if(!node || ts_init_node(node) == -1) { + free(node); + return 0; + } + return node; +} + +void ts_free_node(struct ts_node *node) +{ + ts_destroy_node(node); + free(node); +} + +void ts_free_tree(struct ts_node *tree) +{ + if(!tree) return; + + while(tree->child_list) { + struct ts_node *child = tree->child_list; + tree->child_list = tree->child_list->next; + ts_free_tree(child); + } + + ts_free_node(tree); +} + +void ts_add_attr(struct ts_node *node, struct ts_attr *attr) +{ + attr->next = 0; + if(node->attr_list) { + node->attr_tail->next = attr; + node->attr_tail = attr; + } else { + node->attr_list = node->attr_tail = attr; + } +} + +struct ts_attr *ts_get_attr(struct ts_node *node, const char *name) +{ + struct ts_attr *attr = node->attr_list; + while(attr) { + if(strcmp(attr->name, name) == 0) { + return attr; + } + attr = attr->next; + } + return 0; +} + +const char *ts_get_attr_str(struct ts_node *node, const char *aname, const char *def_val) +{ + struct ts_attr *attr = ts_get_attr(node, aname); + if(!attr || !attr->val.str) { + return def_val; + } + return attr->val.str; +} + +float ts_get_attr_num(struct ts_node *node, const char *aname, float def_val) +{ + struct ts_attr *attr = ts_get_attr(node, aname); + if(!attr || attr->val.type != TS_NUMBER) { + return def_val; + } + return attr->val.fnum; +} + +int ts_get_attr_int(struct ts_node *node, const char *aname, int def_val) +{ + struct ts_attr *attr = ts_get_attr(node, aname); + if(!attr || attr->val.type != TS_NUMBER) { + return def_val; + } + return attr->val.inum; +} + +float *ts_get_attr_vec(struct ts_node *node, const char *aname, float *def_val) +{ + struct ts_attr *attr = ts_get_attr(node, aname); + if(!attr || !attr->val.vec) { + return def_val; + } + return attr->val.vec; +} + +struct ts_value *ts_get_attr_array(struct ts_node *node, const char *aname, struct ts_value *def_val) +{ + struct ts_attr *attr = ts_get_attr(node, aname); + if(!attr || !attr->val.array) { + return def_val; + } + return attr->val.array; +} + +void ts_add_child(struct ts_node *node, struct ts_node *child) +{ + if(child->parent) { + if(child->parent == node) return; + ts_remove_child(child->parent, child); + } + child->parent = node; + child->next = 0; + + if(node->child_list) { + node->child_tail->next = child; + node->child_tail = child; + } else { + node->child_list = node->child_tail = child; + } +} + +int ts_remove_child(struct ts_node *node, struct ts_node *child) +{ + struct ts_node dummy, *iter = &dummy; + dummy.next = node->child_list; + + while(iter->next && iter->next != child) { + iter = iter->next; + } + if(!iter->next) { + return -1; + } + + child->parent = 0; + + iter->next = child->next; + if(!iter->next) { + node->child_tail = iter; + } + node->child_list = dummy.next; + return 0; +} + +struct ts_node *ts_get_child(struct ts_node *node, const char *name) +{ + struct ts_node *res = node->child_list; + while(res) { + if(strcmp(res->name, name) == 0) { + return res; + } + res = res->next; + } + return 0; +} + +struct ts_node *ts_load(const char *fname) +{ + FILE *fp; + struct ts_node *root; + + if(!(fp = fopen(fname, "rb"))) { + fprintf(stderr, "ts_load: failed to open file: %s: %s\n", fname, strerror(errno)); + return 0; + } + + root = ts_text_load(fp); + fclose(fp); + return root; +} + +int ts_save(struct ts_node *tree, const char *fname) +{ + FILE *fp; + int res; + + if(!(fp = fopen(fname, "wb"))) { + fprintf(stderr, "ts_save: failed to open file: %s: %s\n", fname, strerror(errno)); + return 0; + } + res = ts_text_save(tree, fp); + fclose(fp); + return res; +} + +static const char *pathtok(const char *path, char *tok) +{ + int len; + const char *dot = strchr(path, '.'); + if(!dot) { + strcpy(tok, path); + return 0; + } + + len = dot - path; + memcpy(tok, path, len); + tok[len] = 0; + return dot + 1; +} + +struct ts_attr *ts_lookup(struct ts_node *node, const char *path) +{ + char *name = alloca(strlen(path) + 1); + + if(!node) return 0; + + if(!(path = pathtok(path, name)) || strcmp(name, node->name) != 0) { + return 0; + } + + while((path = pathtok(path, name)) && (node = ts_get_child(node, name))); + + if(path || !node) return 0; + return ts_get_attr(node, name); +} + +const char *ts_lookup_str(struct ts_node *root, const char *path, const char *def_val) +{ + struct ts_attr *attr = ts_lookup(root, path); + if(!attr || !attr->val.str) { + return def_val; + } + return attr->val.str; +} + +float ts_lookup_num(struct ts_node *root, const char *path, float def_val) +{ + struct ts_attr *attr = ts_lookup(root, path); + if(!attr || attr->val.type != TS_NUMBER) { + return def_val; + } + return attr->val.fnum; +} + +int ts_lookup_int(struct ts_node *root, const char *path, int def_val) +{ + struct ts_attr *attr = ts_lookup(root, path); + if(!attr || attr->val.type != TS_NUMBER) { + return def_val; + } + return attr->val.inum; +} + +float *ts_lookup_vec(struct ts_node *root, const char *path, float *def_val) +{ + struct ts_attr *attr = ts_lookup(root, path); + if(!attr || !attr->val.vec) { + return def_val; + } + return attr->val.vec; +} + +struct ts_value *ts_lookup_array(struct ts_node *node, const char *path, struct ts_value *def_val) +{ + struct ts_attr *attr = ts_lookup(node, path); + if(!attr || !attr->val.array) { + return def_val; + } + return attr->val.array; +} diff --git a/src/treestor.h b/src/treestor.h new file mode 100644 index 0000000..2251f1f --- /dev/null +++ b/src/treestor.h @@ -0,0 +1,145 @@ +#ifndef TREESTORE_H_ +#define TREESTORE_H_ + +#include + +#ifdef __cplusplus +#define TS_DEFVAL(x) =(x) +extern "C" { +#else +#define TS_DEFVAL(x) +#endif + +enum ts_value_type { TS_STRING, TS_NUMBER, TS_VECTOR, TS_ARRAY }; + +/** treestore node attribute value */ +struct ts_value { + enum ts_value_type type; + + char *str; /**< string values will have this set */ + int inum; /**< numeric values will have this set */ + float fnum; /**< numeric values will have this set */ + + /** vector values (arrays containing ONLY numbers) will have this set */ + float *vec; /**< elements of the vector */ + int vec_size; /**< size of the vector (in elements), same as array_size */ + + /** array values (including vectors) will have this set */ + struct ts_value *array; /**< elements of the array */ + int array_size; /**< size of the array (in elements) */ +}; + +int ts_init_value(struct ts_value *tsv); +void ts_destroy_value(struct ts_value *tsv); + +struct ts_value *ts_alloc_value(void); /**< also calls ts_init_value */ +void ts_free_value(struct ts_value *tsv); /**< also calls ts_destroy_value */ + +/** perform a deep-copy of a ts_value */ +int ts_copy_value(struct ts_value *dest, struct ts_value *src); + +/** set a ts_value as a string */ +int ts_set_value_str(struct ts_value *tsv, const char *str); + +/** set a ts_value from a list of integers */ +int ts_set_valuei_arr(struct ts_value *tsv, int count, const int *arr); +int ts_set_valueiv(struct ts_value *tsv, int count, ...); +int ts_set_valueiv_va(struct ts_value *tsv, int count, va_list ap); +int ts_set_valuei(struct ts_value *tsv, int inum); /**< equiv: ts_set_valueiv(val, 1, inum) */ + +/** set a ts_value from a list of floats */ +int ts_set_valuef_arr(struct ts_value *tsv, int count, const float *arr); +int ts_set_valuefv(struct ts_value *tsv, int count, ...); +int ts_set_valuefv_va(struct ts_value *tsv, int count, va_list ap); +int ts_set_valuef(struct ts_value *tsv, float fnum); /**< equiv: ts_set_valuefv(val, 1, fnum) */ + +/** set a ts_value from a list of ts_value pointers. they are deep-copied as per ts_copy_value */ +int ts_set_value_arr(struct ts_value *tsv, int count, const struct ts_value *arr); +int ts_set_valuev(struct ts_value *tsv, int count, ...); +int ts_set_valuev_va(struct ts_value *tsv, int count, va_list ap); + + +/** treestore node attribute */ +struct ts_attr { + char *name; + struct ts_value val; + + struct ts_attr *next; +}; + +int ts_init_attr(struct ts_attr *attr); +void ts_destroy_attr(struct ts_attr *attr); + +struct ts_attr *ts_alloc_attr(void); /**< also calls ts_init_attr */ +void ts_free_attr(struct ts_attr *attr); /**< also calls ts_destroy_attr */ + +/** perform a deep-copy of a ts_attr */ +int ts_copy_attr(struct ts_attr *dest, struct ts_attr *src); + +int ts_set_attr_name(struct ts_attr *attr, const char *name); + + + +/** treestore node */ +struct ts_node { + char *name; + + int attr_count; + struct ts_attr *attr_list, *attr_tail; + + int child_count; + struct ts_node *child_list, *child_tail; + struct ts_node *parent; + + struct ts_node *next; /* next sibling */ +}; + +int ts_init_node(struct ts_node *node); +void ts_destroy_node(struct ts_node *node); + +struct ts_node *ts_alloc_node(void); /**< also calls ts_init_node */ +void ts_free_node(struct ts_node *n); /**< also calls ts_destroy_node */ + +/** recursively destroy all the nodes of the tree */ +void ts_free_tree(struct ts_node *tree); + +void ts_add_attr(struct ts_node *node, struct ts_attr *attr); +struct ts_attr *ts_get_attr(struct ts_node *node, const char *name); + +const char *ts_get_attr_str(struct ts_node *node, const char *aname, + const char *def_val TS_DEFVAL(0)); +float ts_get_attr_num(struct ts_node *node, const char *aname, + float def_val TS_DEFVAL(0.0f)); +int ts_get_attr_int(struct ts_node *node, const char *aname, + int def_val TS_DEFVAL(0.0f)); +float *ts_get_attr_vec(struct ts_node *node, const char *aname, + float *def_val TS_DEFVAL(0)); +struct ts_value *ts_get_attr_array(struct ts_node *node, const char *aname, + struct ts_value *def_val TS_DEFVAL(0)); + + +void ts_add_child(struct ts_node *node, struct ts_node *child); +int ts_remove_child(struct ts_node *node, struct ts_node *child); +struct ts_node *ts_get_child(struct ts_node *node, const char *name); + +struct ts_node *ts_load(const char *fname); +int ts_save(struct ts_node *tree, const char *fname); + +struct ts_attr *ts_lookup(struct ts_node *root, const char *path); +const char *ts_lookup_str(struct ts_node *root, const char *path, + const char *def_val TS_DEFVAL(0)); +float ts_lookup_num(struct ts_node *root, const char *path, + float def_val TS_DEFVAL(0.0f)); +int ts_lookup_int(struct ts_node *root, const char *path, + int def_val TS_DEFVAL(0)); +float *ts_lookup_vec(struct ts_node *root, const char *path, + float *def_val TS_DEFVAL(0)); +struct ts_value *ts_lookup_array(struct ts_node *root, const char *path, + struct ts_value *def_val TS_DEFVAL(0)); + + +#ifdef __cplusplus +} +#endif + +#endif /* TREESTORE_H_ */ diff --git a/src/ts_text.c b/src/ts_text.c new file mode 100644 index 0000000..347c28c --- /dev/null +++ b/src/ts_text.c @@ -0,0 +1,361 @@ +#include +#include +#include +#include +#include "treestor.h" +#include "dynarr.h" + +struct parser { + FILE *fp; + int nline; + char *token; +}; + +enum { TOK_SYM, TOK_ID, TOK_NUM, TOK_STR }; + +static struct ts_node *read_node(struct parser *pstate); +static int read_array(struct parser *pstate, struct ts_value *tsv, char endsym); +static int next_token(struct parser *pstate); + +static void print_attr(struct ts_attr *attr, FILE *fp, int level); +static void print_value(struct ts_value *value, FILE *fp); +static int tree_level(struct ts_node *n); +static const char *indent(int x); +static const char *toktypestr(int type); + +#define EXPECT(type) \ + do { \ + if(next_token(pst) != (type)) { \ + fprintf(stderr, "expected %s token\n", toktypestr(type)); \ + goto err; \ + } \ + } while(0) + +#define EXPECT_SYM(c) \ + do { \ + if(next_token(pst) != TOK_SYM || pst->token[0] != (c)) { \ + fprintf(stderr, "expected symbol: %c\n", c); \ + goto err; \ + } \ + } while(0) + + +struct ts_node *ts_text_load(FILE *fp) +{ + char *root_name; + struct parser pstate, *pst = &pstate; + struct ts_node *node = 0; + + pstate.fp = fp; + pstate.nline = 0; + if(!(pstate.token = dynarr_alloc(0, 1))) { + perror("failed to allocate token string"); + return 0; + } + + EXPECT(TOK_ID); + if(!(root_name = strdup(pst->token))) { + perror("failed to allocate root node name"); + dynarr_free(pst->token); + return 0; + } + EXPECT_SYM('{'); + if(!(node = read_node(pst))) { + dynarr_free(pst->token); + return 0; + } + node->name = root_name; + +err: + dynarr_free(pst->token); + return node; +} + +static int read_value(struct parser *pst, int toktype, struct ts_value *val) +{ + switch(toktype) { + case TOK_NUM: + ts_set_valuef(val, atof(pst->token)); + break; + + case TOK_SYM: + if(pst->token[0] == '[' || pst->token[0] == '{') { + char endsym = pst->token[0] + 2; /* end symbol is dist 2 from either '[' or '{' */ + if(read_array(pst, val, endsym) == -1) { + return -1; + } + } else { + fprintf(stderr, "read_node: unexpected rhs symbol: %c\n", pst->token[0]); + } + break; + + case TOK_ID: + case TOK_STR: + default: + ts_set_value_str(val, pst->token); + } + + return 0; +} + +static struct ts_node *read_node(struct parser *pst) +{ + int type; + struct ts_node *node; + + if(!(node = ts_alloc_node())) { + perror("failed to allocate treestore node"); + return 0; + } + + while((type = next_token(pst)) == TOK_ID) { + char *id; + + if(!(id = strdup(pst->token))) { + goto err; + } + + EXPECT(TOK_SYM); + + if(pst->token[0] == '=') { + /* attribute */ + struct ts_attr *attr; + int type; + + if(!(attr = ts_alloc_attr())) { + goto err; + } + + if((type = next_token(pst)) == -1) { + ts_free_attr(attr); + fprintf(stderr, "read_node: unexpected EOF\n"); + goto err; + } + + if(read_value(pst, type, &attr->val) == -1) { + ts_free_attr(attr); + fprintf(stderr, "failed to read value\n"); + goto err; + } + attr->name = id; + ts_add_attr(node, attr); + + } else if(pst->token[0] == '{') { + /* child */ + struct ts_node *child; + + if(!(child = read_node(pst))) { + ts_free_node(node); + return 0; + } + + child->name = id; + ts_add_child(node, child); + + } else { + fprintf(stderr, "unexpected token: %s\n", pst->token); + goto err; + } + } + + if(type != TOK_SYM || pst->token[0] != '}') { + fprintf(stderr, "expected closing brace\n"); + goto err; + } + return node; + +err: + fprintf(stderr, "treestore read_node failed\n"); + ts_free_node(node); + return 0; +} + +static int read_array(struct parser *pst, struct ts_value *tsv, char endsym) +{ + int type; + struct ts_value values[32]; + int i, nval = 0; + int res; + + while((type = next_token(pst)) != -1) { + ts_init_value(values + nval); + if(read_value(pst, type, values + nval) == -1) { + return -1; + } + if(nval < 31) { + ++nval; + } else { + ts_destroy_value(values + nval); + } + + type = next_token(pst); + if(!(type == TOK_SYM && (pst->token[0] == ',' || pst->token[0] == endsym))) { + fprintf(stderr, "read_array: expected comma or end symbol ('%c')\n", endsym); + return -1; + } + if(pst->token[0] == endsym) { + break; /* we're done */ + } + } + + if(!nval) { + return -1; + } + + res = ts_set_value_arr(tsv, nval, values); + + for(i=0; itoken); + + // skip whitespace + while((c = fgetc(pst->fp)) != -1) { + if(c == '#') { // skip to end of line + while((c = fgetc(pst->fp)) != -1 && c != '\n'); + if(c == -1) return -1; + } + if(!isspace(c)) break; + if(c == '\n') ++pst->nline; + } + if(c == -1) return -1; + + DYNARR_STRPUSH(pst->token, c); + + if(isdigit(c) || c == '-' || c == '+') { + // token is a number + int found_dot = 0; + while((c = fgetc(pst->fp)) != -1 && + (isdigit(c) || (c == '.' && !found_dot))) { + DYNARR_STRPUSH(pst->token, c); + if(c == '.') found_dot = 1; + } + if(c != -1) ungetc(c, pst->fp); + return TOK_NUM; + } + if(isalpha(c)) { + // token is an identifier + while((c = fgetc(pst->fp)) != -1 && (isalnum(c) || c == '_')) { + DYNARR_STRPUSH(pst->token, c); + } + if(c != -1) ungetc(c, pst->fp); + return TOK_ID; + } + if(c == '"') { + // token is a string constant + // remove the opening quote + DYNARR_STRPOP(pst->token); + while((c = fgetc(pst->fp)) != -1 && c != '"') { + DYNARR_STRPUSH(pst->token, c); + if(c == '\n') ++pst->nline; + } + if(c != '"') { + return -1; + } + return TOK_STR; + } + return TOK_SYM; +} + +int ts_text_save(struct ts_node *tree, FILE *fp) +{ + struct ts_node *c; + struct ts_attr *attr; + int lvl = tree_level(tree); + + fprintf(fp, "%s%s {\n", indent(lvl), tree->name); + + attr = tree->attr_list; + while(attr) { + print_attr(attr, fp, lvl); + attr = attr->next; + } + + c = tree->child_list; + while(c) { + ts_text_save(c, fp); + c = c->next; + } + + fprintf(fp, "%s}\n", indent(lvl)); + return 0; +} + +static void print_attr(struct ts_attr *attr, FILE *fp, int level) +{ + fprintf(fp, "%s%s = ", indent(level + 1), attr->name); + print_value(&attr->val, fp); + fputc('\n', fp); +} + +static void print_value(struct ts_value *value, FILE *fp) +{ + int i; + + switch(value->type) { + case TS_NUMBER: + fprintf(fp, "%g", value->fnum); + break; + + case TS_VECTOR: + fputc('[', fp); + for(i=0; ivec_size; i++) { + if(i == 0) { + fprintf(fp, "%g", value->vec[i]); + } else { + fprintf(fp, ", %g", value->vec[i]); + } + } + fputc(']', fp); + break; + + case TS_ARRAY: + fputc('[', fp); + for(i=0; iarray_size; i++) { + if(i > 0) { + fprintf(fp, ", "); + } + print_value(value->array + i, fp); + } + fputc(']', fp); + break; + + default: + fprintf(fp, "\"%s\"", value->str); + } +} + +static int tree_level(struct ts_node *n) +{ + if(!n->parent) return 0; + return tree_level(n->parent) + 1; +} + +static const char *indent(int x) +{ + static const char buf[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"; + const char *end = buf + sizeof buf - 1; + return x > sizeof buf - 1 ? buf : end - x; +} + +static const char *toktypestr(int type) +{ + switch(type) { + case TOK_ID: + return "identifier"; + case TOK_NUM: + return "number"; + case TOK_STR: + return "string"; + case TOK_SYM: + return "symbol"; + } + return "unknown"; +} -- 1.7.10.4