From 84ea129f26e46a0e38dd630f6d02cad41b983808 Mon Sep 17 00:00:00 2001 From: Stephen Dolan Date: Mon, 17 Sep 2012 19:41:41 +0100 Subject: Better support for appending strings in JV. --- c/jv.c | 59 ++++++++++++++++++++++++++++++++++++++++++++--------------- c/jv.h | 2 ++ c/testdata | 4 ++-- 3 files changed, 48 insertions(+), 17 deletions(-) diff --git a/c/jv.c b/c/jv.c index 786e7b26..595484e7 100644 --- a/c/jv.c +++ b/c/jv.c @@ -340,6 +340,7 @@ typedef struct { // high 31 bits are length, low bit is a flag // indicating whether hash has been computed. uint32_t length_hashed; + uint32_t alloc_length; char data[]; } jvp_string; @@ -350,19 +351,19 @@ static jvp_string* jvp_string_ptr(jv_complex* a) { static jvp_string* jvp_string_alloc(uint32_t size) { jvp_string* s = malloc(sizeof(jvp_string) + size + 1); s->refcnt.count = 1; - s->length_hashed = size << 1; + s->alloc_length = size; return s; } static jv_complex jvp_string_new(const char* data, uint32_t length) { jvp_string* s = jvp_string_alloc(length); + s->length_hashed = length << 1; memcpy(s->data, data, length); s->data[length] = 0; jv_complex r = {&s->refcnt, {0,0}}; return r; } - static void jvp_string_free(jv_complex* s) { if (jvp_refcnt_dec(s)) { jvp_string* str = jvp_string_ptr(s); @@ -385,16 +386,37 @@ static uint32_t jvp_string_length(jvp_string* s) { return s->length_hashed >> 1; } -static jv_complex jvp_string_concat(jvp_string* a, jvp_string* b) { - uint32_t la = jvp_string_length(a), lb = jvp_string_length(b); - jvp_string* s = jvp_string_alloc(la + lb); - memcpy(s->data, a->data, la); - memcpy(s->data + la, b->data, lb); - s->data[la + lb] = 0; - jv_complex r = {&s->refcnt, {0,0}}; +static uint32_t jvp_string_remaining_space(jvp_string* s) { + uint32_t r = s->alloc_length - jvp_string_length(s); + assert(r >= 0); return r; } +static void jvp_string_append(jv_complex* string, const char* data, uint32_t len) { + jvp_string* s = jvp_string_ptr(string); + uint32_t currlen = jvp_string_length(s); + + if (jvp_refcnt_unshared(string) && + jvp_string_remaining_space(s) >= len) { + // the next string fits at the end of a + memcpy(s->data + currlen, data, len); + s->data[currlen + len] = 0; + s->length_hashed = (currlen + len) << 1; + } else { + // allocate a bigger buffer and copy + uint32_t allocsz = (currlen + len) * 2; + if (allocsz < 32) allocsz = 32; + jvp_string* news = jvp_string_alloc(allocsz); + news->length_hashed = (currlen + len) << 1; + memcpy(news->data, s->data, currlen); + memcpy(news->data + currlen, data, len); + news->data[currlen + len] = 0; + jvp_string_free(string); + jv_complex r = {&news->refcnt, {0,0}}; + *string = r; + } +} + static const uint32_t HASH_SEED = 0x432A9843; static uint32_t rotl32 (uint32_t x, int8_t r){ @@ -507,15 +529,22 @@ const char* jv_string_value(jv j) { } jv jv_string_concat(jv a, jv b) { - jv j; - j.kind = JV_KIND_STRING; - j.val.complex = jvp_string_concat(jvp_string_ptr(&a.val.complex), - jvp_string_ptr(&b.val.complex)); - jv_free(a); + jvp_string* sb = jvp_string_ptr(&b.val.complex); + jvp_string_append(&a.val.complex, sb->data, jvp_string_length(sb)); jv_free(b); - return j; + return a; } +jv jv_string_append_buf(jv a, const char* buf, int len) { + jvp_string_append(&a.val.complex, buf, len); + return a; +} + +jv jv_string_append_str(jv a, const char* str) { + return jv_string_append_buf(a, str, strlen(str)); +} + + jv jv_string_fmt(const char* fmt, ...) { int size = 1024; while (1) { diff --git a/c/jv.h b/c/jv.h index ec23262c..295369e8 100644 --- a/c/jv.h +++ b/c/jv.h @@ -80,6 +80,8 @@ uint32_t jv_string_hash(jv); const char* jv_string_value(jv); jv jv_string_concat(jv, jv); jv jv_string_fmt(const char*, ...); +jv jv_string_append_buf(jv a, const char* buf, int len); +jv jv_string_append_str(jv a, const char* str); jv jv_object(); jv jv_object_get(jv object, jv key); diff --git a/c/testdata b/c/testdata index e17f2bb7..c0afbeae 100644 --- a/c/testdata +++ b/c/testdata @@ -159,9 +159,9 @@ null "asdfasdf" {"a":1, "b":2, "c":3} -"asdf" + "jkl;" + . +"asdf" + "jkl;" + . + . + . "some string" -"asdfjkl;some string" +"asdfjkl;some stringsome stringsome string" "\u0000\u0020\u0000" + . "\u0000\u0020\u0000" -- cgit v1.2.3 From 9c15ad20218cdc03fb825773d6ea40b04c756471 Mon Sep 17 00:00:00 2001 From: Stephen Dolan Date: Mon, 17 Sep 2012 20:08:55 +0100 Subject: Support rendering a JSON value to a string buffer. --- c/jv.c | 1 - c/jv.h | 3 +- c/jv_print.c | 146 ++++++++++++++++++++++++++++++++++++++++------------------- c/main.c | 5 ++ 4 files changed, 106 insertions(+), 49 deletions(-) diff --git a/c/jv.c b/c/jv.c index 595484e7..51070636 100644 --- a/c/jv.c +++ b/c/jv.c @@ -544,7 +544,6 @@ jv jv_string_append_str(jv a, const char* str) { return jv_string_append_buf(a, str, strlen(str)); } - jv jv_string_fmt(const char* fmt, ...) { int size = 1024; while (1) { diff --git a/c/jv.h b/c/jv.h index 295369e8..e67d614a 100644 --- a/c/jv.h +++ b/c/jv.h @@ -105,7 +105,8 @@ jv jv_object_iter_value(jv, int); int jv_get_refcnt(jv); enum { JV_PRINT_PRETTY = 1, JV_PRINT_ASCII = 2 }; -void jv_dump(jv, int); +void jv_dump(jv, int flags); +jv jv_dump_string(jv, int flags); jv jv_parse(const char* string); jv jv_parse_sized(const char* string, int length); diff --git a/c/jv_print.c b/c/jv_print.c index f1ec92fb..64bf178a 100644 --- a/c/jv_print.c +++ b/c/jv_print.c @@ -1,47 +1,70 @@ #include "jv.h" #include #include -#include +#include #include "jv_dtoa.h" #include "jv_unicode.h" -static void jv_dump_string(jv str, int ascii_only) { +static void put_buf(const char* s, int len, FILE* fout, jv* strout) { + if (strout) { + *strout = jv_string_append_buf(*strout, s, len); + } else { + fwrite(s, 1, len, fout); + } +} + +static void put_char(char c, FILE* fout, jv* strout) { + put_buf(&c, 1, fout, strout); +} + +static void put_str(const char* s, FILE* fout, jv* strout) { + put_buf(s, strlen(s), fout, strout); +} + +static void put_space(int n, FILE* fout, jv* strout) { + while (n--) { + put_char(' ', fout, strout); + } +} + +static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) { assert(jv_get_kind(str) == JV_KIND_STRING); const char* i = jv_string_value(str); const char* end = i + jv_string_length(jv_copy(str)); int c = 0; + char buf[32]; while ((i = jvp_utf8_next(i, end, &c))) { assert(c != -1); int unicode_escape = 0; if (0x20 <= c && c <= 0x7E) { // printable ASCII if (c == '"' || c == '\\') { - putchar('\\'); + put_char('\\', F, S); } - putchar(c); + put_char(c, F, S); } else if (c < 0x20 || c == 0x7F) { // ASCII control character switch (c) { case '\b': - putchar('\\'); - putchar('b'); + put_char('\\', F, S); + put_char('b', F, S); break; case '\t': - putchar('\\'); - putchar('t'); + put_char('\\', F, S); + put_char('t', F, S); break; case '\r': - putchar('\\'); - putchar('r'); + put_char('\\', F, S); + put_char('r', F, S); break; case '\n': - putchar('\\'); - putchar('n'); + put_char('\\', F, S); + put_char('n', F, S); break; case '\f': - putchar('\\'); - putchar('f'); + put_char('\\', F, S); + put_char('f', F, S); break; default: unicode_escape = 1; @@ -52,13 +75,14 @@ static void jv_dump_string(jv str, int ascii_only) { } if (unicode_escape) { if (c <= 0xffff) { - printf("\\u%04x", c); + sprintf(buf, "\\u%04x", c); } else { c -= 0x10000; - printf("\\u%04x\\u%04x", - 0xD800 | ((c & 0xffc00) >> 10), - 0xDC00 | (c & 0x003ff)); + sprintf(buf, "\\u%04x\\u%04x", + 0xD800 | ((c & 0xffc00) >> 10), + 0xDC00 | (c & 0x003ff)); } + put_str(buf, F, S); } } assert(c != -1); @@ -66,78 +90,97 @@ static void jv_dump_string(jv str, int ascii_only) { enum { INDENT = 2 }; -static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent) { +static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) { char buf[JVP_DTOA_FMT_MAX_LEN]; switch (jv_get_kind(x)) { case JV_KIND_INVALID: assert(0 && "Invalid value"); break; case JV_KIND_NULL: - printf("null"); + put_str("null", F, S); break; case JV_KIND_FALSE: - printf("false"); + put_str("false", F, S); break; case JV_KIND_TRUE: - printf("true"); + put_str("true", F, S); break; case JV_KIND_NUMBER: { double d = jv_number_value(x); if (d != d) { // JSON doesn't have NaN, so we'll render it as "null" - printf("null"); + put_str("null", F, S); } else { // Normalise infinities to something we can print in valid JSON if (d > DBL_MAX) d = DBL_MAX; if (d < -DBL_MAX) d = -DBL_MAX; - printf("%s", jvp_dtoa_fmt(C, buf, d)); + put_str(jvp_dtoa_fmt(C, buf, d), F, S); } break; } case JV_KIND_STRING: - // FIXME: all sorts of broken - putchar('"'); - jv_dump_string(x, 0); - putchar('"'); + put_char('"', F, S); + jvp_dump_string(x, 0, F, S); + put_char('"', F, S); break; case JV_KIND_ARRAY: { if (jv_array_length(jv_copy(x)) == 0) { - printf("[]"); + put_str("[]", F, S); break; } - printf("["); - if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent+INDENT, ""); + put_str("[", F, S); + if (flags & JV_PRINT_PRETTY) { + put_char('\n', F, S); + put_space(indent+INDENT, F, S); + } for (int i=0; i Date: Mon, 17 Sep 2012 20:14:07 +0100 Subject: Add a "tostring" function. --- c/builtin.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/c/builtin.c b/c/builtin.c index 375e3252..97738656 100644 --- a/c/builtin.c +++ b/c/builtin.c @@ -129,6 +129,14 @@ static void f_tonumber(jv input[], jv output[]) { } } +static void f_tostring(jv input[], jv output[]) { + if (jv_get_kind(input[0]) == JV_KIND_STRING) { + output[0] = input[0]; + } else { + output[0] = jv_dump_string(input[0], 0); + } +} + struct cfunction function_list[] = { {f_true, "true", CALL_BUILTIN_1_1}, {f_false, "false", CALL_BUILTIN_1_1}, @@ -138,6 +146,7 @@ struct cfunction function_list[] = { {f_multiply, "_multiply", CALL_BUILTIN_3_1}, {f_divide, "_divide", CALL_BUILTIN_3_1}, {f_tonumber, "tonumber", CALL_BUILTIN_1_1}, + {f_tostring, "tostring", CALL_BUILTIN_1_1}, {f_equal, "_equal", CALL_BUILTIN_3_1}, }; struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])}; -- cgit v1.2.3