Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 1 | /* vi:set ts=8 sts=4 sw=4: |
| 2 | * |
| 3 | * VIM - Vi IMproved by Bram Moolenaar |
| 4 | * |
| 5 | * Do ":help uganda" in Vim to read copying and usage conditions. |
| 6 | * Do ":help credits" in Vim to see a list of people who contributed. |
| 7 | * See README.txt for an overview of the Vim source code. |
| 8 | */ |
| 9 | |
| 10 | /* |
| 11 | * json.c: Encoding and decoding JSON. |
| 12 | * |
Bram Moolenaar | 009d84a | 2016-01-28 14:12:00 +0100 | [diff] [blame] | 13 | * Follows this standard: https://tools.ietf.org/html/rfc7159.html |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 14 | */ |
| 15 | |
| 16 | #include "vim.h" |
| 17 | |
| 18 | #if defined(FEAT_EVAL) || defined(PROTO) |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 19 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 20 | static int json_encode_item(garray_T *gap, typval_T *val, int copyID, int options); |
| 21 | static int json_decode_item(js_read_T *reader, typval_T *res, int options); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 22 | |
| 23 | /* |
| 24 | * Encode "val" into a JSON format string. |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 25 | * The result is in allocated memory. |
| 26 | * The result is empty when encoding fails. |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 27 | * "options" can be JSON_JS or zero; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 28 | */ |
| 29 | char_u * |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 30 | json_encode(typval_T *val, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 31 | { |
| 32 | garray_T ga; |
| 33 | |
| 34 | /* Store bytes in the growarray. */ |
| 35 | ga_init2(&ga, 1, 4000); |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 36 | if (json_encode_item(&ga, val, get_copyID(), options) == FAIL) |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 37 | { |
| 38 | vim_free(ga.ga_data); |
| 39 | return vim_strsave((char_u *)""); |
| 40 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 41 | return ga.ga_data; |
| 42 | } |
| 43 | |
Bram Moolenaar | fb1f626 | 2016-01-31 20:24:32 +0100 | [diff] [blame] | 44 | /* |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 45 | * Encode ["nr", "val"] into a JSON format string in allocated memory. |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 46 | * "options" can be JSON_JS or zero; |
Bram Moolenaar | fb1f626 | 2016-01-31 20:24:32 +0100 | [diff] [blame] | 47 | * Returns NULL when out of memory. |
| 48 | */ |
| 49 | char_u * |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 50 | json_encode_nr_expr(int nr, typval_T *val, int options) |
Bram Moolenaar | fb1f626 | 2016-01-31 20:24:32 +0100 | [diff] [blame] | 51 | { |
| 52 | typval_T listtv; |
| 53 | typval_T nrtv; |
| 54 | char_u *text; |
| 55 | |
| 56 | nrtv.v_type = VAR_NUMBER; |
| 57 | nrtv.vval.v_number = nr; |
| 58 | if (rettv_list_alloc(&listtv) == FAIL) |
| 59 | return NULL; |
| 60 | if (list_append_tv(listtv.vval.v_list, &nrtv) == FAIL |
| 61 | || list_append_tv(listtv.vval.v_list, val) == FAIL) |
| 62 | { |
| 63 | list_unref(listtv.vval.v_list); |
| 64 | return NULL; |
| 65 | } |
| 66 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 67 | text = json_encode(&listtv, options); |
Bram Moolenaar | fb1f626 | 2016-01-31 20:24:32 +0100 | [diff] [blame] | 68 | list_unref(listtv.vval.v_list); |
| 69 | return text; |
| 70 | } |
| 71 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 72 | static void |
| 73 | write_string(garray_T *gap, char_u *str) |
| 74 | { |
| 75 | char_u *res = str; |
| 76 | char_u numbuf[NUMBUFLEN]; |
| 77 | |
| 78 | if (res == NULL) |
| 79 | ga_concat(gap, (char_u *)"null"); |
| 80 | else |
| 81 | { |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 82 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 83 | vimconv_T conv; |
| 84 | char_u *converted = NULL; |
| 85 | |
| 86 | convert_setup(&conv, p_enc, (char_u*)"utf-8"); |
| 87 | if (conv.vc_type != CONV_NONE) |
| 88 | converted = res = string_convert(&conv, res, NULL); |
| 89 | convert_setup(&conv, NULL, NULL); |
| 90 | #endif |
| 91 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 92 | ga_append(gap, '"'); |
| 93 | while (*res != NUL) |
| 94 | { |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 95 | int c; |
| 96 | #ifdef FEAT_MBYTE |
| 97 | /* always use utf-8 encoding, ignore 'encoding' */ |
| 98 | c = utf_ptr2char(res); |
| 99 | #else |
| 100 | c = (int)*(p); |
| 101 | #endif |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 102 | |
| 103 | switch (c) |
| 104 | { |
| 105 | case 0x08: |
| 106 | ga_append(gap, '\\'); ga_append(gap, 'b'); break; |
| 107 | case 0x09: |
| 108 | ga_append(gap, '\\'); ga_append(gap, 't'); break; |
| 109 | case 0x0a: |
| 110 | ga_append(gap, '\\'); ga_append(gap, 'n'); break; |
| 111 | case 0x0c: |
| 112 | ga_append(gap, '\\'); ga_append(gap, 'f'); break; |
| 113 | case 0x0d: |
| 114 | ga_append(gap, '\\'); ga_append(gap, 'r'); break; |
| 115 | case 0x22: /* " */ |
| 116 | case 0x5c: /* \ */ |
| 117 | ga_append(gap, '\\'); |
| 118 | ga_append(gap, c); |
| 119 | break; |
| 120 | default: |
| 121 | if (c >= 0x20) |
| 122 | { |
Bram Moolenaar | fa06a51 | 2016-01-28 22:46:58 +0100 | [diff] [blame] | 123 | #ifdef FEAT_MBYTE |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 124 | numbuf[utf_char2bytes(c, numbuf)] = NUL; |
Bram Moolenaar | fa06a51 | 2016-01-28 22:46:58 +0100 | [diff] [blame] | 125 | #else |
| 126 | numbuf[0] = c; |
| 127 | numbuf[1] = NUL; |
| 128 | #endif |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 129 | ga_concat(gap, numbuf); |
| 130 | } |
| 131 | else |
| 132 | { |
| 133 | vim_snprintf((char *)numbuf, NUMBUFLEN, |
| 134 | "\\u%04lx", (long)c); |
| 135 | ga_concat(gap, numbuf); |
| 136 | } |
| 137 | } |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 138 | #ifdef FEAT_MBYTE |
| 139 | res += utf_ptr2len(res); |
| 140 | #else |
| 141 | ++p; |
| 142 | #endif |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 143 | } |
| 144 | ga_append(gap, '"'); |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 145 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 146 | vim_free(converted); |
| 147 | #endif |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 148 | } |
| 149 | } |
| 150 | |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 151 | /* |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 152 | * Return TRUE if "key" can be used without quotes. |
| 153 | * That is when it starts with a letter and only contains letters, digits and |
| 154 | * underscore. |
| 155 | */ |
| 156 | static int |
| 157 | is_simple_key(char_u *key) |
| 158 | { |
| 159 | char_u *p; |
| 160 | |
| 161 | if (!ASCII_ISALPHA(*key)) |
| 162 | return FALSE; |
| 163 | for (p = key + 1; *p != NUL; ++p) |
| 164 | if (!ASCII_ISALPHA(*p) && *p != '_' && !vim_isdigit(*p)) |
| 165 | return FALSE; |
| 166 | return TRUE; |
| 167 | } |
| 168 | |
| 169 | /* |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 170 | * Encode "val" into "gap". |
| 171 | * Return FAIL or OK. |
| 172 | */ |
| 173 | static int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 174 | json_encode_item(garray_T *gap, typval_T *val, int copyID, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 175 | { |
| 176 | char_u numbuf[NUMBUFLEN]; |
| 177 | char_u *res; |
| 178 | list_T *l; |
| 179 | dict_T *d; |
| 180 | |
| 181 | switch (val->v_type) |
| 182 | { |
| 183 | case VAR_SPECIAL: |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 184 | switch (val->vval.v_number) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 185 | { |
| 186 | case VVAL_FALSE: ga_concat(gap, (char_u *)"false"); break; |
| 187 | case VVAL_TRUE: ga_concat(gap, (char_u *)"true"); break; |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 188 | case VVAL_NONE: if ((options & JSON_JS) != 0 |
| 189 | && (options & JSON_NO_NONE) == 0) |
| 190 | /* empty item */ |
| 191 | break; |
| 192 | /* FALLTHROUGH */ |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 193 | case VVAL_NULL: ga_concat(gap, (char_u *)"null"); break; |
| 194 | } |
| 195 | break; |
| 196 | |
| 197 | case VAR_NUMBER: |
| 198 | vim_snprintf((char *)numbuf, NUMBUFLEN, "%ld", |
| 199 | (long)val->vval.v_number); |
| 200 | ga_concat(gap, numbuf); |
| 201 | break; |
| 202 | |
| 203 | case VAR_STRING: |
| 204 | res = val->vval.v_string; |
| 205 | write_string(gap, res); |
| 206 | break; |
| 207 | |
| 208 | case VAR_FUNC: |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 209 | case VAR_JOB: |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 210 | case VAR_CHANNEL: |
Bram Moolenaar | 4f8b8fa | 2016-02-06 18:42:07 +0100 | [diff] [blame] | 211 | /* no JSON equivalent TODO: better error */ |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 212 | EMSG(_(e_invarg)); |
| 213 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 214 | |
| 215 | case VAR_LIST: |
| 216 | l = val->vval.v_list; |
| 217 | if (l == NULL) |
| 218 | ga_concat(gap, (char_u *)"null"); |
| 219 | else |
| 220 | { |
| 221 | if (l->lv_copyID == copyID) |
| 222 | ga_concat(gap, (char_u *)"[]"); |
| 223 | else |
| 224 | { |
| 225 | listitem_T *li; |
| 226 | |
| 227 | l->lv_copyID = copyID; |
| 228 | ga_append(gap, '['); |
| 229 | for (li = l->lv_first; li != NULL && !got_int; ) |
| 230 | { |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 231 | if (json_encode_item(gap, &li->li_tv, copyID, |
| 232 | options & JSON_JS) == FAIL) |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 233 | return FAIL; |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 234 | if ((options & JSON_JS) |
| 235 | && li->li_next == NULL |
| 236 | && li->li_tv.v_type == VAR_SPECIAL |
| 237 | && li->li_tv.vval.v_number == VVAL_NONE) |
| 238 | /* add an extra comma if the last item is v:none */ |
| 239 | ga_append(gap, ','); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 240 | li = li->li_next; |
| 241 | if (li != NULL) |
| 242 | ga_append(gap, ','); |
| 243 | } |
| 244 | ga_append(gap, ']'); |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 245 | l->lv_copyID = 0; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 246 | } |
| 247 | } |
| 248 | break; |
| 249 | |
| 250 | case VAR_DICT: |
| 251 | d = val->vval.v_dict; |
| 252 | if (d == NULL) |
| 253 | ga_concat(gap, (char_u *)"null"); |
| 254 | else |
| 255 | { |
| 256 | if (d->dv_copyID == copyID) |
| 257 | ga_concat(gap, (char_u *)"{}"); |
| 258 | else |
| 259 | { |
| 260 | int first = TRUE; |
| 261 | int todo = (int)d->dv_hashtab.ht_used; |
| 262 | hashitem_T *hi; |
| 263 | |
| 264 | d->dv_copyID = copyID; |
| 265 | ga_append(gap, '{'); |
| 266 | |
| 267 | for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int; |
| 268 | ++hi) |
| 269 | if (!HASHITEM_EMPTY(hi)) |
| 270 | { |
| 271 | --todo; |
| 272 | if (first) |
| 273 | first = FALSE; |
| 274 | else |
| 275 | ga_append(gap, ','); |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 276 | if ((options & JSON_JS) |
| 277 | && is_simple_key(hi->hi_key)) |
| 278 | ga_concat(gap, hi->hi_key); |
| 279 | else |
| 280 | write_string(gap, hi->hi_key); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 281 | ga_append(gap, ':'); |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 282 | if (json_encode_item(gap, &dict_lookup(hi)->di_tv, |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 283 | copyID, options | JSON_NO_NONE) == FAIL) |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 284 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 285 | } |
| 286 | ga_append(gap, '}'); |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 287 | d->dv_copyID = 0; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 288 | } |
| 289 | } |
| 290 | break; |
| 291 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 292 | case VAR_FLOAT: |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 293 | #ifdef FEAT_FLOAT |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 294 | # if defined(HAVE_MATH_H) |
Bram Moolenaar | 7ce686c | 2016-02-27 16:33:22 +0100 | [diff] [blame] | 295 | if (isnan(val->vval.v_float)) |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 296 | ga_concat(gap, (char_u *)"NaN"); |
Bram Moolenaar | 7ce686c | 2016-02-27 16:33:22 +0100 | [diff] [blame] | 297 | else if (isinf(val->vval.v_float)) |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 298 | ga_concat(gap, (char_u *)"Infinity"); |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 299 | else |
| 300 | # endif |
| 301 | { |
| 302 | vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", |
| 303 | val->vval.v_float); |
| 304 | ga_concat(gap, numbuf); |
| 305 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 306 | break; |
| 307 | #endif |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 308 | case VAR_UNKNOWN: |
Bram Moolenaar | c6b14f0 | 2016-02-20 15:26:42 +0100 | [diff] [blame] | 309 | EMSG2(_(e_intern2), "json_encode_item()"); |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 310 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 311 | } |
Bram Moolenaar | fcaaae6 | 2016-01-24 16:49:11 +0100 | [diff] [blame] | 312 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 313 | } |
| 314 | |
| 315 | /* |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 316 | * When "reader" has less than NUMBUFLEN bytes available, call the fill |
| 317 | * callback to get more. |
| 318 | */ |
| 319 | static void |
| 320 | fill_numbuflen(js_read_T *reader) |
| 321 | { |
| 322 | if (reader->js_fill != NULL && (int)(reader->js_end - reader->js_buf) |
| 323 | - reader->js_used < NUMBUFLEN) |
| 324 | { |
| 325 | if (reader->js_fill(reader)) |
| 326 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
| 327 | } |
| 328 | } |
| 329 | |
| 330 | /* |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 331 | * Skip white space in "reader". All characters <= space are considered white |
| 332 | * space. |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 333 | * Also tops up readahead when needed. |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 334 | */ |
| 335 | static void |
| 336 | json_skip_white(js_read_T *reader) |
| 337 | { |
| 338 | int c; |
| 339 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 340 | for (;;) |
| 341 | { |
| 342 | c = reader->js_buf[reader->js_used]; |
| 343 | if (reader->js_fill != NULL && c == NUL) |
| 344 | { |
| 345 | if (reader->js_fill(reader)) |
| 346 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
| 347 | continue; |
| 348 | } |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 349 | if (c == NUL || c > ' ') |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 350 | break; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 351 | ++reader->js_used; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 352 | } |
| 353 | fill_numbuflen(reader); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 354 | } |
| 355 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 356 | static int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 357 | json_decode_array(js_read_T *reader, typval_T *res, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 358 | { |
| 359 | char_u *p; |
| 360 | typval_T item; |
| 361 | listitem_T *li; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 362 | int ret; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 363 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 364 | if (res != NULL && rettv_list_alloc(res) == FAIL) |
| 365 | { |
| 366 | res->v_type = VAR_SPECIAL; |
| 367 | res->vval.v_number = VVAL_NONE; |
| 368 | return FAIL; |
| 369 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 370 | ++reader->js_used; /* consume the '[' */ |
| 371 | |
| 372 | while (TRUE) |
| 373 | { |
| 374 | json_skip_white(reader); |
| 375 | p = reader->js_buf + reader->js_used; |
| 376 | if (*p == NUL) |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 377 | return MAYBE; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 378 | if (*p == ']') |
| 379 | { |
| 380 | ++reader->js_used; /* consume the ']' */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 381 | break; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 382 | } |
| 383 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 384 | ret = json_decode_item(reader, res == NULL ? NULL : &item, options); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 385 | if (ret != OK) |
| 386 | return ret; |
| 387 | if (res != NULL) |
| 388 | { |
| 389 | li = listitem_alloc(); |
| 390 | if (li == NULL) |
| 391 | { |
| 392 | clear_tv(&item); |
| 393 | return FAIL; |
| 394 | } |
| 395 | li->li_tv = item; |
| 396 | list_append(res->vval.v_list, li); |
| 397 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 398 | |
| 399 | json_skip_white(reader); |
| 400 | p = reader->js_buf + reader->js_used; |
| 401 | if (*p == ',') |
| 402 | ++reader->js_used; |
| 403 | else if (*p != ']') |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 404 | { |
| 405 | if (*p == NUL) |
| 406 | return MAYBE; |
| 407 | return FAIL; |
| 408 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 409 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 410 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 411 | } |
| 412 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 413 | static int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 414 | json_decode_object(js_read_T *reader, typval_T *res, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 415 | { |
| 416 | char_u *p; |
| 417 | typval_T tvkey; |
| 418 | typval_T item; |
| 419 | dictitem_T *di; |
| 420 | char_u buf[NUMBUFLEN]; |
Bram Moolenaar | fbf9c6b | 2016-02-02 19:43:57 +0100 | [diff] [blame] | 421 | char_u *key = NULL; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 422 | int ret; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 423 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 424 | if (res != NULL && rettv_dict_alloc(res) == FAIL) |
| 425 | { |
| 426 | res->v_type = VAR_SPECIAL; |
| 427 | res->vval.v_number = VVAL_NONE; |
| 428 | return FAIL; |
| 429 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 430 | ++reader->js_used; /* consume the '{' */ |
| 431 | |
| 432 | while (TRUE) |
| 433 | { |
| 434 | json_skip_white(reader); |
| 435 | p = reader->js_buf + reader->js_used; |
| 436 | if (*p == NUL) |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 437 | return MAYBE; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 438 | if (*p == '}') |
| 439 | { |
| 440 | ++reader->js_used; /* consume the '}' */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 441 | break; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 442 | } |
| 443 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 444 | if ((options & JSON_JS) && reader->js_buf[reader->js_used] != '"') |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 445 | { |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 446 | /* accept a key that is not in quotes */ |
| 447 | key = p = reader->js_buf + reader->js_used; |
| 448 | while (*p != NUL && *p != ':' && *p > ' ') |
| 449 | ++p; |
| 450 | tvkey.v_type = VAR_STRING; |
| 451 | tvkey.vval.v_string = vim_strnsave(key, (int)(p - key)); |
| 452 | reader->js_used += (int)(p - key); |
| 453 | key = tvkey.vval.v_string; |
| 454 | } |
| 455 | else |
| 456 | { |
| 457 | ret = json_decode_item(reader, res == NULL ? NULL : &tvkey, |
| 458 | options); |
| 459 | if (ret != OK) |
| 460 | return ret; |
| 461 | if (res != NULL) |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 462 | { |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 463 | key = get_tv_string_buf_chk(&tvkey, buf); |
| 464 | if (key == NULL || *key == NUL) |
| 465 | { |
| 466 | clear_tv(&tvkey); |
| 467 | return FAIL; |
| 468 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 469 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 470 | } |
| 471 | |
| 472 | json_skip_white(reader); |
| 473 | p = reader->js_buf + reader->js_used; |
| 474 | if (*p != ':') |
| 475 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 476 | if (res != NULL) |
| 477 | clear_tv(&tvkey); |
| 478 | if (*p == NUL) |
| 479 | return MAYBE; |
| 480 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 481 | } |
| 482 | ++reader->js_used; |
| 483 | json_skip_white(reader); |
| 484 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 485 | ret = json_decode_item(reader, res == NULL ? NULL : &item, options); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 486 | if (ret != OK) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 487 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 488 | if (res != NULL) |
| 489 | clear_tv(&tvkey); |
| 490 | return ret; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 491 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 492 | |
| 493 | if (res != NULL) |
| 494 | { |
| 495 | di = dictitem_alloc(key); |
| 496 | clear_tv(&tvkey); |
| 497 | if (di == NULL) |
| 498 | { |
| 499 | clear_tv(&item); |
| 500 | return FAIL; |
| 501 | } |
| 502 | di->di_tv = item; |
| 503 | if (dict_add(res->vval.v_dict, di) == FAIL) |
| 504 | { |
| 505 | dictitem_free(di); |
| 506 | return FAIL; |
| 507 | } |
| 508 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 509 | |
| 510 | json_skip_white(reader); |
| 511 | p = reader->js_buf + reader->js_used; |
| 512 | if (*p == ',') |
| 513 | ++reader->js_used; |
| 514 | else if (*p != '}') |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 515 | { |
| 516 | if (*p == NUL) |
| 517 | return MAYBE; |
| 518 | return FAIL; |
| 519 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 520 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 521 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 522 | } |
| 523 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 524 | static int |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 525 | json_decode_string(js_read_T *reader, typval_T *res) |
| 526 | { |
| 527 | garray_T ga; |
| 528 | int len; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 529 | char_u *p; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 530 | int c; |
| 531 | long nr; |
| 532 | char_u buf[NUMBUFLEN]; |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 533 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 534 | vimconv_T conv; |
| 535 | char_u *converted = NULL; |
| 536 | #endif |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 537 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 538 | if (res != NULL) |
| 539 | ga_init2(&ga, 1, 200); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 540 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 541 | p = reader->js_buf + reader->js_used + 1; /* skip over " */ |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 542 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 543 | convert_setup(&conv, (char_u*)"utf-8", p_enc); |
| 544 | if (conv.vc_type != CONV_NONE) |
| 545 | converted = p = string_convert(&conv, p, NULL); |
| 546 | convert_setup(&conv, NULL, NULL); |
| 547 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 548 | while (*p != '"') |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 549 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 550 | if (*p == NUL || p[1] == NUL |
| 551 | #ifdef FEAT_MBYTE |
| 552 | || utf_ptr2len(p) < utf_byte2len(*p) |
| 553 | #endif |
| 554 | ) |
| 555 | { |
| 556 | if (reader->js_fill == NULL) |
| 557 | break; |
| 558 | len = (int)(reader->js_end - p); |
| 559 | reader->js_used = (int)(p - reader->js_buf); |
| 560 | if (!reader->js_fill(reader)) |
| 561 | break; /* didn't get more */ |
| 562 | p = reader->js_buf + reader->js_used; |
| 563 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
| 564 | continue; |
| 565 | } |
| 566 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 567 | if (*p == '\\') |
| 568 | { |
| 569 | c = -1; |
| 570 | switch (p[1]) |
| 571 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 572 | case '\\': c = '\\'; break; |
| 573 | case '"': c = '"'; break; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 574 | case 'b': c = BS; break; |
| 575 | case 't': c = TAB; break; |
| 576 | case 'n': c = NL; break; |
| 577 | case 'f': c = FF; break; |
| 578 | case 'r': c = CAR; break; |
| 579 | case 'u': |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 580 | if (reader->js_fill != NULL |
| 581 | && (int)(reader->js_end - p) < NUMBUFLEN) |
| 582 | { |
| 583 | reader->js_used = (int)(p - reader->js_buf); |
| 584 | if (reader->js_fill(reader)) |
| 585 | { |
| 586 | p = reader->js_buf + reader->js_used; |
| 587 | reader->js_end = reader->js_buf |
| 588 | + STRLEN(reader->js_buf); |
| 589 | } |
| 590 | } |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 591 | nr = 0; |
| 592 | len = 0; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 593 | vim_str2nr(p + 2, NULL, &len, |
| 594 | STR2NR_HEX + STR2NR_FORCE, &nr, NULL, 4); |
| 595 | p += len + 2; |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 596 | if (0xd800 <= nr && nr <= 0xdfff |
| 597 | && (int)(reader->js_end - p) >= 6 |
| 598 | && *p == '\\' && *(p+1) == 'u') |
| 599 | { |
| 600 | long nr2 = 0; |
| 601 | |
| 602 | /* decode surrogate pair: \ud812\u3456 */ |
| 603 | len = 0; |
| 604 | vim_str2nr(p + 2, NULL, &len, |
| 605 | STR2NR_HEX + STR2NR_FORCE, &nr2, NULL, 4); |
| 606 | if (0xdc00 <= nr2 && nr2 <= 0xdfff) |
| 607 | { |
| 608 | p += len + 2; |
| 609 | nr = (((nr - 0xd800) << 10) | |
| 610 | ((nr2 - 0xdc00) & 0x3ff)) + 0x10000; |
| 611 | } |
| 612 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 613 | if (res != NULL) |
| 614 | { |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 615 | #ifdef FEAT_MBYTE |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 616 | buf[utf_char2bytes((int)nr, buf)] = NUL; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 617 | ga_concat(&ga, buf); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 618 | #else |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 619 | ga_append(&ga, nr); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 620 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 621 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 622 | break; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 623 | default: |
| 624 | /* not a special char, skip over \ */ |
| 625 | ++p; |
| 626 | continue; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 627 | } |
| 628 | if (c > 0) |
| 629 | { |
| 630 | p += 2; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 631 | if (res != NULL) |
| 632 | ga_append(&ga, c); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 633 | } |
| 634 | } |
| 635 | else |
| 636 | { |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 637 | #ifdef FEAT_MBYTE |
| 638 | len = utf_ptr2len(p); |
| 639 | #else |
| 640 | len = 1; |
| 641 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 642 | if (res != NULL) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 643 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 644 | if (ga_grow(&ga, len) == FAIL) |
| 645 | { |
| 646 | ga_clear(&ga); |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 647 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 648 | vim_free(converted); |
| 649 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 650 | return FAIL; |
| 651 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 652 | mch_memmove((char *)ga.ga_data + ga.ga_len, p, (size_t)len); |
| 653 | ga.ga_len += len; |
| 654 | } |
| 655 | p += len; |
| 656 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 657 | } |
Bram Moolenaar | b6ff811 | 2016-02-27 18:41:27 +0100 | [diff] [blame] | 658 | #if defined(FEAT_MBYTE) && defined(USE_ICONV) |
| 659 | vim_free(converted); |
| 660 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 661 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 662 | reader->js_used = (int)(p - reader->js_buf); |
| 663 | if (*p == '"') |
| 664 | { |
| 665 | ++reader->js_used; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 666 | if (res != NULL) |
| 667 | { |
| 668 | res->v_type = VAR_STRING; |
Bram Moolenaar | 4b6a6dc | 2016-02-04 22:49:49 +0100 | [diff] [blame] | 669 | res->vval.v_string = ga.ga_data; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 670 | } |
| 671 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 672 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 673 | if (res != NULL) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 674 | { |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 675 | res->v_type = VAR_SPECIAL; |
| 676 | res->vval.v_number = VVAL_NONE; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 677 | ga_clear(&ga); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 678 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 679 | return MAYBE; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 680 | } |
| 681 | |
| 682 | /* |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 683 | * Decode one item and put it in "res". If "res" is NULL only advance. |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 684 | * Must already have skipped white space. |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 685 | * |
| 686 | * Return FAIL for a decoding error. |
| 687 | * Return MAYBE for an incomplete message. |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 688 | */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 689 | static int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 690 | json_decode_item(js_read_T *reader, typval_T *res, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 691 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 692 | char_u *p; |
| 693 | int len; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 694 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 695 | fill_numbuflen(reader); |
| 696 | p = reader->js_buf + reader->js_used; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 697 | switch (*p) |
| 698 | { |
| 699 | case '[': /* array */ |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 700 | return json_decode_array(reader, res, options); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 701 | |
| 702 | case '{': /* object */ |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 703 | return json_decode_object(reader, res, options); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 704 | |
| 705 | case '"': /* string */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 706 | return json_decode_string(reader, res); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 707 | |
| 708 | case ',': /* comma: empty item */ |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 709 | if ((options & JSON_JS) == 0) |
| 710 | return FAIL; |
| 711 | /* FALLTHROUGH */ |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 712 | case NUL: /* empty */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 713 | if (res != NULL) |
| 714 | { |
| 715 | res->v_type = VAR_SPECIAL; |
| 716 | res->vval.v_number = VVAL_NONE; |
| 717 | } |
| 718 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 719 | |
| 720 | default: |
| 721 | if (VIM_ISDIGIT(*p) || *p == '-') |
| 722 | { |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 723 | char_u *sp = p; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 724 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 725 | #ifdef FEAT_FLOAT |
| 726 | if (*sp == '-') |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 727 | { |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 728 | ++sp; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 729 | if (*sp == NUL) |
| 730 | return MAYBE; |
| 731 | if (!VIM_ISDIGIT(*sp)) |
| 732 | return FAIL; |
| 733 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 734 | sp = skipdigits(sp); |
| 735 | if (*sp == '.' || *sp == 'e' || *sp == 'E') |
| 736 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 737 | if (res == NULL) |
| 738 | { |
| 739 | float_T f; |
| 740 | |
| 741 | len = string2float(p, &f); |
| 742 | } |
| 743 | else |
| 744 | { |
| 745 | res->v_type = VAR_FLOAT; |
| 746 | len = string2float(p, &res->vval.v_float); |
| 747 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 748 | } |
| 749 | else |
| 750 | #endif |
| 751 | { |
| 752 | long nr; |
| 753 | |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 754 | vim_str2nr(reader->js_buf + reader->js_used, |
| 755 | NULL, &len, 0, /* what */ |
| 756 | &nr, NULL, 0); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 757 | if (res != NULL) |
| 758 | { |
| 759 | res->v_type = VAR_NUMBER; |
| 760 | res->vval.v_number = nr; |
| 761 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 762 | } |
| 763 | reader->js_used += len; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 764 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 765 | } |
| 766 | if (STRNICMP((char *)p, "false", 5) == 0) |
| 767 | { |
| 768 | reader->js_used += 5; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 769 | if (res != NULL) |
| 770 | { |
| 771 | res->v_type = VAR_SPECIAL; |
| 772 | res->vval.v_number = VVAL_FALSE; |
| 773 | } |
| 774 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 775 | } |
| 776 | if (STRNICMP((char *)p, "true", 4) == 0) |
| 777 | { |
| 778 | reader->js_used += 4; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 779 | if (res != NULL) |
| 780 | { |
| 781 | res->v_type = VAR_SPECIAL; |
| 782 | res->vval.v_number = VVAL_TRUE; |
| 783 | } |
| 784 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 785 | } |
| 786 | if (STRNICMP((char *)p, "null", 4) == 0) |
| 787 | { |
| 788 | reader->js_used += 4; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 789 | if (res != NULL) |
| 790 | { |
| 791 | res->v_type = VAR_SPECIAL; |
| 792 | res->vval.v_number = VVAL_NULL; |
| 793 | } |
| 794 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 795 | } |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 796 | #ifdef FEAT_FLOAT |
| 797 | if (STRNICMP((char *)p, "NaN", 3) == 0) |
| 798 | { |
| 799 | reader->js_used += 3; |
| 800 | if (res != NULL) |
| 801 | { |
| 802 | res->v_type = VAR_FLOAT; |
Bram Moolenaar | 3ea0f1a | 2016-02-23 22:07:32 +0100 | [diff] [blame] | 803 | res->vval.v_float = NAN; |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 804 | } |
| 805 | return OK; |
| 806 | } |
| 807 | if (STRNICMP((char *)p, "Infinity", 8) == 0) |
| 808 | { |
| 809 | reader->js_used += 8; |
| 810 | if (res != NULL) |
| 811 | { |
| 812 | res->v_type = VAR_FLOAT; |
Bram Moolenaar | 3ea0f1a | 2016-02-23 22:07:32 +0100 | [diff] [blame] | 813 | res->vval.v_float = INFINITY; |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 814 | } |
| 815 | return OK; |
| 816 | } |
| 817 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 818 | /* check for truncated name */ |
| 819 | len = (int)(reader->js_end - (reader->js_buf + reader->js_used)); |
Bram Moolenaar | f1b6ac7 | 2016-02-23 21:26:43 +0100 | [diff] [blame] | 820 | if ( |
| 821 | (len < 5 && STRNICMP((char *)p, "false", len) == 0) |
| 822 | #ifdef FEAT_FLOAT |
| 823 | || (len < 8 && STRNICMP((char *)p, "Infinity", len) == 0) |
| 824 | || (len < 3 && STRNICMP((char *)p, "NaN", len) == 0) |
| 825 | #endif |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 826 | || (len < 4 && (STRNICMP((char *)p, "true", len) == 0 |
| 827 | || STRNICMP((char *)p, "null", len) == 0))) |
| 828 | return MAYBE; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 829 | break; |
| 830 | } |
| 831 | |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 832 | if (res != NUL) |
| 833 | { |
| 834 | res->v_type = VAR_SPECIAL; |
| 835 | res->vval.v_number = VVAL_NONE; |
| 836 | } |
| 837 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 838 | } |
| 839 | |
| 840 | /* |
| 841 | * Decode the JSON from "reader" and store the result in "res". |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 842 | * "options" can be JSON_JS or zero; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 843 | * Return FAIL if not the whole message was consumed. |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 844 | */ |
Bram Moolenaar | 19d2f15 | 2016-02-01 21:38:19 +0100 | [diff] [blame] | 845 | int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 846 | json_decode_all(js_read_T *reader, typval_T *res, int options) |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 847 | { |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 848 | int ret; |
| 849 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 850 | /* We find the end once, to avoid calling strlen() many times. */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 851 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 852 | json_skip_white(reader); |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 853 | ret = json_decode_item(reader, res, options); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 854 | if (ret != OK) |
| 855 | return FAIL; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 856 | json_skip_white(reader); |
| 857 | if (reader->js_buf[reader->js_used] != NUL) |
Bram Moolenaar | 19d2f15 | 2016-02-01 21:38:19 +0100 | [diff] [blame] | 858 | return FAIL; |
| 859 | return OK; |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 860 | } |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 861 | |
| 862 | /* |
| 863 | * Decode the JSON from "reader" and store the result in "res". |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 864 | * "options" can be JSON_JS or zero; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 865 | * Return FAIL if the message has a decoding error or the message is |
| 866 | * truncated. Consumes the message anyway. |
| 867 | */ |
| 868 | int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 869 | json_decode(js_read_T *reader, typval_T *res, int options) |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 870 | { |
| 871 | int ret; |
| 872 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 873 | /* We find the end once, to avoid calling strlen() many times. */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 874 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
| 875 | json_skip_white(reader); |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 876 | ret = json_decode_item(reader, res, options); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 877 | json_skip_white(reader); |
| 878 | |
| 879 | return ret == OK ? OK : FAIL; |
| 880 | } |
| 881 | |
| 882 | /* |
| 883 | * Decode the JSON from "reader" to find the end of the message. |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 884 | * "options" can be JSON_JS or zero; |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 885 | * Return FAIL if the message has a decoding error. |
| 886 | * Return MAYBE if the message is truncated, need to read more. |
| 887 | * This only works reliable if the message contains an object, array or |
| 888 | * string. A number might be trucated without knowing. |
| 889 | * Does not advance the reader. |
| 890 | */ |
| 891 | int |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 892 | json_find_end(js_read_T *reader, int options) |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 893 | { |
| 894 | int used_save = reader->js_used; |
| 895 | int ret; |
| 896 | |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 897 | /* We find the end once, to avoid calling strlen() many times. */ |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 898 | reader->js_end = reader->js_buf + STRLEN(reader->js_buf); |
| 899 | json_skip_white(reader); |
Bram Moolenaar | 595e64e | 2016-02-07 19:19:53 +0100 | [diff] [blame] | 900 | ret = json_decode_item(reader, NULL, options); |
Bram Moolenaar | 56ead34 | 2016-02-02 18:20:08 +0100 | [diff] [blame] | 901 | reader->js_used = used_save; |
| 902 | return ret; |
| 903 | } |
Bram Moolenaar | 520e1e4 | 2016-01-23 19:46:28 +0100 | [diff] [blame] | 904 | #endif |