source: trunk/libtransmission/JSON_parser.c @ 6912

Last change on this file since 6912 was 6912, checked in by charles, 13 years ago

(libT) apply some changes from Spry's code

File size: 35.5 KB
Line 
1/* JSON_parser.c */
2
3/* 2007-08-24 */
4
5/*
6   Copyright (c) 2005 JSON.org
7
8   Permission is hereby granted, free of charge, to any person obtaining a copy
9   of this software and associated documentation files (the "Software"), to deal
10   in the Software without restriction, including without limitation the rights
11   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12   copies of the Software, and to permit persons to whom the Software is
13   furnished to do so, subject to the following conditions:
14
15   The above copyright notice and this permission notice shall be included in
16   all
17   copies or substantial portions of the Software.
18
19   The Software shall be used for Good, not Evil.
20
21   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27   SOFTWARE.
28 */
29
30/*
31    Callbacks, comments, Unicode handling by Jean Gressmann (jean@0x42.de),
32   2007-2008.
33
34    For the added features the license above applies also.
35
36    Changelog:
37        2008/07/19
38            - Removed some duplicate code & debugging variable
39   (Charles.Kerr@noaa.gov)
40
41        2008/05/28
42            - Made JSON_value structure ansi C compliant. This bug was report by
43              trisk@acm.jhu.edu
44
45        2008/05/20
46            - Fixed bug reported by Charles.Kerr@noaa.gov where the switching
47              from static to dynamic parse buffer did not copy the static parse
48              buffer's content.
49 */
50
51
52#include <assert.h>
53#include <ctype.h>
54#include <float.h>
55#include <stddef.h>
56#include <stdio.h>
57#include <stdlib.h>
58#include <string.h>
59
60#include "JSON_parser.h"
61#include "ConvertUTF.h"
62
63#if _MSC_VER >= 1400 /* Visual Studio 2005 and up */
64 #pragma warning(disable:4996) /* unsecure sscanf */
65#endif
66
67
68#define true  1
69#define false 0
70#define __   -1     /* the universal error code */
71
72/* values chosen so that the object size is approx equal to one page (4K) */
73#ifndef JSON_PARSER_STACK_SIZE
74 #define JSON_PARSER_STACK_SIZE 128
75#endif
76
77#ifndef JSON_PARSER_PARSE_BUFFER_SIZE
78 #define JSON_PARSER_PARSE_BUFFER_SIZE 3500
79#endif
80
81
82typedef struct JSON_parser_struct
83{
84    JSON_parser_callback    callback;
85    void*                   ctx;
86    signed char             state, before_comment_state, type, escaped,
87                            comment, allow_comments, handle_floats_manually;
88    UTF16                   utf16_decode_buffer[2];
89    long                    depth;
90    long                    top;
91    signed char*            stack;
92    long                    stack_capacity;
93    signed char             static_stack[JSON_PARSER_STACK_SIZE];
94    char*                   parse_buffer;
95    size_t                  parse_buffer_capacity;
96    size_t                  parse_buffer_count;
97    size_t                  comment_begin_offset;
98    char                    static_parse_buffer[
99        JSON_PARSER_PARSE_BUFFER_SIZE];
100} * JSON_parser;
101
102#define COUNTOF( x ) ( sizeof( x ) / sizeof( x[0] ) )
103
104/*
105    Characters are mapped into these 31 character classes. This allows for
106    a significant reduction in the size of the state transition table.
107 */
108
109
110enum classes
111{
112    C_SPACE,  /* space */
113    C_WHITE,  /* other whitespace */
114    C_LCURB,  /* {  */
115    C_RCURB,  /* } */
116    C_LSQRB,  /* [ */
117    C_RSQRB,  /* ] */
118    C_COLON,  /* : */
119    C_COMMA,  /* , */
120    C_QUOTE,  /* " */
121    C_BACKS,  /* \ */
122    C_SLASH,  /* / */
123    C_PLUS,   /* + */
124    C_MINUS,  /* - */
125    C_POINT,  /* . */
126    C_ZERO,   /* 0 */
127    C_DIGIT,  /* 123456789 */
128    C_LOW_A,  /* a */
129    C_LOW_B,  /* b */
130    C_LOW_C,  /* c */
131    C_LOW_D,  /* d */
132    C_LOW_E,  /* e */
133    C_LOW_F,  /* f */
134    C_LOW_L,  /* l */
135    C_LOW_N,  /* n */
136    C_LOW_R,  /* r */
137    C_LOW_S,  /* s */
138    C_LOW_T,  /* t */
139    C_LOW_U,  /* u */
140    C_ABCDF,  /* ABCDF */
141    C_E,      /* E */
142    C_ETC,    /* everything else */
143    C_STAR,   /* * */
144    NR_CLASSES
145};
146
147static int ascii_class[128] = {
148/*
149    This array maps the 128 ASCII characters into character classes.
150    The remaining Unicode characters should be mapped to C_ETC.
151    Non-whitespace control characters are errors.
152 */
153    __,      __,           __,             __,             __,          __,
154    __,          __,
155    __,      C_WHITE,      C_WHITE,   __,        __,        C_WHITE,
156    __,          __,
157    __,      __,           __,        __,        __,        __,
158    __,          __,
159    __,      __,           __,        __,        __,        __,
160    __,          __,
161
162    C_SPACE, C_ETC,        C_QUOTE,   C_ETC,     C_ETC,     C_ETC,
163    C_ETC,       C_ETC,
164    C_ETC,   C_ETC,        C_STAR,    C_PLUS,    C_COMMA,   C_MINUS,
165    C_POINT,     C_SLASH,
166    C_ZERO,  C_DIGIT,      C_DIGIT,   C_DIGIT,   C_DIGIT,   C_DIGIT,
167    C_DIGIT,     C_DIGIT,
168    C_DIGIT, C_DIGIT,      C_COLON,   C_ETC,     C_ETC,     C_ETC,
169    C_ETC,       C_ETC,
170
171    C_ETC,   C_ABCDF,      C_ABCDF,   C_ABCDF,   C_ABCDF,   C_E,
172    C_ABCDF,     C_ETC,
173    C_ETC,   C_ETC,        C_ETC,     C_ETC,     C_ETC,     C_ETC,
174    C_ETC,       C_ETC,
175    C_ETC,   C_ETC,        C_ETC,     C_ETC,     C_ETC,     C_ETC,
176    C_ETC,       C_ETC,
177    C_ETC,   C_ETC,        C_ETC,     C_LSQRB,   C_BACKS,   C_RSQRB,
178    C_ETC,       C_ETC,
179
180    C_ETC,   C_LOW_A,      C_LOW_B,   C_LOW_C,   C_LOW_D,   C_LOW_E,
181    C_LOW_F,     C_ETC,
182    C_ETC,   C_ETC,        C_ETC,     C_ETC,     C_LOW_L,   C_ETC,
183    C_LOW_N,     C_ETC,
184    C_ETC,   C_ETC,        C_LOW_R,   C_LOW_S,   C_LOW_T,   C_LOW_U,
185    C_ETC,       C_ETC,
186    C_ETC,   C_ETC,        C_ETC,     C_LCURB,   C_ETC,     C_RCURB,
187    C_ETC,       C_ETC
188};
189
190// Temporary fix for Win32 target
191#if defined(WIN32) && defined(_WIN32) && defined(IN)
192#undef IN
193#endif
194
195/*
196    The state codes.
197 */
198enum states
199{
200    GO,  /* start    */
201    OK,  /* ok       */
202    OB,  /* object   */
203    KE,  /* key      */
204    CO,  /* colon    */
205    VA,  /* value    */
206    AR,  /* array    */
207    ST,  /* string   */
208    ES,  /* escape   */
209    U1,  /* u1       */
210    U2,  /* u2       */
211    U3,  /* u3       */
212    U4,  /* u4       */
213    MI,  /* minus    */
214    ZE,  /* zero     */
215    IN,  /* integer  */
216    FR,  /* fraction */
217    E1,  /* e        */
218    E2,  /* ex       */
219    E3,  /* exp      */
220    T1,  /* tr       */
221    T2,  /* tru      */
222    T3,  /* true     */
223    F1,  /* fa       */
224    F2,  /* fal      */
225    F3,  /* fals     */
226    F4,  /* false    */
227    N1,  /* nu       */
228    N2,  /* nul      */
229    N3,  /* null     */
230    C1,  /* /        */
231    C2,  /* / *     */
232    C3,  /* *        */
233    FX,  /* *.* *eE* */
234    D1,  /* second UTF-16 character decoding started by \ */
235    D2,  /* second UTF-16 character proceeded by u */
236    NR_STATES
237};
238
239enum actions
240{
241    CB = -10, /* comment begin */
242    CE = -11, /* comment end */
243    FA = -12, /* false */
244    TR = -13, /* false */
245    NU = -14, /* null */
246    DE = -15, /* double detected by exponent e E */
247    DF = -16, /* double detected by fraction . */
248    SB = -17, /* string begin */
249    MX = -18, /* integer detected by minus */
250    ZX = -19, /* integer detected by zero */
251    IX = -20, /* integer detected by 1-9 */
252    EX = -21, /* next char is escaped */
253    UC = -22, /* Unicode character read */
254};
255
256
257static int state_transition_table[NR_STATES][NR_CLASSES] = {
258/*
259    The state transition table takes the current state and the current symbol,
260    and returns either a new state or an action. An action is represented as a
261    negative number. A JSON text is accepted if at the end of the text the
262    state is OK and if the mode is MODE_DONE.
263
264                 white                                      1-9
265                                     ABCDF  etc
266             space |  {  }  [  ]  :  ,  "  \  /  +  -  .  0  |  a  b  c  d  e  f
267    l  n  r  s  t  u  |  E  |  * */
268/*start  GO*/ {GO, GO, -6, __, -5, __, __, __, __, __, CB, __, __, __, __,
269               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
270               __, __},
271/*ok     OK*/ {OK, OK, __, -8, __, -7, __, -3, __, __, CB, __, __, __, __,
272               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
273               __, __},
274/*object OB*/ {OB, OB, __, -9, __, __, __, __, SB, __, CB, __, __, __, __,
275               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
276               __, __},
277/*key    KE*/ {KE, KE, __, __, __, __, __, __, SB, __, CB, __, __, __, __,
278               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
279               __, __},
280/*colon  CO*/ {CO, CO, __, __, __, __, -2, __, __, __, CB, __, __, __, __,
281               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
282               __, __},
283/*value  VA*/ {VA, VA, -6, __, -5, __, __, __, SB, __, CB, __, MX, __, ZX,
284               IX, __, __, __, __, __, FA, __, NU, __, __, TR, __, __, __,
285               __, __},
286/*array  AR*/ {AR, AR, -6, __, -5, -7, __, __, SB, __, CB, __, MX, __, ZX,
287               IX, __, __, __, __, __, FA, __, NU, __, __, TR, __, __, __,
288               __, __},
289/*string ST*/ {ST, __, ST, ST, ST, ST, ST, ST, -4, EX, ST, ST, ST, ST, ST,
290               ST, ST, ST, ST, ST, ST, ST, ST, ST, ST, ST, ST, ST, ST, ST,
291               ST, ST},
292/*escape ES*/ {__, __, __, __, __, __, __, __, ST, ST, ST, __, __, __, __,
293               __, __, ST, __, __, __, ST, __, ST, ST, __, ST, U1, __, __,
294               __, __},
295/*u1     U1*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, U2,
296               U2, U2, U2, U2, U2, U2, U2, __, __, __, __, __, __, U2, U2,
297               __, __},
298/*u2     U2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, U3,
299               U3, U3, U3, U3, U3, U3, U3, __, __, __, __, __, __, U3, U3,
300               __, __},
301/*u3     U3*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, U4,
302               U4, U4, U4, U4, U4, U4, U4, __, __, __, __, __, __, U4, U4,
303               __, __},
304/*u4     U4*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, UC,
305               UC, UC, UC, UC, UC, UC, UC, __, __, __, __, __, __, UC, UC,
306               __, __},
307/*minus  MI*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, ZE,
308               IN, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
309               __, __},
310/*zero   ZE*/ {OK, OK, __, -8, __, -7, __, -3, __, __, CB, __, __, DF, __,
311               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
312               __, __},
313/*int    IN*/ {OK, OK, __, -8, __, -7, __, -3, __, __, CB, __, __, DF, IN,
314               IN, __, __, __, __, DE, __, __, __, __, __, __, __, __, DE,
315               __, __},
316/*frac   FR*/ {OK, OK, __, -8, __, -7, __, -3, __, __, CB, __, __, __, FR,
317               FR, __, __, __, __, E1, __, __, __, __, __, __, __, __, E1,
318               __, __},
319/*e      E1*/ {__, __, __, __, __, __, __, __, __, __, __, E2, E2, __, E3,
320               E3, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
321               __, __},
322/*ex     E2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, E3,
323               E3, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
324               __, __},
325/*exp    E3*/ {OK, OK, __, -8, __, -7, __, -3, __, __, __, __, __, __, E3,
326               E3, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
327               __, __},
328/*tr     T1*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
329               __, __, __, __, __, __, __, __, __, T2, __, __, __, __, __,
330               __, __},
331/*tru    T2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
332               __, __, __, __, __, __, __, __, __, __, __, __, T3, __, __,
333               __, __},
334/*true   T3*/ {__, __, __, __, __, __, __, __, __, __, CB, __, __, __, __,
335               __, __, __, __, __, OK, __, __, __, __, __, __, __, __, __,
336               __, __},
337/*fa     F1*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
338               __, F2, __, __, __, __, __, __, __, __, __, __, __, __, __,
339               __, __},
340/*fal    F2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
341               __, __, __, __, __, __, __, F3, __, __, __, __, __, __, __,
342               __, __},
343/*fals   F3*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
344               __, __, __, __, __, __, __, __, __, __, F4, __, __, __, __,
345               __, __},
346/*false  F4*/ {__, __, __, __, __, __, __, __, __, __, CB, __, __, __, __,
347               __, __, __, __, __, OK, __, __, __, __, __, __, __, __, __,
348               __, __},
349/*nu     N1*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
350               __, __, __, __, __, __, __, __, __, __, __, __, N2, __, __,
351               __, __},
352/*nul    N2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
353               __, __, __, __, __, __, __, N3, __, __, __, __, __, __, __,
354               __, __},
355/*null   N3*/ {__, __, __, __, __, __, __, __, __, __, CB, __, __, __, __,
356               __, __, __, __, __, __, __, OK, __, __, __, __, __, __, __,
357               __, __},
358/*/      C1*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
359               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
360               __, C2},
361/*/*     C2*/ {C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2,
362               C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2,
363               C2, C3},
364/**      C3*/ {C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, CE, C2, C2, C2, C2,
365               C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2, C2,
366               C2, C3},
367/*_.     FX*/ {OK, OK, __, -8, __, -7, __, -3, __, __, __, __, __, __, FR,
368               FR, __, __, __, __, E1, __, __, __, __, __, __, __, __, E1,
369               __, __},
370/*\      D1*/ {__, __, __, __, __, __, __, __, __, D2, __, __, __, __, __,
371               __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
372               __, __},
373/*\      D2*/ {__, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
374               __, __, __, __, __, __, __, __, __, __, __, __, U1, __, __,
375               __, __},
376};
377
378
379/*
380    These modes can be pushed on the stack.
381 */
382enum modes
383{
384    MODE_ARRAY = 1,
385    MODE_DONE = 2,
386    MODE_KEY = 3,
387    MODE_OBJECT = 4
388};
389
390static int
391push( JSON_parser jc,
392      int         mode )
393{
394/*
395    Push a mode onto the stack. Return false if there is overflow.
396 */
397    jc->top += 1;
398    if( jc->depth < 0 )
399    {
400        if( jc->top >= jc->stack_capacity )
401        {
402            size_t bytes_to_allocate;
403            jc->stack_capacity *= 2;
404            bytes_to_allocate = jc->stack_capacity *
405                                sizeof( jc->static_stack[0] );
406            if( jc->stack == &jc->static_stack[0] )
407            {
408                jc->stack = (signed char*)malloc( bytes_to_allocate );
409                memcpy( jc->stack, jc->static_stack,
410                       sizeof( jc->static_stack ) );
411            }
412            else
413            {
414                jc->stack = (signed char*)realloc( jc->stack,
415                                                   bytes_to_allocate );
416            }
417        }
418    }
419    else
420    {
421        if( jc->top >= jc->depth )
422        {
423            return false;
424        }
425    }
426
427    jc->stack[jc->top] = mode;
428    return true;
429}
430
431static int
432pop( JSON_parser jc,
433     int         mode )
434{
435/*
436    Pop the stack, assuring that the current mode matches the expectation.
437    Return false if there is underflow or if the modes mismatch.
438 */
439    if( jc->top < 0 || jc->stack[jc->top] != mode )
440    {
441        return false;
442    }
443    jc->top -= 1;
444    return true;
445}
446
447#define parse_buffer_clear( jc ) \
448    do { \
449        jc->parse_buffer_count = 0; \
450        jc->parse_buffer[0] = 0; \
451    } while( 0 )
452
453#define parse_buffer_pop_back_char( jc ) \
454    do { \
455        assert( jc->parse_buffer_count >= 1 ); \
456        --jc->parse_buffer_count; \
457        jc->parse_buffer[jc->parse_buffer_count] = 0; \
458    } while( 0 )
459
460void
461delete_JSON_parser( JSON_parser jc )
462{
463    if( jc )
464    {
465        if( jc->stack != &jc->static_stack[0] )
466        {
467            free( (void*)jc->stack );
468        }
469        if( jc->parse_buffer != &jc->static_parse_buffer[0] )
470        {
471            free( (void*)jc->parse_buffer );
472        }
473        free( (void*)jc );
474    }
475}
476
477JSON_parser
478new_JSON_parser( JSON_config* config )
479{
480/*
481    new_JSON_parser starts the checking process by constructing a JSON_parser
482    object. It takes a depth parameter that restricts the level of maximum
483    nesting.
484
485    To continue the process, call JSON_parser_char for each character in the
486    JSON text, and then call JSON_parser_done to obtain the final result.
487    These functions are fully reentrant.
488 */
489
490    int         depth = 0;
491    JSON_config default_config;
492
493    JSON_parser jc = malloc( sizeof( struct JSON_parser_struct ) );
494
495    memset( jc, 0, sizeof( *jc ) );
496
497
498    /* initialize configuration */
499    init_JSON_config( &default_config );
500
501    /* set to default configuration if none was provided */
502    if( config == NULL )
503    {
504        config = &default_config;
505    }
506
507    depth = config->depth;
508
509    /* We need to be able to push at least one object */
510    if( depth == 0 )
511    {
512        depth = 1;
513    }
514
515    jc->state = GO;
516    jc->top = -1;
517
518    /* Do we want non-bound stack? */
519    if( depth > 0 )
520    {
521        jc->stack_capacity = depth;
522        jc->depth = depth;
523        if( depth <= (int)COUNTOF( jc->static_stack ) )
524        {
525            jc->stack = &jc->static_stack[0];
526        }
527        else
528        {
529            jc->stack =
530                (signed char*)malloc( jc->stack_capacity *
531                                     sizeof( jc->static_stack[0] ) );
532        }
533    }
534    else
535    {
536        jc->stack_capacity = COUNTOF( jc->static_stack );
537        jc->depth = -1;
538        jc->stack = &jc->static_stack[0];
539    }
540
541    /* set parser to start */
542    push( jc, MODE_DONE );
543
544    /* set up the parse buffer */
545    jc->parse_buffer = &jc->static_parse_buffer[0];
546    jc->parse_buffer_capacity = COUNTOF( jc->static_parse_buffer );
547    parse_buffer_clear( jc );
548
549    /* set up callback, comment & float handling */
550    jc->callback = config->callback;
551    jc->ctx = config->callback_ctx;
552    jc->allow_comments = config->allow_comments != 0;
553    jc->handle_floats_manually = config->handle_floats_manually != 0;
554    return jc;
555}
556
557static void
558grow_parse_buffer( JSON_parser jc )
559{
560    size_t bytes_to_allocate;
561
562    jc->parse_buffer_capacity *= 2;
563    bytes_to_allocate = jc->parse_buffer_capacity *
564                        sizeof( jc->parse_buffer[0] );
565    if( jc->parse_buffer == &jc->static_parse_buffer[0] )
566    {
567        jc->parse_buffer = (char*)malloc( bytes_to_allocate );
568        memcpy( jc->parse_buffer, jc->static_parse_buffer,
569                jc->parse_buffer_count );
570    }
571    else
572    {
573        jc->parse_buffer = (char*)realloc( jc->parse_buffer,
574                                           bytes_to_allocate );
575    }
576}
577
578#define parse_buffer_push_back_char( jc, c ) \
579    do { \
580        if( jc->parse_buffer_count + 1 >=\
581            jc->parse_buffer_capacity ) grow_parse_buffer( jc );\
582        jc->parse_buffer[jc->parse_buffer_count++] = c; \
583        jc->parse_buffer[jc->parse_buffer_count]   = 0; \
584    } while( 0 )
585
586
587static int
588parse_parse_buffer( JSON_parser jc )
589{
590    if( jc->callback )
591    {
592        JSON_value value, *arg = NULL;
593
594        if( jc->type != JSON_T_NONE )
595        {
596            assert(
597                jc->type == JSON_T_NULL
598                  || jc->type == JSON_T_FALSE
599                  || jc->type == JSON_T_TRUE
600                  || jc->type == JSON_T_FLOAT
601                  || jc->type == JSON_T_INTEGER
602                  || jc->type == JSON_T_STRING );
603
604            switch( jc->type )
605            {
606                case JSON_T_FLOAT:
607                    arg = &value;
608                    if( jc->handle_floats_manually )
609                    {
610                        value.vu.str.value = jc->parse_buffer;
611                        value.vu.str.length = jc->parse_buffer_count;
612                    }
613                    else
614                    {
615                        sscanf( jc->parse_buffer, "%Lf",
616                                &value.vu.float_value );
617                    }
618                    break;
619
620                case JSON_T_INTEGER:
621                    arg = &value;
622                    sscanf( jc->parse_buffer,
623                            JSON_PARSER_INTEGER_SSCANF_TOKEN,
624                            &value.vu.integer_value );
625                    break;
626
627                case JSON_T_STRING:
628                    arg = &value;
629                    value.vu.str.value = jc->parse_buffer;
630                    value.vu.str.length = jc->parse_buffer_count;
631                    break;
632            }
633
634            if( !( *jc->callback )( jc->ctx, jc->type, arg ) )
635            {
636                return false;
637            }
638        }
639    }
640
641    parse_buffer_clear( jc );
642
643    return true;
644}
645
646static int
647decode_unicode_char( JSON_parser jc )
648{
649    const unsigned chars = jc->utf16_decode_buffer[0] ? 2 : 1;
650    int            i;
651    UTF16 *        uc = chars ==
652                        1 ? &jc->utf16_decode_buffer[0] : &jc->
653                        utf16_decode_buffer[1];
654    UTF16          x;
655    char*          p;
656
657    assert( jc->parse_buffer_count >= 6 );
658
659    p = &jc->parse_buffer[jc->parse_buffer_count - 4];
660
661    for( i = 0; i < 4; ++i, ++p )
662    {
663        x = *p;
664
665        if( x >= 'a' )
666        {
667            x -= ( 'a' - 10 );
668        }
669        else if( x >= 'A' )
670        {
671            x -= ( 'A' - 10 );
672        }
673        else
674        {
675            x &= ~( (UTF16) 0x30 );
676        }
677
678        assert( x < 16 );
679
680        *uc |= x << ( ( 3u - i ) << 2 );
681    }
682
683    /* clear UTF-16 char form buffer */
684    jc->parse_buffer_count -= 6;
685    jc->parse_buffer[jc->parse_buffer_count] = 0;
686
687    /* attempt decoding ... */
688    {
689        UTF8*                  dec_start =
690            (UTF8*)&jc->parse_buffer[jc->parse_buffer_count];
691        UTF8*                  dec_start_dup = dec_start;
692        UTF8*                  dec_end = dec_start + 6;
693
694        const UTF16*           enc_start = &jc->utf16_decode_buffer[0];
695        const UTF16*           enc_end = enc_start + chars;
696
697        const ConversionResult result = ConvertUTF16toUTF8(
698            &enc_start, enc_end, &dec_start, dec_end, strictConversion );
699
700        const size_t           new_chars = dec_start - dec_start_dup;
701
702        /* was it a surrogate UTF-16 char? */
703        if( chars == 1 && result == sourceExhausted )
704        {
705            return true;
706        }
707
708        if( result != conversionOK )
709        {
710            return false;
711        }
712
713        /* NOTE: clear decode buffer to resume string reading,
714           otherwise we continue to read UTF-16 */
715        jc->utf16_decode_buffer[0] = 0;
716
717        assert( new_chars <= 6 );
718
719        jc->parse_buffer_count += new_chars;
720        jc->parse_buffer[jc->parse_buffer_count] = 0;
721    }
722
723    return true;
724}
725
726int
727JSON_parser_char( JSON_parser jc,
728                  int         next_char )
729{
730/*
731    After calling new_JSON_parser, call this function for each character (or
732    partial character) in your JSON text. It can accept UTF-8, UTF-16, or
733    UTF-32. It returns true if things are looking ok so far. If it rejects the
734    text, it returns false.
735 */
736    int next_class, next_state;
737
738/*
739    Determine the character's class.
740 */
741    if( next_char < 0 )
742    {
743        return false;
744    }
745    if( next_char >= 128 )
746    {
747        next_class = C_ETC;
748    }
749    else
750    {
751        next_class = ascii_class[next_char];
752        if( next_class <= __ )
753        {
754            return false;
755        }
756    }
757
758    if( jc->escaped )
759    {
760        jc->escaped = 0;
761        /* remove the backslash */
762        parse_buffer_pop_back_char( jc );
763        switch( next_char )
764        {
765            case 'b':
766                parse_buffer_push_back_char( jc, '\b' );
767                break;
768
769            case 'f':
770                parse_buffer_push_back_char( jc, '\f' );
771                break;
772
773            case 'n':
774                parse_buffer_push_back_char( jc, '\n' );
775                break;
776
777            case 'r':
778                parse_buffer_push_back_char( jc, '\r' );
779                break;
780
781            case 't':
782                parse_buffer_push_back_char( jc, '\t' );
783                break;
784
785            case '"':
786                parse_buffer_push_back_char( jc, '"' );
787                break;
788
789            case '\\':
790                parse_buffer_push_back_char( jc, '\\' );
791                break;
792
793            case '/':
794                parse_buffer_push_back_char( jc, '/' );
795                break;
796
797            case 'u':
798                parse_buffer_push_back_char( jc, '\\' );
799                parse_buffer_push_back_char( jc, 'u' );
800                break;
801
802            default:
803                return false;
804        }
805    }
806    else if( !jc->comment )
807    {
808        if( jc->type != JSON_T_NONE
809          || !( next_class == C_SPACE || next_class == C_WHITE ) /*
810                                                                   non-white-space
811                                                                   */                  )
812        {
813            parse_buffer_push_back_char( jc, (char)next_char );
814        }
815    }
816
817
818/*
819    Get the next state from the state transition table.
820 */
821    next_state = state_transition_table[jc->state][next_class];
822    if( next_state >= 0 )
823    {
824/*
825    Change the state.
826 */
827        jc->state = next_state;
828    }
829    else
830    {
831/*
832    Or perform one of the actions.
833 */
834        switch( next_state )
835        {
836/* Unicode character */
837            case UC:
838                if( !decode_unicode_char( jc ) )
839                {
840                    return false;
841                }
842                /* check if we need to read a second UTF-16 char */
843                if( jc->utf16_decode_buffer[0] )
844                {
845                    jc->state = D1;
846                }
847                else
848                {
849                    jc->state = ST;
850                }
851                break;
852
853/* escaped char */
854            case EX:
855                jc->escaped = 1;
856                jc->state = ES;
857                break;
858
859/* integer detected by minus */
860            case MX:
861                jc->type = JSON_T_INTEGER;
862                jc->state = MI;
863                break;
864
865/* integer detected by zero */
866            case ZX:
867                jc->type = JSON_T_INTEGER;
868                jc->state = ZE;
869                break;
870
871/* integer detected by 1-9 */
872            case IX:
873                jc->type = JSON_T_INTEGER;
874                jc->state = IN;
875                break;
876
877/* floating point number detected by exponent*/
878            case DE:
879                assert( jc->type != JSON_T_FALSE );
880                assert( jc->type != JSON_T_TRUE );
881                assert( jc->type != JSON_T_NULL );
882                assert( jc->type != JSON_T_STRING );
883                jc->type = JSON_T_FLOAT;
884                jc->state = E1;
885                break;
886
887/* floating point number detected by fraction */
888            case DF:
889                assert( jc->type != JSON_T_FALSE );
890                assert( jc->type != JSON_T_TRUE );
891                assert( jc->type != JSON_T_NULL );
892                assert( jc->type != JSON_T_STRING );
893                jc->type = JSON_T_FLOAT;
894                jc->state = FX;
895                break;
896
897/* string begin " */
898            case SB:
899                parse_buffer_clear( jc );
900                assert( jc->type == JSON_T_NONE );
901                jc->type = JSON_T_STRING;
902                jc->state = ST;
903                break;
904
905/* n */
906            case NU:
907                assert( jc->type == JSON_T_NONE );
908                jc->type = JSON_T_NULL;
909                jc->state = N1;
910                break;
911
912/* f */
913            case FA:
914                assert( jc->type == JSON_T_NONE );
915                jc->type = JSON_T_FALSE;
916                jc->state = F1;
917                break;
918
919/* t */
920            case TR:
921                assert( jc->type == JSON_T_NONE );
922                jc->type = JSON_T_TRUE;
923                jc->state = T1;
924                break;
925
926/* closing comment */
927            case CE:
928                jc->comment = 0;
929                assert( jc->parse_buffer_count == 0 );
930                assert( jc->type == JSON_T_NONE );
931                jc->state = jc->before_comment_state;
932                break;
933
934/* opening comment  */
935            case CB:
936                if( !jc->allow_comments )
937                {
938                    return false;
939                }
940                parse_buffer_pop_back_char( jc );
941                if( !parse_parse_buffer( jc ) )
942                {
943                    return false;
944                }
945                assert( jc->parse_buffer_count == 0 );
946                assert( jc->type != JSON_T_STRING );
947                switch( jc->stack[jc->top] )
948                {
949                    case MODE_ARRAY:
950                    case MODE_OBJECT:
951                        switch( jc->state )
952                        {
953                            case VA:
954                            case AR:
955                                jc->before_comment_state = jc->state;
956                                break;
957
958                            default:
959                                jc->before_comment_state = OK;
960                                break;
961                        }
962                        break;
963
964                    default:
965                        jc->before_comment_state = jc->state;
966                        break;
967                }
968                jc->type = JSON_T_NONE;
969                jc->state = C1;
970                jc->comment = 1;
971                break;
972
973/* empty } */
974            case - 9:
975                parse_buffer_clear( jc );
976                if( jc->callback
977                  && !( *jc->callback )( jc->ctx, JSON_T_OBJECT_END, NULL ) )
978                {
979                    return false;
980                }
981                if( !pop( jc, MODE_KEY ) )
982                {
983                    return false;
984                }
985                jc->state = OK;
986                break;
987
988/* } */ case - 8:
989                parse_buffer_pop_back_char( jc );
990                if( !parse_parse_buffer( jc ) )
991                {
992                    return false;
993                }
994                if( jc->callback
995                  && !( *jc->callback )( jc->ctx, JSON_T_OBJECT_END, NULL ) )
996                {
997                    return false;
998                }
999                if( !pop( jc, MODE_OBJECT ) )
1000                {
1001                    return false;
1002                }
1003                jc->type = JSON_T_NONE;
1004                jc->state = OK;
1005                break;
1006
1007/* ] */ case - 7:
1008                parse_buffer_pop_back_char( jc );
1009                if( !parse_parse_buffer( jc ) )
1010                {
1011                    return false;
1012                }
1013                if( jc->callback
1014                  && !( *jc->callback )( jc->ctx, JSON_T_ARRAY_END, NULL ) )
1015                {
1016                    return false;
1017                }
1018                if( !pop( jc, MODE_ARRAY ) )
1019                {
1020                    return false;
1021                }
1022
1023                jc->type = JSON_T_NONE;
1024                jc->state = OK;
1025                break;
1026
1027/* { */ case - 6:
1028                parse_buffer_pop_back_char( jc );
1029                if( jc->callback
1030                  && !( *jc->callback )( jc->ctx, JSON_T_OBJECT_BEGIN, NULL ) )
1031                {
1032                    return false;
1033                }
1034                if( !push( jc, MODE_KEY ) )
1035                {
1036                    return false;
1037                }
1038                assert( jc->type == JSON_T_NONE );
1039                jc->state = OB;
1040                break;
1041
1042/* [ */ case - 5:
1043                parse_buffer_pop_back_char( jc );
1044                if( jc->callback
1045                  && !( *jc->callback )( jc->ctx, JSON_T_ARRAY_BEGIN, NULL ) )
1046                {
1047                    return false;
1048                }
1049                if( !push( jc, MODE_ARRAY ) )
1050                {
1051                    return false;
1052                }
1053                assert( jc->type == JSON_T_NONE );
1054                jc->state = AR;
1055                break;
1056
1057/* string end " */ case - 4:
1058                parse_buffer_pop_back_char( jc );
1059                switch( jc->stack[jc->top] )
1060                {
1061                    case MODE_KEY:
1062                        assert( jc->type == JSON_T_STRING );
1063                        jc->type = JSON_T_NONE;
1064                        jc->state = CO;
1065
1066                        if( jc->callback )
1067                        {
1068                            JSON_value value;
1069                            value.vu.str.value = jc->parse_buffer;
1070                            value.vu.str.length = jc->parse_buffer_count;
1071                            if( !( *jc->callback )( jc->ctx, JSON_T_KEY,
1072                                                    &value ) )
1073                            {
1074                                return false;
1075                            }
1076                        }
1077                        parse_buffer_clear( jc );
1078                        break;
1079
1080                    case MODE_ARRAY:
1081                    case MODE_OBJECT:
1082                        assert( jc->type == JSON_T_STRING );
1083                        if( !parse_parse_buffer( jc ) )
1084                        {
1085                            return false;
1086                        }
1087                        jc->type = JSON_T_NONE;
1088                        jc->state = OK;
1089                        break;
1090
1091                    default:
1092                        return false;
1093                }
1094                break;
1095
1096/* , */ case - 3:
1097                parse_buffer_pop_back_char( jc );
1098                if( !parse_parse_buffer( jc ) )
1099                {
1100                    return false;
1101                }
1102                switch( jc->stack[jc->top] )
1103                {
1104                    case MODE_OBJECT:
1105/*
1106    A comma causes a flip from object mode to key mode.
1107 */
1108                        if( !pop( jc, MODE_OBJECT ) || !push( jc, MODE_KEY ) )
1109                        {
1110                            return false;
1111                        }
1112                        assert( jc->type != JSON_T_STRING );
1113                        jc->type = JSON_T_NONE;
1114                        jc->state = KE;
1115                        break;
1116
1117                    case MODE_ARRAY:
1118                        assert( jc->type != JSON_T_STRING );
1119                        jc->type = JSON_T_NONE;
1120                        jc->state = VA;
1121                        break;
1122
1123                    default:
1124                        return false;
1125                }
1126                break;
1127
1128/* : */ case - 2:
1129/*
1130    A colon causes a flip from key mode to object mode.
1131 */
1132                parse_buffer_pop_back_char( jc );
1133                if( !pop( jc, MODE_KEY ) || !push( jc, MODE_OBJECT ) )
1134                {
1135                    return false;
1136                }
1137                assert( jc->type == JSON_T_NONE );
1138                jc->state = VA;
1139                break;
1140
1141            /*
1142                Bad action.
1143             */
1144            default:
1145                return false;
1146        }
1147    }
1148    return true;
1149}
1150
1151int
1152JSON_parser_done( JSON_parser jc )
1153{
1154    const int result = jc->state == OK && pop( jc, MODE_DONE );
1155
1156    return result;
1157}
1158
1159int
1160JSON_parser_is_legal_white_space_string( const char* s )
1161{
1162    int c, char_class;
1163
1164    if( s == NULL )
1165    {
1166        return false;
1167    }
1168
1169    for( ; *s; ++s )
1170    {
1171        c = *s;
1172
1173        if( c < 0 || c >= 128 )
1174        {
1175            return false;
1176        }
1177
1178        char_class = ascii_class[c];
1179
1180        if( char_class != C_SPACE && char_class != C_WHITE )
1181        {
1182            return false;
1183        }
1184    }
1185
1186    return true;
1187}
1188
1189void
1190init_JSON_config( JSON_config* config )
1191{
1192    if( config )
1193    {
1194        memset( config, 0, sizeof( *config ) );
1195
1196        config->depth = JSON_PARSER_STACK_SIZE - 1;
1197    }
1198}
1199
Note: See TracBrowser for help on using the repository browser.