src/dump.c

   1 /*
   2  * Copyright (c) 2009-2012 Petri Lehtinen <petri@digip.org>
   3  *
   4  * Jansson is free software; you can redistribute it and/or modify
   5  * it under the terms of the MIT license. See LICENSE for details.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <assert.h>
  13
  14 #include <jansson.h>
  15 #include "jansson_private.h"
  16 #include "strbuffer.h"
  17 #include "utf.h"
  18
  19 #define MAX_INTEGER_STR_LENGTH  100
  20 #define MAX_REAL_STR_LENGTH     100
  21
  22 struct object_key {
  23     size_t serial;
  24     const char *key;
  25 };
  26
  27 static int dump_to_strbuffer(const char *buffer, size_t size, void *data)
  28 {
  29     return strbuffer_append_bytes((strbuffer_t *)data, buffer, size);
  30 }
  31
  32 static int dump_to_file(const char *buffer, size_t size, void *data)
  33 {
  34     FILE *dest = (FILE *)data;
  35     if(fwrite(buffer, size, 1, dest) != 1)
  36         return -1;
  37     return 0;
  38 }
  39
  40 /* 32 spaces (the maximum indentation size) */
  41 static char whitespace[] = "                                ";
  42
  43 static int dump_indent(size_t flags, int depth, int space, json_dump_callback_t dump, void *data)
  44 {
  45     if(JSON_INDENT(flags) > 0)
  46     {
  47         int i, ws_count = JSON_INDENT(flags);
  48
  49         if(dump("\n", 1, data))
  50             return -1;
  51
  52         for(i = 0; i < depth; i++)
  53         {
  54             if(dump(whitespace, ws_count, data))
  55                 return -1;
  56         }
  57     }
  58     else if(space && !(flags & JSON_COMPACT))
  59     {
  60         return dump(" ", 1, data);
  61     }
  62     return 0;
  63 }
  64
  65 static int dump_string(const char *str, int ascii, json_dump_callback_t dump, void *data, size_t flags)
  66 {
  67     const char *pos, *end;
  68     int32_t codepoint;
  69
  70     if(dump("\"", 1, data))
  71         return -1;
  72
  73     end = pos = str;
  74     while(1)
  75     {
  76         const char *text;
  77         char seq[13];
  78         int length;
  79
  80         while(*end)
  81         {
  82             end = utf8_iterate(pos, &codepoint);
  83             if(!end)
  84                 return -1;
  85
  86             /* mandatory escape or control char */
  87             if(codepoint == '\\' || codepoint == '/' || codepoint == '"' || codepoint < 0x20)
  88                 break;
  89
  90             /* non-ASCII */
  91             if(ascii && codepoint > 0x7F)
  92                 break;
  93
  94             pos = end;
  95         }
  96
  97         if(pos != str) {
  98             if(dump(str, pos - str, data))
  99                 return -1;
 100         }
 101
 102         if(end == pos)
 103             break;
 104
 105         /* handle \, /, ", and control codes */
 106         length = 2;
 107         switch(codepoint)
 108         {
 109             case '\\': text = "\\\\"; break;
 110             case '\"': text = "\\\""; break;
 111             case '\b': text = "\\b"; break;
 112             case '\f': text = "\\f"; break;
 113             case '\n': text = "\\n"; break;
 114             case '\r': text = "\\r"; break;
 115             case '\t': text = "\\t"; break;
 116             case '/':
 117                 if (flags & JSON_ESCAPE_SLASH)
 118                     text = "\\/";
 119                 else {
 120                     text = "/";
 121                     length = 1;
 122                 }
 123                 break;
 124             default:
 125             {
 126                 /* codepoint is in BMP */
 127                 if(codepoint < 0x10000)
 128                 {
 129                     sprintf(seq, "\\u%04x", codepoint);
 130                     length = 6;
 131                 }
 132
 133                 /* not in BMP -> construct a UTF-16 surrogate pair */
 134                 else
 135                 {
 136                     int32_t first, last;
 137
 138                     codepoint -= 0x10000;
 139                     first = 0xD800 | ((codepoint & 0xffc00) >> 10);
 140                     last = 0xDC00 | (codepoint & 0x003ff);
 141
 142                     sprintf(seq, "\\u%04x\\u%04x", first, last);
 143                     length = 12;
 144                 }
 145
 146                 text = seq;
 147                 break;
 148             }
 149         }
 150
 151         if(dump(text, length, data))
 152             return -1;
 153
 154         str = pos = end;
 155     }
 156
 157     return dump("\"", 1, data);
 158 }
 159
 160 static int object_key_compare_keys(const void *key1, const void *key2)
 161 {
 162     return strcmp(((const struct object_key *)key1)->key,
 163                   ((const struct object_key *)key2)->key);
 164 }
 165
 166 static int object_key_compare_serials(const void *key1, const void *key2)
 167 {
 168     size_t a = ((const struct object_key *)key1)->serial;
 169     size_t b = ((const struct object_key *)key2)->serial;
 170
 171     return a < b ? -1 : a == b ? 0 : 1;
 172 }
 173
 174 static int do_dump(const json_t *json, size_t flags, int depth,
 175                    json_dump_callback_t dump, void *data)
 176 {
 177     int ascii = flags & JSON_ENSURE_ASCII ? 1 : 0;
 178
 179     switch(json_typeof(json)) {
 180         case JSON_NULL:
 181             return dump("null", 4, data);
 182
 183         case JSON_TRUE:
 184             return dump("true", 4, data);
 185
 186         case JSON_FALSE:
 187             return dump("false", 5, data);
 188
 189         case JSON_INTEGER:
 190         {
 191             char buffer[MAX_INTEGER_STR_LENGTH];
 192             int size;
 193
 194             size = snprintf(buffer, MAX_INTEGER_STR_LENGTH,
 195                             "%" JSON_INTEGER_FORMAT,
 196                             json_integer_value(json));
 197             if(size >= MAX_INTEGER_STR_LENGTH)
 198                 return -1;
 199
 200             return dump(buffer, size, data);
 201         }
 202
 203         case JSON_REAL:
 204         {
 205             char buffer[MAX_REAL_STR_LENGTH];
 206             int size;
 207             double value = json_real_value(json);
 208
 209             size = jsonp_dtostr(buffer, MAX_REAL_STR_LENGTH, value);
 210             if(size < 0)
 211                 return -1;
 212
 213             return dump(buffer, size, data);
 214         }
 215
 216         case JSON_STRING:
 217             return dump_string(json_string_value(json), ascii, dump, data, flags);
 218
 219         case JSON_ARRAY:
 220         {
 221             int i;
 222             int n;
 223             json_array_t *array;
 224
 225             /* detect circular references */
 226             array = json_to_array(json);
 227             if(array->visited)
 228                 goto array_error;
 229             array->visited = 1;
 230
 231             n = json_array_size(json);
 232
 233             if(dump("[", 1, data))
 234                 goto array_error;
 235             if(n == 0) {
 236                 array->visited = 0;
 237                 return dump("]", 1, data);
 238             }
 239             if(dump_indent(flags, depth + 1, 0, dump, data))
 240                 goto array_error;
 241
 242             for(i = 0; i < n; ++i) {
 243                 if(do_dump(json_array_get(json, i), flags, depth + 1,
 244                            dump, data))
 245                     goto array_error;
 246
 247                 if(i < n - 1)
 248                 {
 249                     if(dump(",", 1, data) ||
 250                        dump_indent(flags, depth + 1, 1, dump, data))
 251                         goto array_error;
 252                 }
 253                 else
 254                 {
 255                     if(dump_indent(flags, depth, 0, dump, data))
 256                         goto array_error;
 257                 }
 258             }
 259
 260             array->visited = 0;
 261             return dump("]", 1, data);
 262
 263         array_error:
 264             array->visited = 0;
 265             return -1;
 266         }
 267
 268         case JSON_OBJECT:
 269         {
 270             json_object_t *object;
 271             void *iter;
 272             const char *separator;
 273             int separator_length;
 274
 275             if(flags & JSON_COMPACT) {
 276                 separator = ":";
 277                 separator_length = 1;
 278             }
 279             else {
 280                 separator = ": ";
 281                 separator_length = 2;
 282             }
 283
 284             /* detect circular references */
 285             object = json_to_object(json);
 286             if(object->visited)
 287                 goto object_error;
 288             object->visited = 1;
 289
 290             iter = json_object_iter((json_t *)json);
 291
 292             if(dump("{", 1, data))
 293                 goto object_error;
 294             if(!iter) {
 295                 object->visited = 0;
 296                 return dump("}", 1, data);
 297             }
 298             if(dump_indent(flags, depth + 1, 0, dump, data))
 299                 goto object_error;
 300
 301             if(flags & JSON_SORT_KEYS || flags & JSON_PRESERVE_ORDER)
 302             {
 303                 struct object_key *keys;
 304                 size_t size, i;
 305                 int (*cmp_func)(const void *, const void *);
 306
 307                 size = json_object_size(json);
 308                 keys = jsonp_malloc(size * sizeof(struct object_key));
 309                 if(!keys)
 310                     goto object_error;
 311
 312                 i = 0;
 313                 while(iter)
 314                 {
 315                     keys[i].serial = hashtable_iter_serial(iter);
 316                     keys[i].key = json_object_iter_key(iter);
 317                     iter = json_object_iter_next((json_t *)json, iter);
 318                     i++;
 319                 }
 320                 assert(i == size);
 321
 322                 if(flags & JSON_SORT_KEYS)
 323                     cmp_func = object_key_compare_keys;
 324                 else
 325                     cmp_func = object_key_compare_serials;
 326
 327                 qsort(keys, size, sizeof(struct object_key), cmp_func);
 328
 329                 for(i = 0; i < size; i++)
 330                 {
 331                     const char *key;
 332                     json_t *value;
 333
 334                     key = keys[i].key;
 335                     value = json_object_get(json, key);
 336                     assert(value);
 337
 338                     dump_string(key, ascii, dump, data, flags);
 339                     if(dump(separator, separator_length, data) ||
 340                        do_dump(value, flags, depth + 1, dump, data))
 341                     {
 342                         jsonp_free(keys);
 343                         goto object_error;
 344                     }
 345
 346                     if(i < size - 1)
 347                     {
 348                         if(dump(",", 1, data) ||
 349                            dump_indent(flags, depth + 1, 1, dump, data))
 350                         {
 351                             jsonp_free(keys);
 352                             goto object_error;
 353                         }
 354                     }
 355                     else
 356                     {
 357                         if(dump_indent(flags, depth, 0, dump, data))
 358                         {
 359                             jsonp_free(keys);
 360                             goto object_error;
 361                         }
 362                     }
 363                 }
 364
 365                 jsonp_free(keys);
 366             }
 367             else
 368             {
 369                 /* Don't sort keys */
 370
 371                 while(iter)
 372                 {
 373                     void *next = json_object_iter_next((json_t *)json, iter);
 374
 375                     dump_string(json_object_iter_key(iter), ascii, dump, data, flags);
 376                     if(dump(separator, separator_length, data) ||
 377                        do_dump(json_object_iter_value(iter), flags, depth + 1,
 378                                dump, data))
 379                         goto object_error;
 380
 381                     if(next)
 382                     {
 383                         if(dump(",", 1, data) ||
 384                            dump_indent(flags, depth + 1, 1, dump, data))
 385                             goto object_error;
 386                     }
 387                     else
 388                     {
 389                         if(dump_indent(flags, depth, 0, dump, data))
 390                             goto object_error;
 391                     }
 392
 393                     iter = next;
 394                 }
 395             }
 396
 397             object->visited = 0;
 398             return dump("}", 1, data);
 399
 400         object_error:
 401             object->visited = 0;
 402             return -1;
 403         }
 404
 405         default:
 406             /* not reached */
 407             return -1;
 408     }
 409 }
 410
 411 char *json_dumps(const json_t *json, size_t flags)
 412 {
 413     strbuffer_t strbuff;
 414     char *result;
 415
 416     if(strbuffer_init(&strbuff))
 417         return NULL;
 418
 419     if(json_dump_callback(json, dump_to_strbuffer, (void *)&strbuff, flags))
 420         result = NULL;
 421     else
 422         result = jsonp_strdup(strbuffer_value(&strbuff));
 423
 424     strbuffer_close(&strbuff);
 425     return result;
 426 }
 427
 428 int json_dumpf(const json_t *json, FILE *output, size_t flags)
 429 {
 430     return json_dump_callback(json, dump_to_file, (void *)output, flags);
 431 }
 432
 433 int json_dump_file(const json_t *json, const char *path, size_t flags)
 434 {
 435     int result;
 436
 437     FILE *output = fopen(path, "w");
 438     if(!output)
 439         return -1;
 440
 441     result = json_dumpf(json, output, flags);
 442
 443     fclose(output);
 444     return result;
 445 }
 446
 447 int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags)
 448 {
 449     if(!(flags & JSON_ENCODE_ANY)) {
 450         if(!json_is_array(json) && !json_is_object(json))
 451            return -1;
 452     }
 453
 454     return do_dump(json, flags, 0, callback, data);
 455 }