← Back to branch summary

~stub/ubuntu/trusty/avro-c/trunk

« back to all changes in this revision

Viewing changes to jansson/src/load.c

  • Committer: Stuart Bishop
  • Date: 2015-05-14 11:53:53 UTC
  • Revision ID: stuart@stuartbishop.net-20150514115353-0cvnrcyohcq5l7yj
Tags: upstream-1.7.7
Import upstream version 1.7.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
jansson/src/load.c
 
1
/*
 
2
 * Copyright (c) 2009-2011 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 <ctype.h>
 
10
#include <errno.h>
 
11
#include <limits.h>
 
12
#include <stdio.h>
 
13
#include <stdlib.h>
 
14
#include <string.h>
 
15
#include <assert.h>
 
16
 
 
17
#include <jansson.h>
 
18
#include "jansson_private.h"
 
19
#include "strbuffer.h"
 
20
#include "utf.h"
 
21
 
 
22
#define STREAM_STATE_OK        0
 
23
#define STREAM_STATE_EOF      -1
 
24
#define STREAM_STATE_ERROR    -2
 
25
 
 
26
#define TOKEN_INVALID         -1
 
27
#define TOKEN_EOF              0
 
28
#define TOKEN_STRING         256
 
29
#define TOKEN_INTEGER        257
 
30
#define TOKEN_REAL           258
 
31
#define TOKEN_TRUE           259
 
32
#define TOKEN_FALSE          260
 
33
#define TOKEN_NULL           261
 
34
 
 
35
/* Read one byte from stream, convert to unsigned char, then int, and
 
36
   return. return EOF on end of file. This corresponds to the
 
37
   behaviour of fgetc(). */
 
38
typedef int (*get_func)(void *data);
 
39
 
 
40
typedef struct {
 
41
    get_func get;
 
42
    void *data;
 
43
    char buffer[5];
 
44
    int buffer_pos;
 
45
    int state;
 
46
    int line;
 
47
    int column, last_column;
 
48
    size_t position;
 
49
} stream_t;
 
50
 
 
51
typedef struct {
 
52
    stream_t stream;
 
53
    strbuffer_t saved_text;
 
54
    int token;
 
55
    union {
 
56
        char *string;
 
57
        json_int_t integer;
 
58
        double real;
 
59
    } value;
 
60
} lex_t;
 
61
 
 
62
#define stream_to_lex(stream) container_of(stream, lex_t, stream)
 
63
 
 
64
 
 
65
/*** error reporting ***/
 
66
 
 
67
static void error_set(json_error_t *error, const lex_t *lex,
 
68
                      const char *msg, ...)
 
69
{
 
70
    va_list ap;
 
71
    char msg_text[JSON_ERROR_TEXT_LENGTH];
 
72
 
 
73
    int line = -1, col = -1;
 
74
    size_t pos = 0;
 
75
    const char *result = msg_text;
 
76
 
 
77
    if(!error)
 
78
        return;
 
79
 
 
80
    va_start(ap, msg);
 
81
    vsnprintf(msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
 
82
    va_end(ap);
 
83
 
 
84
    if(lex)
 
85
    {
 
86
        const char *saved_text = strbuffer_value(&lex->saved_text);
 
87
        char msg_with_context[JSON_ERROR_TEXT_LENGTH];
 
88
 
 
89
        line = lex->stream.line;
 
90
        col = lex->stream.column;
 
91
        pos = lex->stream.position;
 
92
 
 
93
        if(saved_text && saved_text[0])
 
94
        {
 
95
            if(lex->saved_text.length <= 20) {
 
96
                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH,
 
97
                         "%s near '%s'", msg_text, saved_text);
 
98
                result = msg_with_context;
 
99
            }
 
100
        }
 
101
        else
 
102
        {
 
103
            if(lex->stream.state == STREAM_STATE_ERROR) {
 
104
                /* No context for UTF-8 decoding errors */
 
105
                result = msg_text;
 
106
            }
 
107
            else {
 
108
                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH,
 
109
                         "%s near end of file", msg_text);
 
110
                result = msg_with_context;
 
111
            }
 
112
        }
 
113
    }
 
114
 
 
115
    jsonp_error_set(error, line, col, pos, "%s", result);
 
116
}
 
117
 
 
118
 
 
119
/*** lexical analyzer ***/
 
120
 
 
121
static void
 
122
stream_init(stream_t *stream, get_func get, void *data)
 
123
{
 
124
    stream->get = get;
 
125
    stream->data = data;
 
126
    stream->buffer[0] = '\0';
 
127
    stream->buffer_pos = 0;
 
128
 
 
129
    stream->state = STREAM_STATE_OK;
 
130
    stream->line = 1;
 
131
    stream->column = 0;
 
132
    stream->position = 0;
 
133
}
 
134
 
 
135
static int stream_get(stream_t *stream, json_error_t *error)
 
136
{
 
137
    int c;
 
138
 
 
139
    if(stream->state != STREAM_STATE_OK)
 
140
        return stream->state;
 
141
 
 
142
    if(!stream->buffer[stream->buffer_pos])
 
143
    {
 
144
        c = stream->get(stream->data);
 
145
        if(c == EOF) {
 
146
            stream->state = STREAM_STATE_EOF;
 
147
            return STREAM_STATE_EOF;
 
148
        }
 
149
 
 
150
        stream->buffer[0] = c;
 
151
        stream->buffer_pos = 0;
 
152
 
 
153
        if(0x80 <= c && c <= 0xFF)
 
154
        {
 
155
            /* multi-byte UTF-8 sequence */
 
156
            int i, count;
 
157
 
 
158
            count = utf8_check_first(c);
 
159
            if(!count)
 
160
                goto out;
 
161
 
 
162
            assert(count >= 2);
 
163
 
 
164
            for(i = 1; i < count; i++)
 
165
                stream->buffer[i] = stream->get(stream->data);
 
166
 
 
167
            if(!utf8_check_full(stream->buffer, count, NULL))
 
168
                goto out;
 
169
 
 
170
            stream->buffer[count] = '\0';
 
171
        }
 
172
        else
 
173
            stream->buffer[1] = '\0';
 
174
    }
 
175
 
 
176
    c = stream->buffer[stream->buffer_pos++];
 
177
 
 
178
    stream->position++;
 
179
    if(c == '\n') {
 
180
        stream->line++;
 
181
        stream->last_column = stream->column;
 
182
        stream->column = 0;
 
183
    }
 
184
    else if(utf8_check_first(c)) {
 
185
        /* track the Unicode character column, so increment only if
 
186
           this is the first character of a UTF-8 sequence */
 
187
        stream->column++;
 
188
    }
 
189
 
 
190
    return c;
 
191
 
 
192
out:
 
193
    stream->state = STREAM_STATE_ERROR;
 
194
    error_set(error, stream_to_lex(stream), "unable to decode byte 0x%x", c);
 
195
    return STREAM_STATE_ERROR;
 
196
}
 
197
 
 
198
static void stream_unget(stream_t *stream, int c)
 
199
{
 
200
    if(c == STREAM_STATE_EOF || c == STREAM_STATE_ERROR)
 
201
        return;
 
202
 
 
203
    stream->position--;
 
204
    if(c == '\n') {
 
205
        stream->line--;
 
206
        stream->column = stream->last_column;
 
207
    }
 
208
    else if(utf8_check_first(c))
 
209
        stream->column--;
 
210
 
 
211
    assert(stream->buffer_pos > 0);
 
212
    stream->buffer_pos--;
 
213
    assert(stream->buffer[stream->buffer_pos] == c);
 
214
}
 
215
 
 
216
 
 
217
static int lex_get(lex_t *lex, json_error_t *error)
 
218
{
 
219
    return stream_get(&lex->stream, error);
 
220
}
 
221
 
 
222
static void lex_save(lex_t *lex, int c)
 
223
{
 
224
    strbuffer_append_byte(&lex->saved_text, c);
 
225
}
 
226
 
 
227
static int lex_get_save(lex_t *lex, json_error_t *error)
 
228
{
 
229
    int c = stream_get(&lex->stream, error);
 
230
    if(c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR)
 
231
        lex_save(lex, c);
 
232
    return c;
 
233
}
 
234
 
 
235
static void lex_unget(lex_t *lex, int c)
 
236
{
 
237
    stream_unget(&lex->stream, c);
 
238
}
 
239
 
 
240
static void lex_unget_unsave(lex_t *lex, int c)
 
241
{
 
242
    if(c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR) {
 
243
        char d;
 
244
        stream_unget(&lex->stream, c);
 
245
        d = strbuffer_pop(&lex->saved_text);
 
246
        assert(c == d);
 
247
    }
 
248
}
 
249
 
 
250
static void lex_save_cached(lex_t *lex)
 
251
{
 
252
    while(lex->stream.buffer[lex->stream.buffer_pos] != '\0')
 
253
    {
 
254
        lex_save(lex, lex->stream.buffer[lex->stream.buffer_pos]);
 
255
        lex->stream.buffer_pos++;
 
256
        lex->stream.position++;
 
257
    }
 
258
}
 
259
 
 
260
/* assumes that str points to 'u' plus at least 4 valid hex digits */
 
261
static int32_t decode_unicode_escape(const char *str)
 
262
{
 
263
    int i;
 
264
    int32_t value = 0;
 
265
 
 
266
    assert(str[0] == 'u');
 
267
 
 
268
    for(i = 1; i <= 4; i++) {
 
269
        char c = str[i];
 
270
        value <<= 4;
 
271
        if(isdigit(c))
 
272
            value += c - '0';
 
273
        else if(islower(c))
 
274
            value += c - 'a' + 10;
 
275
        else if(isupper(c))
 
276
            value += c - 'A' + 10;
 
277
        else
 
278
            assert(0);
 
279
    }
 
280
 
 
281
    return value;
 
282
}
 
283
 
 
284
static void lex_scan_string(lex_t *lex, json_error_t *error)
 
285
{
 
286
    int c;
 
287
    const char *p;
 
288
    char *t;
 
289
    int i;
 
290
 
 
291
    lex->value.string = NULL;
 
292
    lex->token = TOKEN_INVALID;
 
293
 
 
294
    c = lex_get_save(lex, error);
 
295
 
 
296
    while(c != '"') {
 
297
        if(c == STREAM_STATE_ERROR)
 
298
            goto out;
 
299
 
 
300
        else if(c == STREAM_STATE_EOF) {
 
301
            error_set(error, lex, "premature end of input");
 
302
            goto out;
 
303
        }
 
304
 
 
305
        else if(0 <= c && c <= 0x1F) {
 
306
            /* control character */
 
307
            lex_unget_unsave(lex, c);
 
308
            if(c == '\n')
 
309
                error_set(error, lex, "unexpected newline", c);
 
310
            else
 
311
                error_set(error, lex, "control character 0x%x", c);
 
312
            goto out;
 
313
        }
 
314
 
 
315
        else if(c == '\\') {
 
316
            c = lex_get_save(lex, error);
 
317
            if(c == 'u') {
 
318
                c = lex_get_save(lex, error);
 
319
                for(i = 0; i < 4; i++) {
 
320
                    if(!isxdigit(c)) {
 
321
                        error_set(error, lex, "invalid escape");
 
322
                        goto out;
 
323
                    }
 
324
                    c = lex_get_save(lex, error);
 
325
                }
 
326
            }
 
327
            else if(c == '"' || c == '\\' || c == '/' || c == 'b' ||
 
328
                    c == 'f' || c == 'n' || c == 'r' || c == 't')
 
329
                c = lex_get_save(lex, error);
 
330
            else {
 
331
                error_set(error, lex, "invalid escape");
 
332
                goto out;
 
333
            }
 
334
        }
 
335
        else
 
336
            c = lex_get_save(lex, error);
 
337
    }
 
338
 
 
339
    /* the actual value is at most of the same length as the source
 
340
       string, because:
 
341
         - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
 
342
         - a single \uXXXX escape (length 6) is converted to at most 3 bytes
 
343
         - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
 
344
           are converted to 4 bytes
 
345
    */
 
346
    lex->value.string = (char *) jsonp_malloc(lex->saved_text.length + 1);
 
347
    if(!lex->value.string) {
 
348
        /* this is not very nice, since TOKEN_INVALID is returned */
 
349
        goto out;
 
350
    }
 
351
 
 
352
    /* the target */
 
353
    t = lex->value.string;
 
354
 
 
355
    /* + 1 to skip the " */
 
356
    p = strbuffer_value(&lex->saved_text) + 1;
 
357
 
 
358
    while(*p != '"') {
 
359
        if(*p == '\\') {
 
360
            p++;
 
361
            if(*p == 'u') {
 
362
                char buffer[4];
 
363
                int length;
 
364
                int32_t value;
 
365
 
 
366
                value = decode_unicode_escape(p);
 
367
                p += 5;
 
368
 
 
369
                if(0xD800 <= value && value <= 0xDBFF) {
 
370
                    /* surrogate pair */
 
371
                    if(*p == '\\' && *(p + 1) == 'u') {
 
372
                        int32_t value2 = decode_unicode_escape(++p);
 
373
                        p += 5;
 
374
 
 
375
                        if(0xDC00 <= value2 && value2 <= 0xDFFF) {
 
376
                            /* valid second surrogate */
 
377
                            value =
 
378
                                ((value - 0xD800) << 10) +
 
379
                                (value2 - 0xDC00) +
 
380
                                0x10000;
 
381
                        }
 
382
                        else {
 
383
                            /* invalid second surrogate */
 
384
                            error_set(error, lex,
 
385
                                      "invalid Unicode '\\u%04X\\u%04X'",
 
386
                                      value, value2);
 
387
                            goto out;
 
388
                        }
 
389
                    }
 
390
                    else {
 
391
                        /* no second surrogate */
 
392
                        error_set(error, lex, "invalid Unicode '\\u%04X'",
 
393
                                  value);
 
394
                        goto out;
 
395
                    }
 
396
                }
 
397
                else if(0xDC00 <= value && value <= 0xDFFF) {
 
398
                    error_set(error, lex, "invalid Unicode '\\u%04X'", value);
 
399
                    goto out;
 
400
                }
 
401
                else if(value == 0)
 
402
                {
 
403
                    error_set(error, lex, "\\u0000 is not allowed");
 
404
                    goto out;
 
405
                }
 
406
 
 
407
                if(utf8_encode(value, buffer, &length))
 
408
                    assert(0);
 
409
 
 
410
                memcpy(t, buffer, length);
 
411
                t += length;
 
412
            }
 
413
            else {
 
414
                switch(*p) {
 
415
                    case '"': case '\\': case '/':
 
416
                        *t = *p; break;
 
417
                    case 'b': *t = '\b'; break;
 
418
                    case 'f': *t = '\f'; break;
 
419
                    case 'n': *t = '\n'; break;
 
420
                    case 'r': *t = '\r'; break;
 
421
                    case 't': *t = '\t'; break;
 
422
                    default: assert(0);
 
423
                }
 
424
                t++;
 
425
                p++;
 
426
            }
 
427
        }
 
428
        else
 
429
            *(t++) = *(p++);
 
430
    }
 
431
    *t = '\0';
 
432
    lex->token = TOKEN_STRING;
 
433
    return;
 
434
 
 
435
out:
 
436
    jsonp_free(lex->value.string);
 
437
}
 
438
 
 
439
#if JSON_INTEGER_IS_LONG_LONG
 
440
#ifdef _WIN32
 
441
#define json_strtoint     _strtoi64
 
442
#else
 
443
#define json_strtoint     strtoll
 
444
#endif
 
445
#else
 
446
#define json_strtoint     strtol
 
447
#endif
 
448
 
 
449
static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
 
450
{
 
451
    const char *saved_text;
 
452
    char *end;
 
453
    double value;
 
454
 
 
455
    lex->token = TOKEN_INVALID;
 
456
 
 
457
    if(c == '-')
 
458
        c = lex_get_save(lex, error);
 
459
 
 
460
    if(c == '0') {
 
461
        c = lex_get_save(lex, error);
 
462
        if(isdigit(c)) {
 
463
            lex_unget_unsave(lex, c);
 
464
            goto out;
 
465
        }
 
466
    }
 
467
    else if(isdigit(c)) {
 
468
        c = lex_get_save(lex, error);
 
469
        while(isdigit(c))
 
470
            c = lex_get_save(lex, error);
 
471
    }
 
472
    else {
 
473
        lex_unget_unsave(lex, c);
 
474
        goto out;
 
475
    }
 
476
 
 
477
    if(c != '.' && c != 'E' && c != 'e') {
 
478
        json_int_t value;
 
479
 
 
480
        lex_unget_unsave(lex, c);
 
481
 
 
482
        saved_text = strbuffer_value(&lex->saved_text);
 
483
 
 
484
        errno = 0;
 
485
        value = json_strtoint(saved_text, &end, 10);
 
486
        if(errno == ERANGE) {
 
487
            if(value < 0)
 
488
                error_set(error, lex, "too big negative integer");
 
489
            else
 
490
                error_set(error, lex, "too big integer");
 
491
            goto out;
 
492
        }
 
493
 
 
494
        assert(end == saved_text + lex->saved_text.length);
 
495
 
 
496
        lex->token = TOKEN_INTEGER;
 
497
        lex->value.integer = value;
 
498
        return 0;
 
499
    }
 
500
 
 
501
    if(c == '.') {
 
502
        c = lex_get(lex, error);
 
503
        if(!isdigit(c)) {
 
504
            lex_unget(lex, c);
 
505
            goto out;
 
506
        }
 
507
        lex_save(lex, c);
 
508
 
 
509
        c = lex_get_save(lex, error);
 
510
        while(isdigit(c))
 
511
            c = lex_get_save(lex, error);
 
512
    }
 
513
 
 
514
    if(c == 'E' || c == 'e') {
 
515
        c = lex_get_save(lex, error);
 
516
        if(c == '+' || c == '-')
 
517
            c = lex_get_save(lex, error);
 
518
 
 
519
        if(!isdigit(c)) {
 
520
            lex_unget_unsave(lex, c);
 
521
            goto out;
 
522
        }
 
523
 
 
524
        c = lex_get_save(lex, error);
 
525
        while(isdigit(c))
 
526
            c = lex_get_save(lex, error);
 
527
    }
 
528
 
 
529
    lex_unget_unsave(lex, c);
 
530
 
 
531
    saved_text = strbuffer_value(&lex->saved_text);
 
532
    errno = 0;
 
533
    value = strtod(saved_text, &end);
 
534
    assert(end == saved_text + lex->saved_text.length);
 
535
 
 
536
    if(errno == ERANGE && value != 0) {
 
537
        error_set(error, lex, "real number overflow");
 
538
        goto out;
 
539
    }
 
540
 
 
541
    lex->token = TOKEN_REAL;
 
542
    lex->value.real = value;
 
543
    return 0;
 
544
 
 
545
out:
 
546
    return -1;
 
547
}
 
548
 
 
549
static int lex_scan(lex_t *lex, json_error_t *error)
 
550
{
 
551
    int c;
 
552
 
 
553
    strbuffer_clear(&lex->saved_text);
 
554
 
 
555
    if(lex->token == TOKEN_STRING) {
 
556
        jsonp_free(lex->value.string);
 
557
        lex->value.string = NULL;
 
558
    }
 
559
 
 
560
    c = lex_get(lex, error);
 
561
    while(c == ' ' || c == '\t' || c == '\n' || c == '\r')
 
562
        c = lex_get(lex, error);
 
563
 
 
564
    if(c == STREAM_STATE_EOF) {
 
565
        lex->token = TOKEN_EOF;
 
566
        goto out;
 
567
    }
 
568
 
 
569
    if(c == STREAM_STATE_ERROR) {
 
570
        lex->token = TOKEN_INVALID;
 
571
        goto out;
 
572
    }
 
573
 
 
574
    lex_save(lex, c);
 
575
 
 
576
    if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
 
577
        lex->token = c;
 
578
 
 
579
    else if(c == '"')
 
580
        lex_scan_string(lex, error);
 
581
 
 
582
    else if(isdigit(c) || c == '-') {
 
583
        if(lex_scan_number(lex, c, error))
 
584
            goto out;
 
585
    }
 
586
 
 
587
    else if(isupper(c) || islower(c)) {
 
588
        /* eat up the whole identifier for clearer error messages */
 
589
        const char *saved_text;
 
590
 
 
591
        c = lex_get_save(lex, error);
 
592
        while(isupper(c) || islower(c))
 
593
            c = lex_get_save(lex, error);
 
594
        lex_unget_unsave(lex, c);
 
595
 
 
596
        saved_text = strbuffer_value(&lex->saved_text);
 
597
 
 
598
        if(strcmp(saved_text, "true") == 0)
 
599
            lex->token = TOKEN_TRUE;
 
600
        else if(strcmp(saved_text, "false") == 0)
 
601
            lex->token = TOKEN_FALSE;
 
602
        else if(strcmp(saved_text, "null") == 0)
 
603
            lex->token = TOKEN_NULL;
 
604
        else
 
605
            lex->token = TOKEN_INVALID;
 
606
    }
 
607
 
 
608
    else {
 
609
        /* save the rest of the input UTF-8 sequence to get an error
 
610
           message of valid UTF-8 */
 
611
        lex_save_cached(lex);
 
612
        lex->token = TOKEN_INVALID;
 
613
    }
 
614
 
 
615
out:
 
616
    return lex->token;
 
617
}
 
618
 
 
619
static char *lex_steal_string(lex_t *lex)
 
620
{
 
621
    char *result = NULL;
 
622
    if(lex->token == TOKEN_STRING)
 
623
    {
 
624
        result = lex->value.string;
 
625
        lex->value.string = NULL;
 
626
    }
 
627
    return result;
 
628
}
 
629
 
 
630
static int lex_init(lex_t *lex, get_func get, void *data)
 
631
{
 
632
    stream_init(&lex->stream, get, data);
 
633
    if(strbuffer_init(&lex->saved_text))
 
634
        return -1;
 
635
 
 
636
    lex->token = TOKEN_INVALID;
 
637
    return 0;
 
638
}
 
639
 
 
640
static void lex_close(lex_t *lex)
 
641
{
 
642
    if(lex->token == TOKEN_STRING)
 
643
        jsonp_free(lex->value.string);
 
644
    strbuffer_close(&lex->saved_text);
 
645
}
 
646
 
 
647
 
 
648
/*** parser ***/
 
649
 
 
650
static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error);
 
651
 
 
652
static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
 
653
{
 
654
    json_t *object = json_object();
 
655
    if(!object)
 
656
        return NULL;
 
657
 
 
658
    lex_scan(lex, error);
 
659
    if(lex->token == '}')
 
660
        return object;
 
661
 
 
662
    while(1) {
 
663
        char *key;
 
664
        json_t *value;
 
665
 
 
666
        if(lex->token != TOKEN_STRING) {
 
667
            error_set(error, lex, "string or '}' expected");
 
668
            goto error;
 
669
        }
 
670
 
 
671
        key = lex_steal_string(lex);
 
672
        if(!key)
 
673
            return NULL;
 
674
 
 
675
        if(flags & JSON_REJECT_DUPLICATES) {
 
676
            if(json_object_get(object, key)) {
 
677
                jsonp_free(key);
 
678
                error_set(error, lex, "duplicate object key");
 
679
                goto error;
 
680
            }
 
681
        }
 
682
 
 
683
        lex_scan(lex, error);
 
684
        if(lex->token != ':') {
 
685
            jsonp_free(key);
 
686
            error_set(error, lex, "':' expected");
 
687
            goto error;
 
688
        }
 
689
 
 
690
        lex_scan(lex, error);
 
691
        value = parse_value(lex, flags, error);
 
692
        if(!value) {
 
693
            jsonp_free(key);
 
694
            goto error;
 
695
        }
 
696
 
 
697
        if(json_object_set_nocheck(object, key, value)) {
 
698
            jsonp_free(key);
 
699
            json_decref(value);
 
700
            goto error;
 
701
        }
 
702
 
 
703
        json_decref(value);
 
704
        jsonp_free(key);
 
705
 
 
706
        lex_scan(lex, error);
 
707
        if(lex->token != ',')
 
708
            break;
 
709
 
 
710
        lex_scan(lex, error);
 
711
    }
 
712
 
 
713
    if(lex->token != '}') {
 
714
        error_set(error, lex, "'}' expected");
 
715
        goto error;
 
716
    }
 
717
 
 
718
    return object;
 
719
 
 
720
error:
 
721
    json_decref(object);
 
722
    return NULL;
 
723
}
 
724
 
 
725
static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
 
726
{
 
727
    json_t *array = json_array();
 
728
    if(!array)
 
729
        return NULL;
 
730
 
 
731
    lex_scan(lex, error);
 
732
    if(lex->token == ']')
 
733
        return array;
 
734
 
 
735
    while(lex->token) {
 
736
        json_t *elem = parse_value(lex, flags, error);
 
737
        if(!elem)
 
738
            goto error;
 
739
 
 
740
        if(json_array_append(array, elem)) {
 
741
            json_decref(elem);
 
742
            goto error;
 
743
        }
 
744
        json_decref(elem);
 
745
 
 
746
        lex_scan(lex, error);
 
747
        if(lex->token != ',')
 
748
            break;
 
749
 
 
750
        lex_scan(lex, error);
 
751
    }
 
752
 
 
753
    if(lex->token != ']') {
 
754
        error_set(error, lex, "']' expected");
 
755
        goto error;
 
756
    }
 
757
 
 
758
    return array;
 
759
 
 
760
error:
 
761
    json_decref(array);
 
762
    return NULL;
 
763
}
 
764
 
 
765
static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
 
766
{
 
767
    json_t *json;
 
768
 
 
769
    switch(lex->token) {
 
770
        case TOKEN_STRING: {
 
771
            json = json_string_nocheck(lex->value.string);
 
772
            break;
 
773
        }
 
774
 
 
775
        case TOKEN_INTEGER: {
 
776
            json = json_integer(lex->value.integer);
 
777
            break;
 
778
        }
 
779
 
 
780
        case TOKEN_REAL: {
 
781
            json = json_real(lex->value.real);
 
782
            break;
 
783
        }
 
784
 
 
785
        case TOKEN_TRUE:
 
786
            json = json_true();
 
787
            break;
 
788
 
 
789
        case TOKEN_FALSE:
 
790
            json = json_false();
 
791
            break;
 
792
 
 
793
        case TOKEN_NULL:
 
794
            json = json_null();
 
795
            break;
 
796
 
 
797
        case '{':
 
798
            json = parse_object(lex, flags, error);
 
799
            break;
 
800
 
 
801
        case '[':
 
802
            json = parse_array(lex, flags, error);
 
803
            break;
 
804
 
 
805
        case TOKEN_INVALID:
 
806
            error_set(error, lex, "invalid token");
 
807
            return NULL;
 
808
 
 
809
        default:
 
810
            error_set(error, lex, "unexpected token");
 
811
            return NULL;
 
812
    }
 
813
 
 
814
    if(!json)
 
815
        return NULL;
 
816
 
 
817
    return json;
 
818
}
 
819
 
 
820
static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
 
821
{
 
822
    json_t *result;
 
823
 
 
824
    lex_scan(lex, error);
 
825
    if(lex->token != '[' && lex->token != '{') {
 
826
        error_set(error, lex, "'[' or '{' expected");
 
827
        return NULL;
 
828
    }
 
829
 
 
830
    result = parse_value(lex, flags, error);
 
831
    if(!result)
 
832
        return NULL;
 
833
 
 
834
    if(!(flags & JSON_DISABLE_EOF_CHECK)) {
 
835
        lex_scan(lex, error);
 
836
        if(lex->token != TOKEN_EOF) {
 
837
            error_set(error, lex, "end of file expected");
 
838
            json_decref(result);
 
839
            result = NULL;
 
840
        }
 
841
    }
 
842
 
 
843
    return result;
 
844
}
 
845
 
 
846
typedef struct
 
847
{
 
848
    const char *data;
 
849
    int pos;
 
850
} string_data_t;
 
851
 
 
852
static int string_get(void *data)
 
853
{
 
854
    char c;
 
855
    string_data_t *stream = (string_data_t *)data;
 
856
    c = stream->data[stream->pos];
 
857
    if(c == '\0')
 
858
        return EOF;
 
859
    else
 
860
    {
 
861
        stream->pos++;
 
862
        return (unsigned char)c;
 
863
    }
 
864
}
 
865
 
 
866
json_t *json_loads(const char *string, size_t flags, json_error_t *error)
 
867
{
 
868
    lex_t lex;
 
869
    json_t *result;
 
870
    string_data_t stream_data;
 
871
 
 
872
    stream_data.data = string;
 
873
    stream_data.pos = 0;
 
874
 
 
875
    if(lex_init(&lex, string_get, (void *)&stream_data))
 
876
        return NULL;
 
877
 
 
878
    jsonp_error_init(error, "<string>");
 
879
    result = parse_json(&lex, flags, error);
 
880
 
 
881
    lex_close(&lex);
 
882
    return result;
 
883
}
 
884
 
 
885
typedef struct
 
886
{
 
887
    const char *data;
 
888
    size_t len;
 
889
    size_t pos;
 
890
} buffer_data_t;
 
891
 
 
892
static int buffer_get(void *data)
 
893
{
 
894
    char c;
 
895
    buffer_data_t *stream = (buffer_data_t *) data;
 
896
    if(stream->pos >= stream->len)
 
897
      return EOF;
 
898
 
 
899
    c = stream->data[stream->pos];
 
900
    stream->pos++;
 
901
    return (unsigned char)c;
 
902
}
 
903
 
 
904
json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error)
 
905
{
 
906
    lex_t lex;
 
907
    json_t *result;
 
908
    buffer_data_t stream_data;
 
909
 
 
910
    stream_data.data = buffer;
 
911
    stream_data.pos = 0;
 
912
    stream_data.len = buflen;
 
913
 
 
914
    if(lex_init(&lex, buffer_get, (void *)&stream_data))
 
915
        return NULL;
 
916
 
 
917
    jsonp_error_init(error, "<buffer>");
 
918
    result = parse_json(&lex, flags, error);
 
919
 
 
920
    lex_close(&lex);
 
921
    return result;
 
922
}
 
923
 
 
924
json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
 
925
{
 
926
    lex_t lex;
 
927
    const char *source;
 
928
    json_t *result;
 
929
 
 
930
    if(lex_init(&lex, (get_func)fgetc, input))
 
931
        return NULL;
 
932
 
 
933
    if(input == stdin)
 
934
        source = "<stdin>";
 
935
    else
 
936
        source = "<stream>";
 
937
 
 
938
    jsonp_error_init(error, source);
 
939
    result = parse_json(&lex, flags, error);
 
940
 
 
941
    lex_close(&lex);
 
942
    return result;
 
943
}
 
944
 
 
945
json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
 
946
{
 
947
    json_t *result;
 
948
    FILE *fp;
 
949
 
 
950
    jsonp_error_init(error, path);
 
951
 
 
952
    fp = fopen(path, "r");
 
953
    if(!fp)
 
954
    {
 
955
        error_set(error, NULL, "unable to open %s: %s",
 
956
                  path, strerror(errno));
 
957
        return NULL;
 
958
    }
 
959
 
 
960
    result = json_loadf(fp, flags, error);
 
961
 
 
962
    fclose(fp);
 
963
    return result;
 
964
}