chibipub

ubjson.c (11006B)

---

 
 #include "ubjson.h"
 #include "json.h"
 #include "parse.h"
 
 #include <assert.h>
 
 static inline int push_ubjson_null(struct cursor *ubjson)
 {
 	return push_byte(ubjson, 'Z');
 }
 
 static inline int is_number_tag(unsigned char tag)
 {
 	return tag == 'U' || tag == 'l' || tag == 'I' || tag == 'L' || tag == 'i';
 }
 
 static int parse_ubjson_sized_len(struct ubjson *ubjson, unsigned int *len, unsigned int *size)
 {
 	unsigned char byte;
 	unsigned short u16;
 	unsigned char *start;
 
 	start = ubjson->cur.p;
 
 	if (!pull_byte(&ubjson->cur, &byte)) {
 		note_error(&ubjson->errs, "oob");
 		return 0;
 	} else if (byte == 'U' || byte == 'i') {
 		if (!pull_byte(&ubjson->cur, &byte)) {
 			note_error(&ubjson->errs, "pull byte after u8 int");
 		} else {
 			if (size)
 				*size = 1;
 			*len = byte;
 			return 1;
 		}
 	} else if (byte == 'I') {
 		if (!pull_data(&ubjson->cur, (unsigned char*)&u16, sizeof(u16))) {
 			note_error(&ubjson->errs, "pull byte after u16 int");
 		} else {
 			if (size)
 				*size = 2;
 			*len = u16;
 			return 1;
 		}
 	} else if (byte == 'l' || byte == 'L') {
 		if (!pull_int(&ubjson->cur, (int*)len)) {
 			note_error(&ubjson->errs, "pull byte after u16 int");
 		} else {
 			if (size)
 				*size = 4;
 			return 1;
 		}
 	} else {
 		note_error(&ubjson->errs, "unhandled number tag '%c'", byte);
 	}
 
 	ubjson->cur.p = start;
 	return 0;
 }
 
 static inline int parse_ubjson_len(struct ubjson *ubjson, unsigned int *len)
 {
 	return parse_ubjson_sized_len(ubjson, len, NULL);
 }
 
 static int parse_ubjson_string(struct ubjson *ubjson, struct json *val)
 {
 	char byte;
 	byte = 0;
 
 	if (!parse_char(&ubjson->cur, &byte, 'S')) {
 		note_error(&ubjson->errs, "expected S tag, got '%c'", byte);
 		return 0;
 	}
 
 	if (!parse_ubjson_len(ubjson, &val->len)) {
 		note_error(&ubjson->errs, "size");
 		return 0;
 	}
 
 	val->type = JSON_STRING;
 	val->string = (char*)ubjson->cur.p;
 
 	ubjson->cur.p += val->len;
 
 	return 1;
 }
 
 static inline int push_ubjson_close(struct cursor *ubjson, unsigned int *len, char end)
 {
 	*len = ubjson->p + 1 - ((unsigned char*)len)-4;
 	return push_byte(ubjson, end);
 }
 
 static int push_ubjson_open(struct cursor *ubjson, char typ, unsigned int **len)
 {
 	if (!push_byte(ubjson, typ))
 		return 0;
 
 	if (!push_byte(ubjson, 'l'))
 		return 0;
 
 	/* fill this in later */
 	*len = (unsigned int *)ubjson->p;
 
 	if (!push_int(ubjson, 0))
 		return 0;
 
 	return 1;
 }
 
 static int push_ubjson_num(struct cursor *ubjson, unsigned int len)
 {
 	if (len <= 0xFF) {
 		if (!push_byte(ubjson, 'U')) {
 			return 0;
 		}
 		if (!push_byte(ubjson, (unsigned char)len)) {
 			return 0;
 		}
 	} else if (len <= 0xFFFF) {
 		if (!push_byte(ubjson, 'I')) {
 			return 0;
 		}
 		/* TODO: big-endian push */
 		if (!push_u16(ubjson, (unsigned int)len)) {
 			return 0;
 		}
 	} else {
 		if (!push_byte(ubjson, 'l')) {
 			return 0;
 		}
 		/* TODO: big-endian push */
 		if (!push_int(ubjson, len)) {
 			return 0;
 		}
 	}
 	return 1;
 }
 
 static inline int is_escape_char(char c)
 {
 	return c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' ||
 		c == 'n' || c == 'r' || c == 't';
 }
 
 static int count_skipped(unsigned char *text, int size)
 {
 	unsigned char *p;
 	int skipped = 0;
 
 	for (p = text; p < text+size; p++) {
 		if (*p == '\\' && (p+1 < text+size) && is_escape_char(*(p+1))) {
 			p++;
 			skipped++;
 		}
 	}
 
 	return skipped;
 }
 
 static char escaped_char(char c)
 {
 	switch (c) {
 		case 'n': return '\n';
 		case 't': return '\t';
 		case 'r': return '\r';
 		case 'b': return '\b';
 		case 'f': return '\f';
 	}
 	return c;
 }
 
 static int push_unescaped(struct cursor *cur, unsigned char *text, int size)
 {
 	unsigned char *p;
 	unsigned char c;
 
 	for (p = text; p < text+size; p++) {
 		if (*p == '\\' && (p+1 < text+size) && is_escape_char(*(p+1))) {
 			p++;
 			c = (unsigned char)escaped_char((char)*p);
 		} else {
 			c = *p;
 		}
 
 		if (!push_byte(cur, c)) {
 			return 0;
 		}
 	}
 
 	return 1;
 }
 
 
 static int push_ubjson_str(struct cursor *ubjson, unsigned char *text,
 		unsigned int size)
 {
 	int skipped;
 
 	if (!push_byte(ubjson, 'S')) {
 		return 0;
 	}
 
 	skipped = count_skipped(text, size);
 
 	if (!push_ubjson_num(ubjson, size-skipped)) {
 		return 0;
 	}
 
 	if (!push_unescaped(ubjson, text, size)) {
 		return 0;
 	}
 
 	return 1;
 }
 
 static inline int valid_ubjson_tag(char c)
 {
 	return c == 'S' ||
 	       c == '{' ||
 	       c == '[' ||
 	       c == 'T' ||
 	       c == 'F' ||
 	       c == 'Z' || is_number_tag(c);
 }
 
 static inline void copy_ubjson(struct ubjson *src, struct ubjson *dst) {
 	copy_cursor(&src->cur, &dst->cur);
 	copy_errors(&src->errs, &dst->errs);
 	dst->data_end = src->data_end;
 }
 
 static int parse_ubjson_container(struct ubjson *ubjson, struct json *val, char token)
 {
 	char c;
 	c = 0;
 
 	val->type = JSON_OBJECT;
 	assert(ubjson != &val->container);
 	copy_ubjson(ubjson, &val->container);
 
 	if (!parse_char(&ubjson->cur, &c, token)) {
 		note_error(&ubjson->errs, "expected '{' tag, got '%c'", c);
 		return 0;
 	}
 
 	if (!parse_ubjson_len(ubjson, &val->len)) {
 		/* reset */
 		ubjson->cur.p = val->container.cur.p;
 		note_error(&ubjson->errs, "object len");
 		return 0;
 	}
 
 	if (ubjson->cur.p + val->len >= ubjson->data_end) {
 		/* reset */
 		ubjson->cur.p = val->container.cur.p;
 		note_error(&ubjson->errs, "invalid len %d", val->len);
 		return 0;
 	}
 
 	ubjson->cur.p += val->len;
 
 	return 1;
 }
 
 static inline int parse_ubjson_object(struct ubjson *ubjson, struct json *val)
 {
 	return parse_ubjson_container(ubjson, val, '{');
 }
 
 static inline int parse_ubjson_array(struct ubjson *ubjson, struct json *val)
 {
 	return parse_ubjson_container(ubjson, val, '[');
 }
 
 static int parse_ubjson_number(struct ubjson *ubjson, struct json *val)
 {
 	if (!parse_ubjson_sized_len(ubjson, &val->number_int, &val->len)) {
 		note_error(&ubjson->errs, "");
 		return 0;
 	}
 
 	val->type = JSON_NUMBER_INT;
 	return 1;
 }
 
 static int parse_ubjson_bool(struct ubjson *ubjson, struct json *val)
 {
 	unsigned char byte;
 	if (!pull_byte(&ubjson->cur, &byte)) {
 		note_error(&ubjson->errs, "pull byte oob");
 		return 0;
 	}
 
 	if (byte != 'T' && byte != 'F') {
 		note_error(&ubjson->errs, "invalid bool tag: '%c'", byte);
 		return 0;
 	}
 
 	val->type = JSON_BOOL;
 	val->len = 0;
 	val->boolean = byte == 'T';
 	return 1;
 }
 
 int parse_ubjson_value(struct ubjson *ubjson, struct json *val)
 {
 	char tag;
 	assert(&ubjson->cur != &val->container.cur);
 	if (!peek_char(&ubjson->cur, &tag)) {
 		note_error(&ubjson->errs, "peek value tag oob");
 		return 0;
 	}
 
 	if (tag == 'Z') {
 		val->type = JSON_NULL;
 		ubjson->cur.p++;
 		return 1;
 	} else if (tag == 'S') {
 		return parse_ubjson_string(ubjson, val);
 	} else if (tag == '{') {
 		return parse_ubjson_object(ubjson, val);
 	} else if (tag == '[') {
 		return parse_ubjson_array(ubjson, val);
 	} else if (is_number_tag(tag)) {
 		return parse_ubjson_number(ubjson, val);
 	} else if (tag == 'F' || tag == 'T') {
 		return parse_ubjson_bool(ubjson, val);
 	}
 
 	note_error(&ubjson->errs, "unhandled type '%c'", tag);
 	return 0;
 }
 
 static int ubjson_obj_lookup(struct ubjson *ubjson, const char *path, struct json *val)
 {
 	char byte;
 	unsigned int len;
 	struct json blackhole;
 	byte = 0;
 	assert(&ubjson->cur != &val->container.cur);
 
 	if (!parse_char(&ubjson->cur, &byte, '{')) {
 		note_error(&ubjson->errs, "no object tag, got '%c'", byte);
 		return 0;
 	}
 
 	if (!parse_ubjson_len(ubjson, &len)) {
 		note_error(&ubjson->errs, "object size");
 		return 0;
 	}
 
 	while (1) {
 		if (!peek_char(&ubjson->cur, &byte)) {
 			note_error(&ubjson->errs, "oob");
 			break;
 		}
 
 		if (byte == '}') {
 			note_error(&ubjson->errs, "not found")
 			break;
 		}
 
 		if (!parse_ubjson_string(ubjson, val)) {
 			note_error(&ubjson->errs, "string");
 			break;
 		}
 
 		if (strlen(path) != val->len ||
 		    memcmp(path, val->string, val->len)) {
 			/* skip over value */
 			if (!parse_ubjson_value(ubjson, &blackhole)) {
 				note_error(&ubjson->errs, "skip value");
 				return 0;
 			}
 
 			continue;
 		}
 
 		return parse_ubjson_value(ubjson, val);
 	}
 
 	note_error(&ubjson->errs, "not found");
 	ubjson->cur.p = ubjson->cur.start;
 	return 0;
 }
 
 int ubjson_lookup(struct ubjson *ubjson, const char **path, int path_len, struct json *val)
 {
 	int i;
 	const char *seg;
 	char byte;
 	struct ubjson next;
 
 	byte = 0;
 	copy_ubjson(ubjson, &next);
 
 	for (i = 0; i < path_len; i++) {
 		seg = path[i];
 
 		if (!ubjson_obj_lookup(&next, seg, val)) {
 			note_error(&ubjson->errs, "lookup path segment: '%s'", seg);
 			return 0;
 		}
 
 		/* not at the last segment and don't have an object or array */
 		if (i != path_len-1 && val->type != JSON_OBJECT) {
 			note_error(&ubjson->errs,
 			    "segment '%s' not an object, got '%c'", seg, byte);
 			return 0;
 		} else if (val->type == JSON_OBJECT) {
 			copy_ubjson(&val->container, &next);
 		}
 	}
 
 	return 1;
 }
 
 
 static inline int handle_ubjson_str(struct json_handlers *h, struct json_strtok *str)
 {
 	return push_ubjson_str((struct cursor*)h->data, str->text, str->size);
 }
 
 static inline int handle_ubjson_bool(struct json_handlers *h, int val)
 {
 	return push_byte((struct cursor*)h->data, val ? 'T' : 'F');
 }
 
 static inline int handle_ubjson_null(struct json_handlers *h)
 {
 	return push_ubjson_null((struct cursor*)h->data);
 }
 
 static inline int handle_ubjson_number(struct json_handlers *h, unsigned int num)
 {
 	return push_ubjson_num((struct cursor*)h->data, num);
 }
 
 static inline int handle_ubjson_open(struct json_handlers *h, char type, unsigned int **len)
 {
 	return push_ubjson_open((struct cursor*)h->data, type, len);
 }
 
 static inline int handle_ubjson_close(struct json_handlers *h, char type, unsigned int *len)
 {
 	return push_ubjson_close((struct cursor*)h->data, len, type);
 }
 
 static int handle_ubjson_token(struct json_handlers *h, char token, unsigned int **len)
 {
 	if (token == '{' || token == '[')
 		return handle_ubjson_open(h, token, len);
 	else if (token == '}' || token == ']')
 		return handle_ubjson_close(h, token, *len);
 	else
 		return 1;
 }
 
 void make_ubjson_handlers(struct json_handlers *h, struct cursor *ubjson)
 {
 	h->data = (void*)ubjson;
 
 	h->string = handle_ubjson_str;
 	h->boolean = handle_ubjson_bool;
 	h->null = handle_ubjson_null;
 	h->number = handle_ubjson_number;
 	h->token = handle_ubjson_token;
 }
 
 int parse_ubjson(unsigned char *buf, size_t buf_size, struct ubjson *out)
 {
 	struct json_parser p;
 	struct json_handlers h;
 	int ok;
 
 	make_ubjson_handlers(&h, &out->cur);
 
 	init_json_parser(&p, buf, buf_size, &h);
 	ok = parse_json(&p);
 
 	out->data_end = out->cur.p;
 	out->cur.p = out->cur.start;
 
 	return ok;
 }
 
 void init_ubjson(struct ubjson *ubjson, unsigned char *buf, size_t bufsize)
 {
 	make_cursor(buf, buf + bufsize, &ubjson->cur);
 	init_errors(&ubjson->errs);
 }
 
 void print_value(struct json *val)
 {
 	switch (val->type) {
 	case JSON_STRING:
 		printf("%.*s", val->len, val->string);
 		return;
 	case JSON_NULL:
 		printf("null");
 		return;
 	case JSON_NUMBER_INT:
 		printf("%d", val->number_int);
 		return;
 	case JSON_NUMBER:
 		printf("%f", val->number);
 		return;
 	case JSON_BOOL:
 		printf("%s", val->boolean? "true" : "false");
 		return;
 	default:
 		printf("implement print %d", val->type);
 	}
 }