src/dump.c

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