src/dump.c

   1 #define _GNU_SOURCE
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6
   7 #include <jansson.h>
   8 #include "strbuffer.h"
   9
  10 typedef int (*dump_func)(const char *buffer, int size, void *data);
  11
  12 struct string
  13 {
  14     char *buffer;
  15     int length;
  16     int size;
  17 };
  18
  19 static int dump_to_strbuffer(const char *buffer, int size, void *data)
  20 {
  21     return strbuffer_append_bytes((strbuffer_t *)data, buffer, size);
  22 }
  23
  24 static int dump_to_file(const char *buffer, int size, void *data)
  25 {
  26     FILE *dest = (FILE *)data;
  27     if(fwrite(buffer, size, 1, dest) != 1)
  28         return -1;
  29     return 0;
  30 }
  31
  32 static int dump_indent(uint32_t flags, int depth, dump_func dump, void *data)
  33 {
  34     if(JSON_INDENT(flags) > 0)
  35     {
  36         char *ws_buffer;
  37         int ws_count = JSON_INDENT(flags) * depth;
  38
  39         if(dump("\n", 1, data))
  40             return -1;
  41
  42         if(ws_count == 0)
  43             return 0;
  44
  45         ws_buffer = alloca(ws_count);
  46         memset(ws_buffer, ' ', ws_count);
  47         return dump(ws_buffer, ws_count, data);
  48     }
  49     return 0;
  50 }
  51
  52 static int dump_string(const char *str, dump_func dump, void *data)
  53 {
  54     const char *end;
  55
  56     if(dump("\"", 1, data))
  57         return -1;
  58
  59     end = str;
  60     while(1)
  61     {
  62         const char *text;
  63         char seq[7];
  64         int length;
  65
  66         while(*end && *end != '\\' && *end != '"' && (*end < 0 || *end > 0x1F))
  67             end++;
  68
  69         if(end != str) {
  70             if(dump(str, end - str, data))
  71                 return -1;
  72         }
  73
  74         if(!*end)
  75             break;
  76
  77         /* handle \, ", and control codes */
  78         length = 2;
  79         switch(*end)
  80         {
  81             case '\\': text = "\\\\"; break;
  82             case '\"': text = "\\\""; break;
  83             case '\b': text = "\\b"; break;
  84             case '\f': text = "\\f"; break;
  85             case '\n': text = "\\n"; break;
  86             case '\r': text = "\\r"; break;
  87             case '\t': text = "\\t"; break;
  88             default:
  89             {
  90                 sprintf(seq, "\\u00%02x", *end);
  91                 text = seq;
  92                 length = 6;
  93                 break;
  94             }
  95         }
  96
  97         if(dump(text, length, data))
  98             return -1;
  99
 100         end++;
 101         str = end;
 102     }
 103
 104     return dump("\"", 1, data);
 105 }
 106
 107 static int do_dump(const json_t *json, uint32_t flags, int depth,
 108                    dump_func dump, void *data)
 109 {
 110     switch(json_typeof(json)) {
 111         case JSON_NULL:
 112             return dump("null", 4, data);
 113
 114         case JSON_TRUE:
 115             return dump("true", 4, data);
 116
 117         case JSON_FALSE:
 118             return dump("false", 5, data);
 119
 120         case JSON_INTEGER:
 121         {
 122             char *buffer;
 123             int size, ret;
 124
 125             size = asprintf(&buffer, "%d", json_integer_value(json));
 126             if(size == -1)
 127                 return -1;
 128
 129             ret = dump(buffer, size, data);
 130             free(buffer);
 131             return ret;
 132         }
 133
 134         case JSON_REAL:
 135         {
 136             char *buffer;
 137             int size, ret;
 138
 139             size = asprintf(&buffer, "%.17f", json_real_value(json));
 140             if(size == -1)
 141                 return -1;
 142
 143             ret = dump(buffer, size, data);
 144             free(buffer);
 145             return ret;
 146         }
 147
 148         case JSON_STRING:
 149             return dump_string(json_string_value(json), dump, data);
 150
 151         case JSON_ARRAY:
 152         {
 153             int i;
 154             int n = json_array_size(json);
 155
 156             if(dump("[", 1, data))
 157                 return -1;
 158             if(n == 0)
 159                 return dump("]", 1, data);
 160             if(dump_indent(flags, depth + 1, dump, data))
 161                 return -1;
 162
 163             for(i = 0; i < n; ++i) {
 164                 if(do_dump(json_array_get(json, i), flags, depth + 1,
 165                            dump, data))
 166                     return -1;
 167
 168                 if(i < n - 1)
 169                 {
 170                     if(dump(",", 1, data) ||
 171                        dump_indent(flags, depth + 1, dump, data))
 172                         return -1;
 173                 }
 174                 else
 175                 {
 176                     if(dump_indent(flags, depth, dump, data))
 177                         return -1;
 178                 }
 179             }
 180             return dump("]", 1, data);
 181         }
 182
 183         case JSON_OBJECT:
 184         {
 185             void *iter = json_object_iter((json_t *)json);
 186
 187             if(dump("{", 1, data))
 188                 return -1;
 189             if(!iter)
 190                 return dump("}", 1, data);
 191             if(dump_indent(flags, depth + 1, dump, data))
 192                 return -1;
 193
 194             while(iter)
 195             {
 196                 void *next = json_object_iter_next((json_t *)json, iter);
 197
 198                 dump_string(json_object_iter_key(iter), dump, data);
 199                 if(dump(": ", 2, data) ||
 200                    do_dump(json_object_iter_value(iter), flags, depth + 1,
 201                            dump, data))
 202                     return -1;
 203
 204                 if(next)
 205                 {
 206                     if(dump(",", 1, data) ||
 207                        dump_indent(flags, depth + 1, dump, data))
 208                         return -1;
 209                 }
 210                 else
 211                 {
 212                     if(dump_indent(flags, depth, dump, data))
 213                         return -1;
 214                 }
 215
 216                 iter = next;
 217             }
 218             return dump("}", 1, data);
 219         }
 220
 221         default:
 222             /* not reached */
 223             return -1;
 224     }
 225 }
 226
 227
 228 char *json_dumps(const json_t *json, uint32_t flags)
 229 {
 230     strbuffer_t strbuff;
 231     char *result;
 232
 233     if(strbuffer_init(&strbuff))
 234       return NULL;
 235
 236     if(do_dump(json, flags, 0, dump_to_strbuffer, (void *)&strbuff))
 237         return NULL;
 238
 239     if(dump_to_strbuffer("\n", 1, (void *)&strbuff))
 240         return NULL;
 241
 242     result = strdup(strbuffer_value(&strbuff));
 243     strbuffer_close(&strbuff);
 244
 245     return result;
 246 }
 247
 248 int json_dumpf(const json_t *json, FILE *output, uint32_t flags)
 249 {
 250     if(do_dump(json, flags, 0, dump_to_file, (void *)output))
 251         return -1;
 252     return dump_to_file("\n", 1, (void *)output);
 253 }
 254
 255 int json_dump_file(const json_t *json, const char *path, uint32_t flags)
 256 {
 257     int result;
 258
 259     FILE *output = fopen(path, "w");
 260     if(!output)
 261         return -1;
 262
 263     result = json_dumpf(json, output, flags);
 264
 265     fclose(output);
 266     return result;
 267 }