// build JSON object hierarchy
JSON * JSON::parse_private(Lexer *lexer)
{
// check token to determine what JSON type to construct
Json_Token token = lexer->get_token();
switch (token)
{
case Object_start_token:
return parse_object(lexer);
case Array_start_token:
return parse_array(lexer);
case String_token:
return new_string(lexer->token_src, lexer->token_len);
case Null_token:
return new_null();
case True_token:
return new_boolean(true);
case False_token:
return new_boolean(false);
case Float_token:
return new_float(lexer->float_num);
case Unsigned_token:
return new_unsigned(lexer->unsigned_num);
case Signed_token:
return new_signed(lexer->signed_num);
default:
Serial.println(F("JSON syntax error"));
}
return null;
}
bool test_equal()
{
symbol *s[3];
integer *i[3];
boolean *b[3];
s[0] = new_symbol("foo");
s[1] = new_symbol("bar");
s[2] = new_symbol("foo");
i[0] = new_integer(0);
i[1] = new_integer(1);
i[2] = new_integer(0);
b[0] = new_boolean(true);
b[1] = new_boolean(false);
b[2] = new_boolean(true);
assert(generic_equal(s[0], s[0]) == true);
assert(generic_equal(s[0], s[1]) == false);
assert(generic_equal(s[0], s[2]) == true);
assert(generic_equal(i[0], i[0]) == true);
assert(generic_equal(i[0], i[1]) == false);
assert(generic_equal(i[0], i[2]) == true);
assert(generic_equal(b[0], b[0]) == true);
assert(generic_equal(b[0], b[1]) == false);
assert(generic_equal(b[0], b[2]) == true);
assert(generic_equal(b[0], s[0]) == false);
assert(generic_equal(b[0], i[1]) == false);
assert(generic_equal(s[0], b[1]) == false);
return true;
}
value_t value_identity_compare_cycle_protect(value_t a, value_t b,
cycle_detector_t *detector) {
// First check that they even belong to the same domain. Values can be equal
// across domains.
value_domain_t a_domain = get_value_domain(a);
value_domain_t b_domain = get_value_domain(b);
if (a_domain != b_domain)
return no();
// Then dispatch to the domain equals functions.
switch (a_domain) {
case vdInteger:
case vdCustomTagged:
return new_boolean(is_same_value(a, b));
case vdHeapObject:
return heap_object_identity_compare(a, b, detector);
default:
return no();
}
}
static value_t default_heap_heap_object_identity_compare(value_t a, value_t b,
cycle_detector_t *detector) {
return new_boolean(is_same_value(a, b));
}
// Parses any expression.
struct ParseResult parse(const char *text) {
struct ParseResult result;
result.err_type = PARSE_SUCCESS;
const char *s = text;
s += skip_whitespace(s);
size_t len;
switch (*s) {
case '\0':
result.err_type = ERR_UNEXPECTED_EOI;
break;
case '(':
s++;
result = parse_pair(s);
s += result.chars_read;
break;
case ')':
result.err_type = ERR_UNEXPECTED_RPAREN;
break;
case '.':
result.err_type = ERR_INVALID_DOT;
break;
case '#':
len = skip_symbol(s + 1);
if (len == 1 && s[1] == 't') {
s += 2;
result.expr = new_boolean(true);
} else if (len == 1 && s[1] == 'f') {
s += 2;
result.expr = new_boolean(false);
} else if (len > 2 && s[1] == '\\') {
char c = parse_char_name(s + 2, len - 1);
if (c == '\0') {
s += 2;
result.err_type = ERR_UNKNOWN_CHARACTER;
} else {
s += 1 + len;
result.expr = new_character(c);
}
} else if (s[1] == '\\' && s[2] && !isspace(s[2])) {
result.expr = new_character(s[2]);
s += 3;
} else {
result.err_type = ERR_INVALID_LITERAL;
}
break;
case '\'':
s++;
result = parse(s);
s += result.chars_read;
if (result.err_type == PARSE_SUCCESS) {
result.expr = new_pair(
new_stdmacro(F_QUOTE),
new_pair(result.expr, new_null()));
}
break;
case '`':
s++;
result = parse(s);
s += result.chars_read;
if (result.err_type == PARSE_SUCCESS) {
result.expr = new_pair(
new_stdmacro(F_QUASIQUOTE),
new_pair(result.expr, new_null()));
}
break;
case ',':
s++;
enum StandardMacro stdmacro = F_UNQUOTE;
if (*s == '@') {
s++;
stdmacro = F_UNQUOTE_SPLICING;
}
result = parse(s);
s += result.chars_read;
if (result.err_type == PARSE_SUCCESS) {
result.expr = new_pair(
new_stdmacro(stdmacro),
new_pair(result.expr, new_null()));
}
break;
case '"':
s++;
len = skip_string(s);
if (!(s[len-1] == '\\' && (len < 2 || s[len-2] == '\\'))
&& s[len] == '"') {
result.expr = parse_string(s, len);
} else {
result.err_type = ERR_UNEXPECTED_EOI;
}
s += len;
s++;
break;
default:;
len = skip_symbol(s);
assert(len > 0);
Number number;
if (parse_number(s, len, &number)) {
result.expr = new_number(number);
} else {
InternId symbol_id = intern_string_n(s, len);
result.expr = new_symbol(symbol_id);
}
s += len;
break;
}
if (result.err_type == PARSE_SUCCESS) {
s += skip_whitespace(s);
assert(s > text);
}
result.chars_read = (size_t)(s - text);
return result;
}
