exchange

mustach-json-c.c (6948B)

---

 /*
  Author: José Bollo <jobol@nonadev.net>
 
  https://gitlab.com/jobol/mustach
 
  SPDX-License-Identifier: ISC
 */
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
 #include <stdio.h>
 #include <string.h>
 
 #include "mustach.h"
 #include "mustach-wrap.h"
 #include "mustach-json-c.h"
 
 struct expl {
 	struct json_object *root;
 	struct json_object *selection;
 	int depth;
 	struct {
 		struct json_object *cont;
 		struct json_object *obj;
 		struct json_object_iterator iter;
 		struct json_object_iterator enditer;
 		int is_objiter;
 		int index, count;
 	} stack[MUSTACH_MAX_DEPTH];
 };
 
 static int start(void *closure)
 {
 	struct expl *e = closure;
 	e->depth = 0;
 	e->selection = NULL;
 	e->stack[0].cont = NULL;
 	e->stack[0].obj = e->root;
 	e->stack[0].index = 0;
 	e->stack[0].count = 1;
 	return MUSTACH_OK;
 }
 
 static int compare(void *closure, const char *value)
 {
 	struct expl *e = closure;
 	struct json_object *o = e->selection;
 	double d;
 	int64_t i;
 
 	switch (json_object_get_type(o)) {
 	case json_type_double:
 		d = json_object_get_double(o) - atof(value);
 		return d < 0 ? -1 : d > 0 ? 1 : 0;
 	case json_type_int:
 		i = json_object_get_int64(o) - (int64_t)atoll(value);
 		return i < 0 ? -1 : i > 0 ? 1 : 0;
 	default:
 		return strcmp(json_object_get_string(o), value);
 	}
 }
 
 static int sel(void *closure, const char *name)
 {
 	struct expl *e = closure;
 	struct json_object *o;
 	int i, r;
 
 	if (name == NULL) {
 		o = e->stack[e->depth].obj;
 		r = 1;
 	} else {
 		i = e->depth;
 		while (i >= 0 && !json_object_object_get_ex(e->stack[i].obj, name, &o))
 			i--;
 		if (i >= 0)
 			r = 1;
 		else {
 			o = NULL;
 			r = 0;
 		}
 	}
 	e->selection = o;
 	return r;
 }
 
 static int subsel(void *closure, const char *name)
 {
 	struct expl *e = closure;
 	struct json_object *o = NULL;
 	int r = 0;
 
 	if (json_object_is_type(e->selection, json_type_object))
 		r = json_object_object_get_ex(e->selection, name, &o);
 	else if (json_object_is_type(e->selection, json_type_array)) {
 		char *end;
 		size_t idx = (size_t)strtol(name, &end, 10);
 		if (!*end && idx < json_object_array_length(e->selection)) {
 			o = json_object_array_get_idx(e->selection, idx);
 			r = 1;
 		}
 	}
 	if (r)
 		e->selection = o;
 	return r;
 }
 
 static int enter(void *closure, int objiter)
 {
 	struct expl *e = closure;
 	struct json_object *o;
 
 	if (++e->depth >= MUSTACH_MAX_DEPTH)
 		return MUSTACH_ERROR_TOO_DEEP;
 
 	o = e->selection;
 	e->stack[e->depth].is_objiter = 0;
 	if (objiter) {
 		if (!json_object_is_type(o, json_type_object))
 			goto not_entering;
 
 		e->stack[e->depth].iter = json_object_iter_begin(o);
 		e->stack[e->depth].enditer = json_object_iter_end(o);
 		if (json_object_iter_equal(&e->stack[e->depth].iter, &e->stack[e->depth].enditer))
 			goto not_entering;
 		e->stack[e->depth].obj = json_object_iter_peek_value(&e->stack[e->depth].iter);
 		e->stack[e->depth].cont = o;
 		e->stack[e->depth].is_objiter = 1;
 	} else if (json_object_is_type(o, json_type_array)) {
 		e->stack[e->depth].count = json_object_array_length(o);
 		if (e->stack[e->depth].count == 0)
 			goto not_entering;
 		e->stack[e->depth].cont = o;
 		e->stack[e->depth].obj = json_object_array_get_idx(o, 0);
 		e->stack[e->depth].index = 0;
 	} else if ((json_object_is_type(o, json_type_object) && json_object_object_length(o) > 0)
 		|| json_object_get_boolean(o)) {
 		e->stack[e->depth].count = 1;
 		e->stack[e->depth].cont = NULL;
 		e->stack[e->depth].obj = o;
 		e->stack[e->depth].index = 0;
 	} else
 		goto not_entering;
 	return 1;
 
 not_entering:
 	e->depth--;
 	return 0;
 }
 
 static int next(void *closure)
 {
 	struct expl *e = closure;
 
 	if (e->depth <= 0)
 		return MUSTACH_ERROR_CLOSING;
 
 	if (e->stack[e->depth].is_objiter) {
 		json_object_iter_next(&e->stack[e->depth].iter);
 		if (json_object_iter_equal(&e->stack[e->depth].iter, &e->stack[e->depth].enditer))
 			return 0;
 		e->stack[e->depth].obj = json_object_iter_peek_value(&e->stack[e->depth].iter);
 		return 1;
 	}
 
 	e->stack[e->depth].index++;
 	if (e->stack[e->depth].index >= e->stack[e->depth].count)
 		return 0;
 
 	e->stack[e->depth].obj = json_object_array_get_idx(e->stack[e->depth].cont, e->stack[e->depth].index);
 	return 1;
 }
 
 static int leave(void *closure)
 {
 	struct expl *e = closure;
 
 	if (e->depth <= 0)
 		return MUSTACH_ERROR_CLOSING;
 
 	e->depth--;
 	return 0;
 }
 
 static int get(void *closure, struct mustach_sbuf *sbuf, int key)
 {
 	struct expl *e = closure;
 	const char *s;
 	int d;
 
 	if (key) {
 		s = "";
 		for (d = e->depth ; d >= 0 ; d--)
 			if (e->stack[d].is_objiter) {
 				s = json_object_iter_peek_name(&e->stack[d].iter);
 				break;
 			}
 	}
 	else
 		switch (json_object_get_type(e->selection)) {
 		case json_type_string:
 			s = json_object_get_string(e->selection);
 			break;
 		case json_type_null:
 			s = "";
 			break;
 		default:
 			s = json_object_to_json_string_ext(e->selection, 0);
 			break;
 		}
 	sbuf->value = s;
 	return 1;
 }
 
 const struct mustach_wrap_itf mustach_json_c_wrap_itf = {
 	.start = start,
 	.stop = NULL,
 	.compare = compare,
 	.sel = sel,
 	.subsel = subsel,
 	.enter = enter,
 	.next = next,
 	.leave = leave,
 	.get = get
 };
 
 int mustach_json_c_file(const char *template, size_t length, struct json_object *root, int flags, FILE *file)
 {
 	struct expl e;
 	e.root = root;
 	return mustach_wrap_file(template, length, &mustach_json_c_wrap_itf, &e, flags, file);
 }
 
 int mustach_json_c_fd(const char *template, size_t length, struct json_object *root, int flags, int fd)
 {
 	struct expl e;
 	e.root = root;
 	return mustach_wrap_fd(template, length, &mustach_json_c_wrap_itf, &e, flags, fd);
 }
 
 int mustach_json_c_mem(const char *template, size_t length, struct json_object *root, int flags, char **result, size_t *size)
 {
 	struct expl e;
 	e.root = root;
 	return mustach_wrap_mem(template, length, &mustach_json_c_wrap_itf, &e, flags, result, size);
 }
 
 int mustach_json_c_write(const char *template, size_t length, struct json_object *root, int flags, mustach_write_cb_t *writecb, void *closure)
 {
 	struct expl e;
 	e.root = root;
 	return mustach_wrap_write(template, length, &mustach_json_c_wrap_itf, &e, flags, writecb, closure);
 }
 
 int mustach_json_c_emit(const char *template, size_t length, struct json_object *root, int flags, mustach_emit_cb_t *emitcb, void *closure)
 {
 	struct expl e;
 	e.root = root;
 	return mustach_wrap_emit(template, length, &mustach_json_c_wrap_itf, &e, flags, emitcb, closure);
 }
 
 int fmustach_json_c(const char *template, struct json_object *root, FILE *file)
 {
 	return mustach_json_c_file(template, 0, root, -1, file);
 }
 
 int fdmustach_json_c(const char *template, struct json_object *root, int fd)
 {
 	return mustach_json_c_fd(template, 0, root, -1, fd);
 }
 
 int mustach_json_c(const char *template, struct json_object *root, char **result, size_t *size)
 {
 	return mustach_json_c_mem(template, 0, root, -1, result, size);
 }
 
 int umustach_json_c(const char *template, struct json_object *root, mustach_write_cb_t *writecb, void *closure)
 {
 	return mustach_json_c_write(template, 0, root, -1, writecb, closure);
 }