X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=src%2Fdump.c;h=a862cba286ed5ba87f965f7f5d1503f397512b57;hb=782acfe378b8d6dddb307029ba97688943312340;hp=b8bd46013d0f0da66a94e845f4be33ba6ac6d628;hpb=6b14df13cc1b453d0cc277d0ba50cbabc2745089;p=jansson.git diff --git a/src/dump.c b/src/dump.c index b8bd460..a862cba 100644 --- a/src/dump.c +++ b/src/dump.c @@ -1,11 +1,23 @@ +/* + * Copyright (c) 2009, 2010 Petri Lehtinen + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + #define _GNU_SOURCE #include #include #include -#include +#include #include +#include "jansson_private.h" #include "strbuffer.h" +#include "utf.h" + +#define MAX_INTEGER_STR_LENGTH 100 +#define MAX_REAL_STR_LENGTH 100 typedef int (*dump_func)(const char *buffer, int size, void *data); @@ -29,63 +41,74 @@ static int dump_to_file(const char *buffer, int size, void *data) return 0; } -static int dump_to_fd(const char *buffer, int size, void *data) -{ - int *fd = (int *)data; - if(write(*fd, buffer, size) != size) - return -1; - return 0; -} +/* 256 spaces (the maximum indentation size) */ +static char whitespace[] = " "; -static int dump_indent(uint32_t flags, int depth, dump_func dump, void *data) +static int dump_indent(unsigned long flags, int depth, int space, dump_func dump, void *data) { if(JSON_INDENT(flags) > 0) { - char *ws_buffer; - int ws_count = JSON_INDENT(flags) * depth; + int i, ws_count = JSON_INDENT(flags); if(dump("\n", 1, data)) return -1; - if(ws_count == 0) - return 0; - - ws_buffer = alloca(ws_count); - memset(ws_buffer, ' ', ws_count); - return dump(ws_buffer, ws_count, data); + for(i = 0; i < depth; i++) + { + if(dump(whitespace, ws_count, data)) + return -1; + } } - else + else if(space && !(flags & JSON_COMPACT)) + { return dump(" ", 1, data); + } + return 0; } -static int dump_string(const char *str, dump_func dump, void *data) +static int dump_string(const char *str, int ascii, dump_func dump, void *data) { - const char *end; + const char *pos, *end; + int32_t codepoint; if(dump("\"", 1, data)) return -1; - end = str; + end = pos = str; while(1) { const char *text; - char seq[7]; + char seq[13]; int length; - while(*end && *end != '\\' && *end != '"' && (*end < 0 || *end > 0x1F)) - end++; + while(*end) + { + end = utf8_iterate(pos, &codepoint); + if(!end) + return -1; + + /* mandatory escape or control char */ + if(codepoint == '\\' || codepoint == '"' || codepoint < 0x20) + break; - if(end != str) { - if(dump(str, end - str, data)) + /* non-ASCII */ + if(ascii && codepoint > 0x7F) + break; + + pos = end; + } + + if(pos != str) { + if(dump(str, pos - str, data)) return -1; } - if(!*end) + if(end == pos) break; /* handle \, ", and control codes */ length = 2; - switch(*end) + switch(codepoint) { case '\\': text = "\\\\"; break; case '\"': text = "\\\""; break; @@ -96,9 +119,27 @@ static int dump_string(const char *str, dump_func dump, void *data) case '\t': text = "\\t"; break; default: { - sprintf(seq, "\\u00%02x", *end); + /* codepoint is in BMP */ + if(codepoint < 0x10000) + { + sprintf(seq, "\\u%04x", codepoint); + length = 6; + } + + /* not in BMP -> construct a UTF-16 surrogate pair */ + else + { + int32_t first, last; + + codepoint -= 0x10000; + first = 0xD800 | ((codepoint & 0xffc00) >> 10); + last = 0xDC00 | (codepoint & 0x003ff); + + sprintf(seq, "\\u%04x\\u%04x", first, last); + length = 12; + } + text = seq; - length = 6; break; } } @@ -106,16 +147,29 @@ static int dump_string(const char *str, dump_func dump, void *data) if(dump(text, length, data)) return -1; - end++; - str = end; + str = pos = end; } return dump("\"", 1, data); } -static int do_dump(const json_t *json, uint32_t flags, int depth, +static int object_key_compare_keys(const void *key1, const void *key2) +{ + return strcmp((*(const object_key_t **)key1)->key, + (*(const object_key_t **)key2)->key); +} + +static int object_key_compare_serials(const void *key1, const void *key2) +{ + return (*(const object_key_t **)key1)->serial - + (*(const object_key_t **)key2)->serial; +} + +static int do_dump(const json_t *json, unsigned long flags, int depth, dump_func dump, void *data) { + int ascii = flags & JSON_ENSURE_ASCII ? 1 : 0; + switch(json_typeof(json)) { case JSON_NULL: return dump("null", 4, data); @@ -128,45 +182,65 @@ static int do_dump(const json_t *json, uint32_t flags, int depth, case JSON_INTEGER: { - char *buffer; - int size, ret; + char buffer[MAX_INTEGER_STR_LENGTH]; + int size; - size = asprintf(&buffer, "%d", json_integer_value(json)); - if(size == -1) + size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, "%d", json_integer_value(json)); + if(size >= MAX_INTEGER_STR_LENGTH) return -1; - ret = dump(buffer, size, data); - free(buffer); - return ret; + return dump(buffer, size, data); } case JSON_REAL: { - char *buffer; - int size, ret; + char buffer[MAX_REAL_STR_LENGTH]; + int size; - size = asprintf(&buffer, "%.17f", json_real_value(json)); - if(size == -1) + size = snprintf(buffer, MAX_REAL_STR_LENGTH, "%.17g", + json_real_value(json)); + if(size >= MAX_REAL_STR_LENGTH) return -1; - ret = dump(buffer, size, data); - free(buffer); - return ret; + /* Make sure there's a dot or 'e' in the output. Otherwise + a real is converted to an integer when decoding */ + if(strchr(buffer, '.') == NULL && + strchr(buffer, 'e') == NULL) + { + if(size + 2 >= MAX_REAL_STR_LENGTH) { + /* No space to append ".0" */ + return -1; + } + buffer[size] = '.'; + buffer[size + 1] = '0'; + size += 2; + } + + return dump(buffer, size, data); } case JSON_STRING: - return dump_string(json_string_value(json), dump, data); + return dump_string(json_string_value(json), ascii, dump, data); case JSON_ARRAY: { int i; - int n = json_array_size(json); + int n; + json_array_t *array; + + /* detect circular references */ + array = json_to_array(json); + if(array->visited) + return -1; + array->visited = 1; + + n = json_array_size(json); if(dump("[", 1, data)) return -1; if(n == 0) return dump("]", 1, data); - if(dump_indent(flags, depth + 1, dump, data)) + if(dump_indent(flags, depth + 1, 0, dump, data)) return -1; for(i = 0; i < n; ++i) { @@ -177,53 +251,148 @@ static int do_dump(const json_t *json, uint32_t flags, int depth, if(i < n - 1) { if(dump(",", 1, data) || - dump_indent(flags, depth + 1, dump, data)) + dump_indent(flags, depth + 1, 1, dump, data)) return -1; } else { - if(dump_indent(flags, depth, dump, data)) + if(dump_indent(flags, depth, 0, dump, data)) return -1; } } + + array->visited = 0; return dump("]", 1, data); } case JSON_OBJECT: { - void *iter = json_object_iter((json_t *)json); + json_object_t *object; + void *iter; + const char *separator; + int separator_length; + + if(flags & JSON_COMPACT) { + separator = ":"; + separator_length = 1; + } + else { + separator = ": "; + separator_length = 2; + } + + /* detect circular references */ + object = json_to_object(json); + if(object->visited) + return -1; + object->visited = 1; + + iter = json_object_iter((json_t *)json); if(dump("{", 1, data)) return -1; if(!iter) return dump("}", 1, data); - if(dump_indent(flags, depth + 1, dump, data)) + if(dump_indent(flags, depth + 1, 0, dump, data)) return -1; - while(iter) + if(flags & JSON_SORT_KEYS || flags & JSON_PRESERVE_ORDER) { - void *next = json_object_iter_next((json_t *)json, iter); - - dump_string(json_object_iter_key(iter), dump, data); - if(dump(": ", 2, data) || - do_dump(json_object_iter_value(iter), flags, depth + 1, - dump, data)) + const object_key_t **keys; + unsigned int size; + unsigned int i; + int (*cmp_func)(const void *, const void *); + + size = json_object_size(json); + keys = malloc(size * sizeof(object_key_t *)); + if(!keys) return -1; - if(next) + i = 0; + while(iter) { - if(dump(",", 1, data) || - dump_indent(flags, depth + 1, dump, data)) - return -1; + keys[i] = jsonp_object_iter_fullkey(iter); + iter = json_object_iter_next((json_t *)json, iter); + i++; } + assert(i == size); + + if(flags & JSON_SORT_KEYS) + cmp_func = object_key_compare_keys; else + cmp_func = object_key_compare_serials; + + qsort(keys, size, sizeof(object_key_t *), cmp_func); + + for(i = 0; i < size; i++) { - if(dump_indent(flags, depth, dump, data)) + const char *key; + json_t *value; + + key = keys[i]->key; + value = json_object_get(json, key); + assert(value); + + dump_string(key, ascii, dump, data); + if(dump(separator, separator_length, data) || + do_dump(value, flags, depth + 1, dump, data)) + { + free(keys); return -1; + } + + if(i < size - 1) + { + if(dump(",", 1, data) || + dump_indent(flags, depth + 1, 1, dump, data)) + { + free(keys); + return -1; + } + } + else + { + if(dump_indent(flags, depth, 0, dump, data)) + { + free(keys); + return -1; + } + } } - iter = next; + free(keys); + } + else + { + /* Don't sort keys */ + + while(iter) + { + void *next = json_object_iter_next((json_t *)json, iter); + + dump_string(json_object_iter_key(iter), ascii, dump, data); + if(dump(separator, separator_length, data) || + do_dump(json_object_iter_value(iter), flags, depth + 1, + dump, data)) + return -1; + + if(next) + { + if(dump(",", 1, data) || + dump_indent(flags, depth + 1, 1, dump, data)) + return -1; + } + else + { + if(dump_indent(flags, depth, 0, dump, data)) + return -1; + } + + iter = next; + } } + + object->visited = 0; return dump("}", 1, data); } @@ -234,28 +403,21 @@ static int do_dump(const json_t *json, uint32_t flags, int depth, } -int json_dump(const json_t *json, const char *path, uint32_t flags) -{ - FILE *output = fopen(path, "w"); - if(!output) - return -1; - - return json_dumpf(json, output, flags); -} - -char *json_dumps(const json_t *json, uint32_t flags) +char *json_dumps(const json_t *json, unsigned long flags) { strbuffer_t strbuff; char *result; - if(strbuffer_init(&strbuff)) - return NULL; + if(!json_is_array(json) && !json_is_object(json)) + return NULL; - if(do_dump(json, flags, 0, dump_to_strbuffer, (void *)&strbuff)) + if(strbuffer_init(&strbuff)) return NULL; - if(dump_to_strbuffer("\n", 1, (void *)&strbuff)) + if(do_dump(json, flags, 0, dump_to_strbuffer, (void *)&strbuff)) { + strbuffer_close(&strbuff); return NULL; + } result = strdup(strbuffer_value(&strbuff)); strbuffer_close(&strbuff); @@ -263,16 +425,24 @@ char *json_dumps(const json_t *json, uint32_t flags) return result; } -int json_dumpf(const json_t *json, FILE *output, uint32_t flags) +int json_dumpf(const json_t *json, FILE *output, unsigned long flags) { - if(do_dump(json, flags, 0, dump_to_file, (void *)output)) + if(!json_is_array(json) && !json_is_object(json)) return -1; - return dump_to_file("\n", 1, (void *)output); + + return do_dump(json, flags, 0, dump_to_file, (void *)output); } -int json_dumpfd(const json_t *json, int fd, uint32_t flags) +int json_dump_file(const json_t *json, const char *path, unsigned long flags) { - if(do_dump(json, flags, 0, dump_to_fd, (void *)&fd)) + int result; + + FILE *output = fopen(path, "w"); + if(!output) return -1; - return dump_to_fd("\n", 1, (void *)&fd); + + result = json_dumpf(json, output, flags); + + fclose(output); + return result; }