chibipub

json.c (11130B)

---

 
 #include "cursor.h"
 #include "json.h"
 #include "parse.h"
 #include "util.h"
 
 #include <assert.h>
 #include <ctype.h>
 
 void init_json_strtok(struct json_strtok *s)
 {
 	memset(s, 0, sizeof(*s));
 }
 
 void init_json_pusher_with(struct json_pusher *p, struct cursor *out)
 {
 	memset(p, 0, sizeof(*p));
 	init_errors(&p->errs);
 	copy_cursor(out, &p->cur);
 }
 
 void init_json_pusher(struct json_pusher *p, unsigned char *buf, size_t size)
 {
 	memset(p, 0, sizeof(*p));
 	init_errors(&p->errs);
 	make_cursor(buf, buf+size, &p->cur);
 }
 
 void init_json_handlers(struct json_handlers *h)
 {
 	memset(h, 0, sizeof(*h));
 }
 
 static void consume_whitespace(struct cursor *cur)
 {
 	for (; cur->p < cur->end; cur->p++) {
 		if (!isspace(*cur->p))
 			return;
 	}
 }
 
 static int pull_utf8_cont(struct cursor *cur, unsigned char *c)
 {
 	if (!pull_byte(cur, c)) {
 		return 0;
 	}
 
 	if ((*c & 0xC0) != 0x80) {
 		return 0;
 	}
 
 	*c = *c & 0x3F;
 
 	return 1;
 }
 
 static int parse_utf8_char(struct cursor *cur, unsigned int *chr)
 {
 	unsigned char c[4];
 
 	if (!pull_byte(cur, &c[0])) {
 		return 0;
 	}
 
 	if ((c[0] & 0x80) == 0) {
 		*chr = c[0];
 		return 1;
 	}
 
 	if ((c[0] & 0xE0) == 0xC0) {
 		if (!pull_utf8_cont(cur, &c[1])) {
 			return 0;
 		}
 		if (c[1] >= 0) {
 			*chr = ((c[0] & 0x1F) << 6) | c[1];
 			if (*chr >= 128) {
 				return 1;
 			}
 		}
 	} else if ((c[0] & 0xF0) == 0xE0) {
 		if (!(pull_utf8_cont(cur, &c[1]) &&
                       pull_utf8_cont(cur, &c[2]))) {
 			return 0;
 		}
 		if ((c[1] | c[2]) >= 0) {
 			*chr = ((c[0] & 0x0F) << 12) | (c[1] << 6) | c[2];
 			if (*chr >= 2048 && (*chr < 55296 || *chr > 57343)) {
 				return 1;
 			}
 		}
 	} else if ((c[0] & 0xF8) == 0xF0) {
 		if (!(pull_utf8_cont(cur, &c[1]) &&
                       pull_utf8_cont(cur, &c[2]) &&
 		      pull_utf8_cont(cur, &c[3]))) {
 			return 0;
 		}
 		if ((c[1] | c[2] | c[3]) >= 0) {
 			*chr = ((c[0] & 0x08) << 18) | (c[1] << 12)
 			                             | (c[2] << 6) | c[3];
 			if (*chr >= 65536 && *chr <= 1114111) {
 				return 1;
 			}
 		}
 	}
 
 	return 0;
 }
 
 static inline int parse_escape(struct json_parser *p)
 {
 	p->cur.p++;
 	return 1;
 }
 
 static int parse_string_with(struct json_parser *p, int is_key)
 {
 	char c;
 	unsigned int chr;
 	unsigned char *start;
 	struct json_strtok str;
 	c = 0;
 	chr = 0;
 
 	init_json_strtok(&str);
 
 	start = p->cur.p;
 
 	if (!parse_char(&p->cur, &c, '"')) {
 		note_error(&p->errs, "expected '\"', got '%c'", c);
 		return 0;
 	}
 
 	while (1) {
 		if (!parse_utf8_char(&p->cur, &chr)) {
 			note_error(&p->errs, "invalid utf-8 codepoint");
 			break;
 		}
 
 		if (chr == '"') {
 			str.text = start+1;
 			str.size = p->cur.p - start - 2;
 			str.is_key = is_key;
 
 			return (*p->handlers.string)(&p->handlers, &str);
 		}
 
 		if (chr == '\\' && !parse_escape(p)) {
 			note_error(&p->errs, "invalid escape char '%c'", c);
 			break;
 		}
 	}
 
 	p->cur.p = start;
 	return 0;
 }
 
 static int inline parse_string(struct json_parser *p)
 {
 	return parse_string_with(p, 0);
 }
 
 static int inline parse_key(struct json_parser *p)
 {
 	return parse_string_with(p, 1);
 }
 
 static int parse_digits(struct json_parser *p, unsigned int *out)
 {
 	char c;
 
 	if (!peek_char(&p->cur, &c)) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	if (c < '1' || c > '9') {
 		note_error(&p->errs, "expected 1-9, got '%c'", c);
 		return 0;
 	}
 
 	for (*out = 0; p->cur.p < p->cur.end; p->cur.p++) {
 		c = *p->cur.p;
 
 		if (c < '0' || c > '9') {
 			return 1;
 		}
 
 		*out = 10*(*out) + (c-'0');
 	}
 
 	note_error(&p->errs, "oob");
 	return 0;
 }
 
 static int parse_fraction(struct json_parser *p)
 {
 	note_error(&p->errs, "floating point numbers not supported");
 	return 0;
 	/*
 	if (!peek_char(&p->cur, &c)) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	if (c !== '.') {
 		p->cur.p++;
 	} else (parse_digits(p)) {
 	}
 	*/
 }
 
 static int parse_number(struct json_parser *p)
 {
 	char c;
 	int sign = 1;
 	unsigned int digits;
 
 	if (!peek_char(&p->cur, &c)) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	if (c == '-') {
 		sign = -1;
 		p->cur.p++;
 		if (!peek_char(&p->cur, &c)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 	}
 
 	if (c == '0') {
 		p->cur.p++;
 		if (!peek_char(&p->cur, &c)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 		if (c != '.' && (c < '0' || c > '9')) {
 			/* just a 0 */
 			return (*p->handlers.number)(&p->handlers, 0);
 		}
 		return parse_fraction(p);
 	} else if (c >= '1' && c <= '9') {
 		if (!parse_digits(p, &digits)) {
 			note_error(&p->errs, "digits");
 			return 0;
 		}
 
 		/* @generalize */
 		return (*p->handlers.number)(&p->handlers, digits * sign);
 	} else {
 		note_error(&p->errs, "expected '-', '0' or '1-9', got '%c'", c)
 		return 0;
 	}
 
 	note_error(&p->errs, "impossibru");
 	return 0;
 }
 
 static int parse_value(struct json_parser *p);
 
 static int parse_kv(struct json_parser *p)
 {
 	char c;
 	unsigned int *len;
 	c = 0;
 
 	if (!parse_key(p)) {
 		note_error(&p->errs, "key");
 		return 0;
 	}
 
 	consume_whitespace(&p->cur);
 
 	if (!parse_char(&p->cur, &c, ':')) {
 		note_error(&p->errs, "expected ':', got %c", c);
 		return 0;
 	}
 
 	if (!(*p->handlers.token)(&p->handlers, ':', &len)) {
 		note_error(&p->errs, "':' handler");
 		return 0;
 	}
 
 	return parse_value(p);
 }
 
 
 static int parse_object(struct json_parser *p)
 {
 	char c;
 	unsigned int *len;
 	c = 0;
 
 	if (!parse_char(&p->cur, &c, '{')) {
 		note_error(&p->errs, "expected '{' got '%c'", c);
 		return 0;
 	}
 
 	if (!(*p->handlers.token)(&p->handlers, '{', &len)) {
 		note_error(&p->errs, "obj handle open", c);
 		return 0;
 	}
 
 	while(1) {
 		consume_whitespace(&p->cur);
 
 		if (!peek_char(&p->cur, &c)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 
 		if (c == '}') {
 			p->cur.p++;
 			if (!(*p->handlers.token)(&p->handlers, '}', &len)) {
 				note_error(&p->errs, "'}' handler 1");
 				return 0;
 			}
 			return 1;
 		}
 
 		if (c != '"') {
 			note_error(&p->errs, "expected '\"' or '}', got '%c'", c);
 			return 0;
 		}
 
 		if (!parse_kv(p)) {
 			note_error(&p->errs, "expected key value pair");
 			return 0;
 		}
 
 		if (!peek_char(&p->cur, &c)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 
 		if (c == ',') {
 			if (!(*p->handlers.token)(&p->handlers, ',', &len)) {
 				note_error(&p->errs, "',' handler");
 				return 0;
 			}
 			p->cur.p++;
 			continue;
 		}
 
 		if (c == '}') {
 			p->cur.p++;
 			if (!(*p->handlers.token)(&p->handlers, '}', &len)) {
 				note_error(&p->errs, "'}' handler 2");
 				return 0;
 			}
 			return 1;
 		}
 
 		note_error(&p->errs, "expected ',' or '}', got '%c'", c);
 		return 0;
 	}
 
 	note_error(&p->errs, "impossibru");
 	return 0;
 }
 
 static int parse_array(struct json_parser *p)
 {
 	char c;
 	unsigned int *len;
 
 	c = 0;
 
 	if (!parse_char(&p->cur, &c, '[')) {
 		note_error(&p->errs, "expected '[', got '%c'", c);
 		return 0;
 	}
 
 	if (!(*p->handlers.token)(&p->handlers, '[', &len)) {
 		note_error(&p->errs, "array handle open", c);
 		return 0;
 	}
 
 	consume_whitespace(&p->cur);
 
 	/* empty array case */
 	if (!peek_char(&p->cur, &c)) {
 		note_error(&p->errs, "empty array peek oob");
 		return 0;
 	}
 
 	if (c == ']') {
 		p->cur.p++;
 		return (*p->handlers.token)(&p->handlers, ']', &len);
 	}
 
 	while(1) {
 		if (!parse_value(p)) {
 			note_error(&p->errs, "expected json value");
 			return 0;
 		}
 
 		if (!peek_char(&p->cur, &c)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 
 		if (c == ']') {
 			p->cur.p++;
 			return (*p->handlers.token)(&p->handlers, ']', &len);
 		}
 
 		if (c != ',') {
 			note_error(&p->errs, "expected ',', got '%c'", c);
 			return 0;
 		}
 
 		if (!(*p->handlers.token)(&p->handlers, ',', &len)) {
 			note_error(&p->errs, "']' handler");
 			return 0;
 		}
 
 		p->cur.p++;
 	}
 
 	return 0;
 }
 
 static inline int parse_bool(struct json_parser *p)
 {
 	if (parse_str(&p->cur, "true")) {
 		return (*p->handlers.boolean)(&p->handlers, 1);
 	}
 
 	if (parse_str(&p->cur, "false")) {
 		return (*p->handlers.boolean)(&p->handlers, 0);
 	}
 
 	return 0;
 }
 
 static int parse_null(struct json_parser *p)
 {
 	if (!parse_str(&p->cur, "null")) {
 		note_error(&p->errs, "not null");
 		return 0;
 	}
 
 	return (*p->handlers.null)(&p->handlers);
 }
 
 static int parse_value(struct json_parser *p)
 {
 	int res;
 
 	consume_whitespace(&p->cur);
 
 	p->errs.record = 0;
 
 	res = parse_string(p) ||
 	      parse_object(p) ||
 	      parse_number(p) ||
 	      parse_array(p)  ||
 	      parse_bool(p)   ||
 	      parse_null(p);
 
 	p->errs.record = 1;
 
 	if (!res) {
 		print_around(&p->cur, 20);
 		note_error(&p->errs, "couldn't parse json value");
 		return 0;
 	}
 
 	consume_whitespace(&p->cur);
 
 	return res;
 }
 
 
 static int parse_array_or_object(struct json_parser *p)
 {
 	char c;
 	consume_whitespace(&p->cur);
 
 	if (!peek_char(&p->cur, &c)) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	if (c == '{') {
 		return parse_object(p);
 	}
 
 	if (c == '[') {
 		return parse_array(p);
 	}
 
 	note_error(&p->errs, "expected '{' or '[', got '%c'", c);
 	return 0;
 }
 
 
 void copy_json_handlers(struct json_handlers *src, struct json_handlers *dst)
 {
 	dst->data = src->data;
 	dst->string = src->string;
 	dst->boolean = src->boolean;
 	dst->null = src->null;
 	dst->number = src->number;
 	dst->token = src->token;
 }
 
 int push_escaped(struct cursor *cur, unsigned char *text, int size)
 {
 	unsigned char *p;
 	for (p = text; p < text+size; p++) {
 		if (*p == '"') {
 			if (!push_str(cur, "\\\""))
 				return 0;
 			continue;
 		}
 
 		if (!push_byte(cur, *p)) {
 			return 0;
 		}
 	}
 
 	return 1;
 }
 
 int handle_string(struct json_handlers *h, struct json_strtok *str)
 {
 	struct json_pusher *p = (struct json_pusher*)h->data;
 
 	if (!push_byte(&p->cur, '"')) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	if (str->needs_escape) {
 		if (!push_escaped(&p->cur, str->text, str->size)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 	} else {
 		if (!push_data(&p->cur, str->text, str->size)) {
 			note_error(&p->errs, "oob");
 			return 0;
 		}
 	}
 
 	if (!push_byte(&p->cur, '"')) {
 		note_error(&p->errs, "oob");
 		return 0;
 	}
 
 	return 1;
 }
 
 int handle_bool(struct json_handlers *h, int val)
 {
 	struct json_pusher *p = (struct json_pusher*)h->data;
 	return push_str(&p->cur, val? "true" : "false");
 }
 
 int handle_null(struct json_handlers *h)
 {
 	struct json_pusher *p = (struct json_pusher*)h->data;
 	return push_data(&p->cur, (unsigned char*)"null", 4);
 }
 
 int handle_number(struct json_handlers *h, unsigned int number)
 {
 	struct json_pusher *p = (struct json_pusher*)h->data;
 	static char digits[16];
 	int c;
 
 	c = snprintf(digits, sizeof(digits), "%d", number);
 	return push_data(&p->cur, (unsigned char*)digits, c);
 }
 
 int handle_token(struct json_handlers *h, char token, unsigned int **len)
 {
 	struct json_pusher *p = (struct json_pusher*)h->data;
 	return push_byte(&p->cur, token);
 }
 
 void make_compact_handlers(struct json_handlers *h, struct json_pusher *out)
 {
 	h->data = out;
 	h->string = handle_string;
 	h->boolean = handle_bool;
 	h->null = handle_null;
 	h->number = handle_number;
 	h->token = handle_token;
 }
 
 void init_json_parser(struct json_parser *p, unsigned char *buf, size_t buf_size,
 		struct json_handlers *h)
 {
 	memset(p, 0, sizeof(*p));
 	make_cursor(buf, buf + buf_size, &p->cur);
 	init_errors(&p->errs);
 	copy_json_handlers(h, &p->handlers);
 }
 
 int parse_json(struct json_parser *p)
 {
 	return parse_array_or_object(p);
 }