The R Project SVN – R-packages – Diff – /trunk/RJSONIO/src/JSON_parser.c


/* JSON_parser.c */
 
/* 2007-08-24 */
 
/*
Copyright (c) 2005 JSON.org
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
The Software shall be used for Good, not Evil.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
/*
    Callbacks, comments, Unicode handling by Jean Gressmann (jean@0x42.de), 2007-2008.
    
    For the added features the license above applies also.
    
    Changelog:
        2008/10/14 
            - Renamed states.IN to states.IT to avoid name clash which IN macro
              defined in windef.h (alexey.pelykh@gmail.com)
            
        2008/07/19 
            - Removed some duplicate code & debugging variable (Charles.Kerr@noaa.gov)
        
        2008/05/28 
            - Made JSON_value structure ansi C compliant. This bug was report by 
              trisk@acm.jhu.edu
        
        2008/05/20 
            - Fixed bug reported by Charles.Kerr@noaa.gov where the switching 
              from static to dynamic parse buffer did not copy the static parse 
              buffer's content.
*/
 
 
 
#include <assert.h>
#include <ctype.h>
#include <float.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
 
#include "JSON_parser.h"
#include "ConvertUTF.h"
 
 
#if _MSC_VER >= 1400 /* Visual Studio 2005 and up */
#	pragma warning(disable:4996) // unsecure sscanf
#endif
 
/*
#define true  1
#define false 0
*/
#define __   -1     /* the universal error code */
 
/* values chosen so that the object size is approx equal to one page (4K) */
#ifndef JSON_PARSER_STACK_SIZE
#   define JSON_PARSER_STACK_SIZE 128
#endif
 
#ifndef JSON_PARSER_PARSE_BUFFER_SIZE
#   define JSON_PARSER_PARSE_BUFFER_SIZE 3500
#endif
 
 
typedef struct JSON_parser_struct {
    JSON_parser_callback callback;
    void* ctx;
    signed char state, before_comment_state, type, escaped, comment, allow_comments, handle_floats_manually;
    UTF16 utf16_decode_buffer[2];
    long depth;
    long top;
    signed char* stack;
    long stack_capacity;
    signed char static_stack[JSON_PARSER_STACK_SIZE];
    char* parse_buffer;
    size_t parse_buffer_capacity;
    size_t parse_buffer_count;
    size_t comment_begin_offset;
    char static_parse_buffer[JSON_PARSER_PARSE_BUFFER_SIZE];
} * JSON_parser;
 
#define COUNTOF(x) (sizeof(x)/sizeof(x[0])) 
 
/*
    Characters are mapped into these 31 character classes. This allows for
    a significant reduction in the size of the state transition table.
*/
 
 
 
enum classes {
    C_SPACE,  /* space */
    C_WHITE,  /* other whitespace */
    C_LCURB,  /* {  */
    C_RCURB,  /* } */
    C_LSQRB,  /* [ */
    C_RSQRB,  /* ] */
    C_COLON,  /* : */
    C_COMMA,  /* , */
    C_QUOTE,  /* " */
    C_BACKS,  /* \ */
    C_SLASH,  /* / */
    C_PLUS,   /* + */
    C_MINUS,  /* - */
    C_POINT,  /* . */
    C_ZERO ,  /* 0 */
    C_DIGIT,  /* 123456789 */
    C_LOW_A,  /* a */
    C_LOW_B,  /* b */
    C_LOW_C,  /* c */
    C_LOW_D,  /* d */
    C_LOW_E,  /* e */
    C_LOW_F,  /* f */
    C_LOW_L,  /* l */
    C_LOW_N,  /* n */
    C_LOW_R,  /* r */
    C_LOW_S,  /* s */
    C_LOW_T,  /* t */
    C_LOW_U,  /* u */
    C_ABCDF,  /* ABCDF */
    C_E,      /* E */
    C_ETC,    /* everything else */
    C_STAR,   /* * */   
    NR_CLASSES
};
 
static int ascii_class[128] = {
/*
    This array maps the 128 ASCII characters into character classes.
    The remaining Unicode characters should be mapped to C_ETC.
    Non-whitespace control characters are errors.
*/
    __,      __,      __,      __,      __,      __,      __,      __,
    __,      C_WHITE, C_WHITE, __,      __,      C_WHITE, __,      __,
    __,      __,      __,      __,      __,      __,      __,      __,
    __,      __,      __,      __,      __,      __,      __,      __,
 
    C_SPACE, C_ETC,   C_QUOTE, C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,
    C_ETC,   C_ETC,   C_STAR,   C_PLUS,  C_COMMA, C_MINUS, C_POINT, C_SLASH,
    C_ZERO,  C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT,
    C_DIGIT, C_DIGIT, C_COLON, C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,
 
    C_ETC,   C_ABCDF, C_ABCDF, C_ABCDF, C_ABCDF, C_E,     C_ABCDF, C_ETC,
    C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,
    C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_ETC,
    C_ETC,   C_ETC,   C_ETC,   C_LSQRB, C_BACKS, C_RSQRB, C_ETC,   C_ETC,
 
    C_ETC,   C_LOW_A, C_LOW_B, C_LOW_C, C_LOW_D, C_LOW_E, C_LOW_F, C_ETC,
    C_ETC,   C_ETC,   C_ETC,   C_ETC,   C_LOW_L, C_ETC,   C_LOW_N, C_ETC,
    C_ETC,   C_ETC,   C_LOW_R, C_LOW_S, C_LOW_T, C_LOW_U, C_ETC,   C_ETC,
    C_ETC,   C_ETC,   C_ETC,   C_LCURB, C_ETC,   C_RCURB, C_ETC,   C_ETC
};
 
 
/*
    The state codes.
*/
enum states {
    GO,  /* start    */
    OK,  /* ok       */
    OB,  /* object   */
    KE,  /* key      */
    CO,  /* colon    */
    VA,  /* value    */
    AR,  /* array    */
    ST,  /* string   */
    ES,  /* escape   */
    U1,  /* u1       */
    U2,  /* u2       */
    U3,  /* u3       */
    U4,  /* u4       */
    MI,  /* minus    */
    ZE,  /* zero     */
    IT,  /* integer  */
    FR,  /* fraction */
    E1,  /* e        */
    E2,  /* ex       */
    E3,  /* exp      */
    T1,  /* tr       */
    T2,  /* tru      */
    T3,  /* true     */
    F1,  /* fa       */
    F2,  /* fal      */
    F3,  /* fals     */
    F4,  /* false    */
    N1,  /* nu       */
    N2,  /* nul      */
    N3,  /* null     */
    C1,  /* /        */
    C2,  /* / *     */
    C3,  /* *        */
    FX,  /* *.* *eE* */
    D1,  /* second UTF-16 character decoding started by \ */
    D2,  /* second UTF-16 character proceeded by u */
    NR_STATES
};
 
enum actions
{
    CB = -10, /* comment begin */
    CE = -11, /* comment end */
    FA = -12, /* false */
    TR = -13, /* false */
    NU = -14, /* null */
    DE = -15, /* double detected by exponent e E */
    DF = -16, /* double detected by fraction . */
    SB = -17, /* string begin */
    MX = -18, /* integer detected by minus */
    ZX = -19, /* integer detected by zero */
    IX = -20, /* integer detected by 1-9 */
    EX = -21, /* next char is escaped */
    UC = -22, /* Unicode character read */
};
 
 
static int state_transition_table[NR_STATES][NR_CLASSES] = {
/*
    The state transition table takes the current state and the current symbol,
    and returns either a new state or an action. An action is represented as a
    negative number. A JSON text is accepted if at the end of the text the
    state is OK and if the mode is MODE_DONE.
 
                 white                                      1-9                                   ABCDF  etc
             space |  {  }  [  ]  :  ,  "  \  /  +  -  .  0  |  a  b  c  d  e  f  l  n  r  s  t  u  |  E  |  * */
/*start  GO*/ {GO,GO,-6,__,-5,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*ok     OK*/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*object OB*/ {OB,OB,__,-9,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*key    KE*/ {KE,KE,__,__,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*colon  CO*/ {CO,CO,__,__,__,__,-2,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*value  VA*/ {VA,VA,-6,__,-5,__,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},
/*array  AR*/ {AR,AR,-6,__,-5,-7,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},
/*string ST*/ {ST,__,ST,ST,ST,ST,ST,ST,-4,EX,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST},
/*escape ES*/ {__,__,__,__,__,__,__,__,ST,ST,ST,__,__,__,__,__,__,ST,__,__,__,ST,__,ST,ST,__,ST,U1,__,__,__,__},
/*u1     U1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U2,U2,U2,U2,U2,U2,U2,U2,__,__,__,__,__,__,U2,U2,__,__},
/*u2     U2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U3,U3,U3,U3,U3,U3,U3,U3,__,__,__,__,__,__,U3,U3,__,__},
/*u3     U3*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U4,U4,U4,U4,U4,U4,U4,U4,__,__,__,__,__,__,U4,U4,__,__},
/*u4     U4*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,UC,UC,UC,UC,UC,UC,UC,UC,__,__,__,__,__,__,UC,UC,__,__},
/*minus  MI*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,ZE,IT,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*zero   ZE*/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*int    IT*/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,IT,IT,__,__,__,__,DE,__,__,__,__,__,__,__,__,DE,__,__},
/*frac   FR*/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},
/*e      E1*/ {__,__,__,__,__,__,__,__,__,__,__,E2,E2,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*ex     E2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*exp    E3*/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*tr     T1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T2,__,__,__,__,__,__,__},
/*tru    T2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T3,__,__,__,__},
/*true   T3*/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},
/*fa     F1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*fal    F2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F3,__,__,__,__,__,__,__,__,__},
/*fals   F3*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F4,__,__,__,__,__,__},
/*false  F4*/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},
/*nu     N1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N2,__,__,__,__},
/*nul    N2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N3,__,__,__,__,__,__,__,__,__},
/*null   N3*/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__},
/*/      C1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,C2},
/*/*     C2*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},
/**      C3*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,CE,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},
/*_.     FX*/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},
/*\      D1*/ {__,__,__,__,__,__,__,__,__,D2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},
/*\      D2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,U1,__,__,__,__},
};
 
 
/*
    These modes can be pushed on the stack.
*/
enum modes {
    MODE_ARRAY = 1, 
    MODE_DONE = 2,  
    MODE_KEY = 3,   
    MODE_OBJECT = 4
};
 
static int
push(JSON_parser jc, int mode)
{
/*
    Push a mode onto the stack. Return false if there is overflow.
*/
    jc->top += 1;
    if (jc->depth < 0) {
        if (jc->top >= jc->stack_capacity) {
            size_t bytes_to_allocate;
            jc->stack_capacity *= 2;
            bytes_to_allocate = jc->stack_capacity * sizeof(jc->static_stack[0]);
            if (jc->stack == &jc->static_stack[0]) {
                jc->stack = (signed char*)malloc(bytes_to_allocate);
                memcpy(jc->stack, jc->static_stack, sizeof(jc->static_stack));
            } else {
                jc->stack = (signed char*)realloc(jc->stack, bytes_to_allocate);
            }
        }
    } else {
        if (jc->top >= jc->depth) {
            return false;
        }
    }
    
    jc->stack[jc->top] = (signed char)mode;
    return true;
}
 
 
static int
pop(JSON_parser jc, int mode)
{
/*
    Pop the stack, assuring that the current mode matches the expectation.
    Return false if there is underflow or if the modes mismatch.
*/
    if (jc->top < 0 || jc->stack[jc->top] != mode) {
        return false;
    }
    jc->top -= 1;
    return true;
}
 
 
#define parse_buffer_clear(jc) \
    do {\
        jc->parse_buffer_count = 0;\
        jc->parse_buffer[0] = 0;\
    } while (0)
    
#define parse_buffer_pop_back_char(jc)\
    do {\
        assert(jc->parse_buffer_count >= 1);\
        --jc->parse_buffer_count;\
        jc->parse_buffer[jc->parse_buffer_count] = 0;\
    } while (0)    
    
void delete_JSON_parser(JSON_parser jc)
{
    if (jc) {
        if (jc->stack != &jc->static_stack[0]) {
            free((void*)jc->stack);
        }
        if (jc->parse_buffer != &jc->static_parse_buffer[0]) {
            free((void*)jc->parse_buffer);
        }
        free((void*)jc);
     }   
}
 
 
JSON_parser
new_JSON_parser(JSON_config* config)
{
/*
    new_JSON_parser starts the checking process by constructing a JSON_parser
    object. It takes a depth parameter that restricts the level of maximum
    nesting.
 
    To continue the process, call JSON_parser_char for each character in the
    JSON text, and then call JSON_parser_done to obtain the final result.
    These functions are fully reentrant.
*/
 
    int depth = 0;
    JSON_config default_config;
    
    JSON_parser jc = malloc(sizeof(struct JSON_parser_struct));
    
    memset(jc, 0, sizeof(*jc));
    
    
    /* initialize configuration */
    init_JSON_config(&default_config);
    
    /* set to default configuration if none was provided */
    if (config == NULL) {
        config = &default_config;
    }
 
    depth = config->depth;
    
    /* We need to be able to push at least one object */
    if (depth == 0) {
        depth = 1;
    }
    
    jc->state = GO;
    jc->top = -1;
    
    /* Do we want non-bound stack? */
    if (depth > 0) {
        jc->stack_capacity = depth;
        jc->depth = depth;
        if (depth <= COUNTOF(jc->static_stack)) {
            jc->stack = &jc->static_stack[0];
        } else {
            jc->stack = (signed char*)malloc(jc->stack_capacity * sizeof(jc->static_stack[0]));
        }
    } else {
        jc->stack_capacity = COUNTOF(jc->static_stack);
        jc->depth = -1;
        jc->stack = &jc->static_stack[0];
    }
    
    /* set parser to start */
    push(jc, MODE_DONE);
    
    /* set up the parse buffer */
    jc->parse_buffer = &jc->static_parse_buffer[0];
    jc->parse_buffer_capacity = COUNTOF(jc->static_parse_buffer);
    parse_buffer_clear(jc);
    
    /* set up callback, comment & float handling */
    jc->callback = config->callback;
    jc->ctx = config->callback_ctx;
    jc->allow_comments = config->allow_comments != 0;
    jc->handle_floats_manually = config->handle_floats_manually != 0;
    return jc;
}
 
static void grow_parse_buffer(JSON_parser jc)
{
    size_t bytes_to_allocate;
    jc->parse_buffer_capacity *= 2;
    bytes_to_allocate = jc->parse_buffer_capacity * sizeof(jc->parse_buffer[0]);
    if (jc->parse_buffer == &jc->static_parse_buffer[0]) {
        jc->parse_buffer = (char*)malloc(bytes_to_allocate);
        memcpy(jc->parse_buffer, jc->static_parse_buffer, jc->parse_buffer_count);
    } else {
        jc->parse_buffer = (char*)realloc(jc->parse_buffer, bytes_to_allocate);
    }
}
 
#define parse_buffer_push_back_char(jc, c)\
    do {\
        if (jc->parse_buffer_count + 1 >= jc->parse_buffer_capacity) grow_parse_buffer(jc);\
        jc->parse_buffer[jc->parse_buffer_count++] = c;\
        jc->parse_buffer[jc->parse_buffer_count]   = 0;\
    } while (0)
 
 
static int parse_parse_buffer(JSON_parser jc)
{
    if (jc->callback) {
        JSON_value value, *arg = NULL;
        
        if (jc->type != JSON_T_NONE) {
            assert(
                jc->type == JSON_T_NULL ||
                jc->type == JSON_T_FALSE ||
                jc->type == JSON_T_TRUE ||
                jc->type == JSON_T_FLOAT ||
                jc->type == JSON_T_INTEGER ||
                jc->type == JSON_T_STRING);
        
            switch(jc->type) {
                case JSON_T_FLOAT:
                    arg = &value;
                    if (jc->handle_floats_manually) {
                        value.vu.str.value = jc->parse_buffer;
                        value.vu.str.length = jc->parse_buffer_count;
                    } else { 
                        sscanf(jc->parse_buffer, DoubleScanFormat, &value.vu.float_value);
                    }
                    break;
                case JSON_T_INTEGER: {
                    double tmp;
                    arg = &value;
		    // value unused
                    int ok = sscanf(jc->parse_buffer, "%lf", &tmp);
	            if(tmp > MAX_INT || tmp < - MAX_INT) {
                       jc->type = JSON_T_FLOAT;
	               value.vu.float_value = tmp;
	            } else
			value.vu.integer_value = (JSON_int_t)tmp;
                    break;
                }
                case JSON_T_STRING:
                    arg = &value;
                    value.vu.str.value = jc->parse_buffer;
                    value.vu.str.length = jc->parse_buffer_count;
                    break;
            }
            
            if (!(*jc->callback)(jc->ctx, jc->type, arg)) {
                return false;
            }
        }
    }
    
    parse_buffer_clear(jc);
    
    return true;
}
 
static int decode_unicode_char(JSON_parser jc)
{
    const unsigned chars = jc->utf16_decode_buffer[0] ? 2 : 1;
    int i;
    UTF16 *uc = chars == 1 ? &jc->utf16_decode_buffer[0] : &jc->utf16_decode_buffer[1];
    UTF16 x;
    char* p;
    
    assert(jc->parse_buffer_count >= 6);
    
    p = &jc->parse_buffer[jc->parse_buffer_count - 4];
    
    for (i = 0; i < 4; ++i, ++p) {
        x = *p;
        
        if (x >= 'a') {
            x -= ('a' - 10);
        } else if (x >= 'A') {
            x -= ('A' - 10);
        } else {
            x &= ~((UTF16) 0x30);
        }
        
        assert(x < 16);
        
        *uc |= x << ((3u - i) << 2);
    }
    
    /* clear UTF-16 char form buffer */
    jc->parse_buffer_count -= 6;
    jc->parse_buffer[jc->parse_buffer_count] = 0;
    
    /* attempt decoding ... */
    {
        UTF8* dec_start = (UTF8*)&jc->parse_buffer[jc->parse_buffer_count];
        UTF8* dec_start_dup = dec_start;
        UTF8* dec_end = dec_start + 6;
        
        const UTF16* enc_start = &jc->utf16_decode_buffer[0];
        const UTF16* enc_end = enc_start + chars;
    
        const ConversionResult result = ConvertUTF16toUTF8(
            &enc_start, enc_end, &dec_start, dec_end, strictConversion);
        
        const size_t new_chars = dec_start - dec_start_dup;
        
        /* was it a surrogate UTF-16 char? */
        if (chars == 1 && result == sourceExhausted) {
            return true;
        }
        
        if (result != conversionOK) {
            return false;
        }
        
        /* NOTE: clear decode buffer to resume string reading,
           otherwise we continue to read UTF-16 */
        jc->utf16_decode_buffer[0] = 0;
        
        assert(new_chars <= 6);
        
        jc->parse_buffer_count += new_chars;
        jc->parse_buffer[jc->parse_buffer_count] = 0;
    }
    
    return true;
}
 
 
int
JSON_parser_char(JSON_parser jc, int next_char)
{
/*
    After calling new_JSON_parser, call this function for each character (or
    partial character) in your JSON text. It can accept UTF-8, UTF-16, or
    UTF-32. It returns true if things are looking ok so far. If it rejects the
    text, it returns false.
*/
    int next_class, next_state;
    
/*
    Determine the character's class.
*/
    if (next_char < 0) {
        return false;
    }
    if (next_char >= 128) {
        next_class = C_ETC;
    } else {
        next_class = ascii_class[next_char];
        if (next_class <= __) {
            return false;
        }
    }
    
    if (jc->escaped) {
        jc->escaped = 0;
        /* remove the backslash */
        parse_buffer_pop_back_char(jc);
        switch(next_char) {
        case 'b':
            parse_buffer_push_back_char(jc, '\b');
            break;
        case 'f':
            parse_buffer_push_back_char(jc, '\f');
            break;
        case 'n':
            parse_buffer_push_back_char(jc, '\n');
            break;
        case 'r':
            parse_buffer_push_back_char(jc, '\r');
            break;
        case 't':
            parse_buffer_push_back_char(jc, '\t');
            break;
        case '"':
            parse_buffer_push_back_char(jc, '"');
            break;
        case '\\':
            parse_buffer_push_back_char(jc, '\\');
            break;
        case '/':
            parse_buffer_push_back_char(jc, '/');
            break;
        case 'u':
            parse_buffer_push_back_char(jc, '\\');
            parse_buffer_push_back_char(jc, 'u');
            break;
        default:
            return false;
        }
    } else if (!jc->comment) { 
        if (jc->type != JSON_T_NONE || !(next_class == C_SPACE || next_class == C_WHITE) /* non-white-space */) {
            parse_buffer_push_back_char(jc, (char)next_char);
        }
    }
    
    
    
/*
    Get the next state from the state transition table.
*/
    next_state = state_transition_table[jc->state][next_class];
    if (next_state >= 0) {
/*
    Change the state.
*/
        jc->state = (signed char) next_state;
    } else {
/*
    Or perform one of the actions.
*/
        switch (next_state) {
/* Unicode character */        
        case UC:
            if(!decode_unicode_char(jc)) {
                return false;
            }
            /* check if we need to read a second UTF-16 char */
            if (jc->utf16_decode_buffer[0]) {
                jc->state = D1;
            } else {
                jc->state = ST;
            }
            break;
/* escaped char */
        case EX:
            jc->escaped = 1;
            jc->state = ES;
            break;
/* integer detected by minus */
        case MX:
            jc->type = JSON_T_INTEGER;
            jc->state = MI;
            break;  
/* integer detected by zero */            
        case ZX:
            jc->type = JSON_T_INTEGER;
            jc->state = ZE;
            break;  
/* integer detected by 1-9 */            
        case IX:
            jc->type = JSON_T_INTEGER;
            jc->state = IT;
            break;  
            
/* floating point number detected by exponent*/
        case DE:
            assert(jc->type != JSON_T_FALSE);
            assert(jc->type != JSON_T_TRUE);
            assert(jc->type != JSON_T_NULL);
            assert(jc->type != JSON_T_STRING);
            jc->type = JSON_T_FLOAT;
            jc->state = E1;
            break;   
        
/* floating point number detected by fraction */
        case DF:
            assert(jc->type != JSON_T_FALSE);
            assert(jc->type != JSON_T_TRUE);
            assert(jc->type != JSON_T_NULL);
            assert(jc->type != JSON_T_STRING);
            jc->type = JSON_T_FLOAT;
            jc->state = FX;
            break;   
/* string begin " */
        case SB:
            parse_buffer_clear(jc);
            assert(jc->type == JSON_T_NONE);
            jc->type = JSON_T_STRING;
            jc->state = ST;
            break;        
        
/* n */
        case NU:
            assert(jc->type == JSON_T_NONE);
            jc->type = JSON_T_NULL;
            jc->state = N1;
            break;        
/* f */
        case FA:
            assert(jc->type == JSON_T_NONE);
            jc->type = JSON_T_FALSE;
            jc->state = F1;
            break;        
/* t */
        case TR:
            assert(jc->type == JSON_T_NONE);
            jc->type = JSON_T_TRUE;
            jc->state = T1;
            break;        
        
/* closing comment */
        case CE:
            jc->comment = 0;
            assert(jc->parse_buffer_count == 0);
            assert(jc->type == JSON_T_NONE);
            jc->state = jc->before_comment_state;
            break;        
        
/* opening comment  */
        case CB:
            if (!jc->allow_comments) {
                return false;
            }
            parse_buffer_pop_back_char(jc);
            if (!parse_parse_buffer(jc)) {
                return false;
            }
            assert(jc->parse_buffer_count == 0);
            assert(jc->type != JSON_T_STRING);
            switch (jc->stack[jc->top]) {
            case MODE_ARRAY:
            case MODE_OBJECT:   
                switch(jc->state) {
                case VA:
                case AR:
                    jc->before_comment_state = jc->state;
                    break;
                default:
                    jc->before_comment_state = OK;
                    break;
                }
                break;
            default:
                jc->before_comment_state = jc->state;
                break;
            }
            jc->type = JSON_T_NONE;
            jc->state = C1;
            jc->comment = 1;
            break;
/* empty } */
        case -9:        
            parse_buffer_clear(jc);
            if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_END, NULL)) {
                return false;
            }
            if (!pop(jc, MODE_KEY)) {
                return false;
            }
            jc->state = OK;
            break;
 
/* } */ case -8:
            parse_buffer_pop_back_char(jc);
            if (!parse_parse_buffer(jc)) {
                return false;
            }
            if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_END, NULL)) {
                return false;
            }
            if (!pop(jc, MODE_OBJECT)) {
                return false;
            }
            jc->type = JSON_T_NONE;
            jc->state = OK;
            break;
 
/* ] */ case -7:
            parse_buffer_pop_back_char(jc);
            if (!parse_parse_buffer(jc)) {
                return false;
            }
            if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_ARRAY_END, NULL)) {
                return false;
            }
            if (!pop(jc, MODE_ARRAY)) {
                return false;
            }
            
            jc->type = JSON_T_NONE;
            jc->state = OK;
            break;
 
/* { */ case -6:
            parse_buffer_pop_back_char(jc);
            if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_BEGIN, NULL)) {
                return false;
            }
            if (!push(jc, MODE_KEY)) {
                return false;
            }
            assert(jc->type == JSON_T_NONE);
            jc->state = OB;
            break;
 
/* [ */ case -5:
            parse_buffer_pop_back_char(jc);
            if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_ARRAY_BEGIN, NULL)) {
                return false;
            }
            if (!push(jc, MODE_ARRAY)) {
                return false;
            }
            assert(jc->type == JSON_T_NONE);
            jc->state = AR;
            break;
 
/* string end " */ case -4:
            parse_buffer_pop_back_char(jc);
            switch (jc->stack[jc->top]) {
            case MODE_KEY:
                assert(jc->type == JSON_T_STRING);
                jc->type = JSON_T_NONE;
                jc->state = CO;
                
                if (jc->callback) {
                    JSON_value value;
                    value.vu.str.value = jc->parse_buffer;
                    value.vu.str.length = jc->parse_buffer_count;
                    if (!(*jc->callback)(jc->ctx, JSON_T_KEY, &value)) {
                        return false;
                    }
                }
                parse_buffer_clear(jc);
                break;
            case MODE_ARRAY:
            case MODE_OBJECT:
                assert(jc->type == JSON_T_STRING);
                if (!parse_parse_buffer(jc)) {
                    return false;
                }
                jc->type = JSON_T_NONE;
                jc->state = OK;
                break;
            default:
                return false;
            }
            break;
 
/* , */ case -3:
            parse_buffer_pop_back_char(jc);
            if (!parse_parse_buffer(jc)) {
                return false;
            }
            switch (jc->stack[jc->top]) {
            case MODE_OBJECT:
/*
    A comma causes a flip from object mode to key mode.
*/
                if (!pop(jc, MODE_OBJECT) || !push(jc, MODE_KEY)) {
                    return false;
                }
                assert(jc->type != JSON_T_STRING);
                jc->type = JSON_T_NONE;
                jc->state = KE;
                break;
            case MODE_ARRAY:
                assert(jc->type != JSON_T_STRING);
                jc->type = JSON_T_NONE;
                jc->state = VA;
                break;
            default:
                return false;
            }
            break;
 
/* : */ case -2:
/*
    A colon causes a flip from key mode to object mode.
*/
            parse_buffer_pop_back_char(jc);
            if (!pop(jc, MODE_KEY) || !push(jc, MODE_OBJECT)) {
                return false;
            }
            assert(jc->type == JSON_T_NONE);
            jc->state = VA;
            break;
/*
    Bad action.
*/
        default:
            return false;
        }
    }
    return true;
}
 
 
int
JSON_parser_done(JSON_parser jc)
{
    const int result = jc->state == OK && pop(jc, MODE_DONE);
 
    return result;
}
 
 
int JSON_parser_is_legal_white_space_string(const char* s)
{
    int c, char_class;
    
    if (s == NULL) {
        return false;
    }
    
    for (; *s; ++s) {   
        c = *s;
        
        if (c < 0 || c >= 128) {
            return false;
        }
        
        char_class = ascii_class[c];
        
        if (char_class != C_SPACE && char_class != C_WHITE) {
            return false;
        }
    }
    
    return true;
}
 
 
 
void init_JSON_config(JSON_config* config)
{
    if (config) {
        memset(config, 0, sizeof(*config));
        
        config->depth = JSON_PARSER_STACK_SIZE - 1;
    }
}

Rev 7747	Rev 8509
1	`/* JSON_parser.c */`	1	`/* JSON_parser.c */`
2		2
3	`/* 2007-08-24 */`	3	`/* 2007-08-24 */`
4		4
5	`/*`	5	`/*`
6	`Copyright (c) 2005 JSON.org`	6	`Copyright (c) 2005 JSON.org`
7		7
8	`Permission is hereby granted, free of charge, to any person obtaining a copy`	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`	9	`of this software and associated documentation files (the "Software"), to deal`
10	`in the Software without restriction, including without limitation the rights`	10	`in the Software without restriction, including without limitation the rights`
11	`to use, copy, modify, merge, publish, distribute, sublicense, and/or sell`	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`	12	`copies of the Software, and to permit persons to whom the Software is`
13	`furnished to do so, subject to the following conditions:`	13	`furnished to do so, subject to the following conditions:`
14		14
15	`The above copyright notice and this permission notice shall be included in all`	15	`The above copyright notice and this permission notice shall be included in all`
16	`copies or substantial portions of the Software.`	16	`copies or substantial portions of the Software.`
17		17
18	`The Software shall be used for Good, not Evil.`	18	`The Software shall be used for Good, not Evil.`
19		19
20	`THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`	20	`THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`
21	`IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`	21	`IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`
22	`FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`	22	`FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`
23	`AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`	23	`AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`
24	`LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,`	24	`LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,`
25	`OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE`	25	`OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE`
26	`SOFTWARE.`	26	`SOFTWARE.`
27	`*/`	27	`*/`
28		28
29	`/*`	29	`/*`
30	`Callbacks, comments, Unicode handling by Jean Gressmann (jean@0x42.de), 2007-2008.`	30	`Callbacks, comments, Unicode handling by Jean Gressmann (jean@0x42.de), 2007-2008.`
31		31
32	`For the added features the license above applies also.`	32	`For the added features the license above applies also.`
33		33
34	`Changelog:`	34	`Changelog:`
35	`2008/10/14`	35	`2008/10/14`
36	`- Renamed states.IN to states.IT to avoid name clash which IN macro`	36	`- Renamed states.IN to states.IT to avoid name clash which IN macro`
37	`defined in windef.h (alexey.pelykh@gmail.com)`	37	`defined in windef.h (alexey.pelykh@gmail.com)`
38		38
39	`2008/07/19`	39	`2008/07/19`
40	`- Removed some duplicate code & debugging variable (Charles.Kerr@noaa.gov)`	40	`- Removed some duplicate code & debugging variable (Charles.Kerr@noaa.gov)`
41		41
42	`2008/05/28`	42	`2008/05/28`
43	`- Made JSON_value structure ansi C compliant. This bug was report by`	43	`- Made JSON_value structure ansi C compliant. This bug was report by`
44	`trisk@acm.jhu.edu`	44	`trisk@acm.jhu.edu`
45		45
46	`2008/05/20`	46	`2008/05/20`
47	`- Fixed bug reported by Charles.Kerr@noaa.gov where the switching`	47	`- Fixed bug reported by Charles.Kerr@noaa.gov where the switching`
48	`from static to dynamic parse buffer did not copy the static parse`	48	`from static to dynamic parse buffer did not copy the static parse`
49	`buffer's content.`	49	`buffer's content.`
50	`*/`	50	`*/`
51		51
52		52
53		53
54	`#include <assert.h>`	54	`#include <assert.h>`
55	`#include <ctype.h>`	55	`#include <ctype.h>`
56	`#include <float.h>`	56	`#include <float.h>`
57	`#include <stddef.h>`	57	`#include <stddef.h>`
58	`#include <stdio.h>`	58	`#include <stdio.h>`
59	`#include <stdlib.h>`	59	`#include <stdlib.h>`
60	`#include <string.h>`	60	`#include <string.h>`
-		61	`#include <stdbool.h>`
61		62
62	`#include "JSON_parser.h"`	63	`#include "JSON_parser.h"`
63	`#include "ConvertUTF.h"`	64	`#include "ConvertUTF.h"`
64		65
65		66
66	`#if _MSC_VER >= 1400 /* Visual Studio 2005 and up */`	67	`#if _MSC_VER >= 1400 /* Visual Studio 2005 and up */`
67	`# pragma warning(disable:4996) // unsecure sscanf`	68	`# pragma warning(disable:4996) // unsecure sscanf`
68	`#endif`	69	`#endif`
69		70
70		71	`/*`
71	`#define true 1`	72	`#define true 1`
72	`#define false 0`	73	`#define false 0`
-		74	`*/`
73	`#define __ -1 /* the universal error code */`	75	`#define __ -1 /* the universal error code */`
74		76
75	`/* values chosen so that the object size is approx equal to one page (4K) */`	77	`/* values chosen so that the object size is approx equal to one page (4K) */`
76	`#ifndef JSON_PARSER_STACK_SIZE`	78	`#ifndef JSON_PARSER_STACK_SIZE`
77	`# define JSON_PARSER_STACK_SIZE 128`	79	`# define JSON_PARSER_STACK_SIZE 128`
78	`#endif`	80	`#endif`
79		81
80	`#ifndef JSON_PARSER_PARSE_BUFFER_SIZE`	82	`#ifndef JSON_PARSER_PARSE_BUFFER_SIZE`
81	`# define JSON_PARSER_PARSE_BUFFER_SIZE 3500`	83	`# define JSON_PARSER_PARSE_BUFFER_SIZE 3500`
82	`#endif`	84	`#endif`
83		85
84		86
85	`typedef struct JSON_parser_struct {`	87	`typedef struct JSON_parser_struct {`
86	`JSON_parser_callback callback;`	88	`JSON_parser_callback callback;`
87	`void* ctx;`	89	`void* ctx;`
88	`signed char state, before_comment_state, type, escaped, comment, allow_comments, handle_floats_manually;`	90	`signed char state, before_comment_state, type, escaped, comment, allow_comments, handle_floats_manually;`
89	`UTF16 utf16_decode_buffer[2];`	91	`UTF16 utf16_decode_buffer[2];`
90	`long depth;`	92	`long depth;`
91	`long top;`	93	`long top;`
92	`signed char* stack;`	94	`signed char* stack;`
93	`long stack_capacity;`	95	`long stack_capacity;`
94	`signed char static_stack[JSON_PARSER_STACK_SIZE];`	96	`signed char static_stack[JSON_PARSER_STACK_SIZE];`
95	`char* parse_buffer;`	97	`char* parse_buffer;`
96	`size_t parse_buffer_capacity;`	98	`size_t parse_buffer_capacity;`
97	`size_t parse_buffer_count;`	99	`size_t parse_buffer_count;`
98	`size_t comment_begin_offset;`	100	`size_t comment_begin_offset;`
99	`char static_parse_buffer[JSON_PARSER_PARSE_BUFFER_SIZE];`	101	`char static_parse_buffer[JSON_PARSER_PARSE_BUFFER_SIZE];`
100	`} * JSON_parser;`	102	`} * JSON_parser;`
101		103
102	`#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))`	104	`#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))`
103		105
104	`/*`	106	`/*`
105	`Characters are mapped into these 31 character classes. This allows for`	107	`Characters are mapped into these 31 character classes. This allows for`
106	`a significant reduction in the size of the state transition table.`	108	`a significant reduction in the size of the state transition table.`
107	`*/`	109	`*/`
108		110
109		111
110		112
111	`enum classes {`	113	`enum classes {`
112	`C_SPACE, /* space */`	114	`C_SPACE, /* space */`
113	`C_WHITE, /* other whitespace */`	115	`C_WHITE, /* other whitespace */`
114	`C_LCURB, /* { */`	116	`C_LCURB, /* { */`
115	`C_RCURB, /* } */`	117	`C_RCURB, /* } */`
116	`C_LSQRB, /* [ */`	118	`C_LSQRB, /* [ */`
117	`C_RSQRB, /* ] */`	119	`C_RSQRB, /* ] */`
118	`C_COLON, /* : */`	120	`C_COLON, /* : */`
119	`C_COMMA, /* , */`	121	`C_COMMA, /* , */`
120	`C_QUOTE, /* " */`	122	`C_QUOTE, /* " */`
121	`C_BACKS, /* \ */`	123	`C_BACKS, /* \ */`
122	`C_SLASH, /* / */`	124	`C_SLASH, /* / */`
123	`C_PLUS, /* + */`	125	`C_PLUS, /* + */`
124	`C_MINUS, /* - */`	126	`C_MINUS, /* - */`
125	`C_POINT, /* . */`	127	`C_POINT, /* . */`
126	`C_ZERO , /* 0 */`	128	`C_ZERO , /* 0 */`
127	`C_DIGIT, /* 123456789 */`	129	`C_DIGIT, /* 123456789 */`
128	`C_LOW_A, /* a */`	130	`C_LOW_A, /* a */`
129	`C_LOW_B, /* b */`	131	`C_LOW_B, /* b */`
130	`C_LOW_C, /* c */`	132	`C_LOW_C, /* c */`
131	`C_LOW_D, /* d */`	133	`C_LOW_D, /* d */`
132	`C_LOW_E, /* e */`	134	`C_LOW_E, /* e */`
133	`C_LOW_F, /* f */`	135	`C_LOW_F, /* f */`
134	`C_LOW_L, /* l */`	136	`C_LOW_L, /* l */`
135	`C_LOW_N, /* n */`	137	`C_LOW_N, /* n */`
136	`C_LOW_R, /* r */`	138	`C_LOW_R, /* r */`
137	`C_LOW_S, /* s */`	139	`C_LOW_S, /* s */`
138	`C_LOW_T, /* t */`	140	`C_LOW_T, /* t */`
139	`C_LOW_U, /* u */`	141	`C_LOW_U, /* u */`
140	`C_ABCDF, /* ABCDF */`	142	`C_ABCDF, /* ABCDF */`
141	`C_E, /* E */`	143	`C_E, /* E */`
142	`C_ETC, /* everything else */`	144	`C_ETC, /* everything else */`
143	`C_STAR, /* * */`	145	`C_STAR, /* * */`
144	`NR_CLASSES`	146	`NR_CLASSES`
145	`};`	147	`};`
146		148
147	`static int ascii_class[128] = {`	149	`static int ascii_class[128] = {`
148	`/*`	150	`/*`
149	`This array maps the 128 ASCII characters into character classes.`	151	`This array maps the 128 ASCII characters into character classes.`
150	`The remaining Unicode characters should be mapped to C_ETC.`	152	`The remaining Unicode characters should be mapped to C_ETC.`
151	`Non-whitespace control characters are errors.`	153	`Non-whitespace control characters are errors.`
152	`*/`	154	`*/`
153	`__, __, __, __, __, __, __, __,`	155	`__, __, __, __, __, __, __, __,`
154	`__, C_WHITE, C_WHITE, __, __, C_WHITE, __, __,`	156	`__, C_WHITE, C_WHITE, __, __, C_WHITE, __, __,`
155	`__, __, __, __, __, __, __, __,`	157	`__, __, __, __, __, __, __, __,`
156	`__, __, __, __, __, __, __, __,`	158	`__, __, __, __, __, __, __, __,`
157		159
158	`C_SPACE, C_ETC, C_QUOTE, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`	160	`C_SPACE, C_ETC, C_QUOTE, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`
159	`C_ETC, C_ETC, C_STAR, C_PLUS, C_COMMA, C_MINUS, C_POINT, C_SLASH,`	161	`C_ETC, C_ETC, C_STAR, C_PLUS, C_COMMA, C_MINUS, C_POINT, C_SLASH,`
160	`C_ZERO, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT,`	162	`C_ZERO, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT,`
161	`C_DIGIT, C_DIGIT, C_COLON, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`	163	`C_DIGIT, C_DIGIT, C_COLON, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`
162		164
163	`C_ETC, C_ABCDF, C_ABCDF, C_ABCDF, C_ABCDF, C_E, C_ABCDF, C_ETC,`	165	`C_ETC, C_ABCDF, C_ABCDF, C_ABCDF, C_ABCDF, C_E, C_ABCDF, C_ETC,`
164	`C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`	166	`C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`
165	`C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`	167	`C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC,`
166	`C_ETC, C_ETC, C_ETC, C_LSQRB, C_BACKS, C_RSQRB, C_ETC, C_ETC,`	168	`C_ETC, C_ETC, C_ETC, C_LSQRB, C_BACKS, C_RSQRB, C_ETC, C_ETC,`
167		169
168	`C_ETC, C_LOW_A, C_LOW_B, C_LOW_C, C_LOW_D, C_LOW_E, C_LOW_F, C_ETC,`	170	`C_ETC, C_LOW_A, C_LOW_B, C_LOW_C, C_LOW_D, C_LOW_E, C_LOW_F, C_ETC,`
169	`C_ETC, C_ETC, C_ETC, C_ETC, C_LOW_L, C_ETC, C_LOW_N, C_ETC,`	171	`C_ETC, C_ETC, C_ETC, C_ETC, C_LOW_L, C_ETC, C_LOW_N, C_ETC,`
170	`C_ETC, C_ETC, C_LOW_R, C_LOW_S, C_LOW_T, C_LOW_U, C_ETC, C_ETC,`	172	`C_ETC, C_ETC, C_LOW_R, C_LOW_S, C_LOW_T, C_LOW_U, C_ETC, C_ETC,`
171	`C_ETC, C_ETC, C_ETC, C_LCURB, C_ETC, C_RCURB, C_ETC, C_ETC`	173	`C_ETC, C_ETC, C_ETC, C_LCURB, C_ETC, C_RCURB, C_ETC, C_ETC`
172	`};`	174	`};`
173		175
174		176
175	`/*`	177	`/*`
176	`The state codes.`	178	`The state codes.`
177	`*/`	179	`*/`
178	`enum states {`	180	`enum states {`
179	`GO, /* start */`	181	`GO, /* start */`
180	`OK, /* ok */`	182	`OK, /* ok */`
181	`OB, /* object */`	183	`OB, /* object */`
182	`KE, /* key */`	184	`KE, /* key */`
183	`CO, /* colon */`	185	`CO, /* colon */`
184	`VA, /* value */`	186	`VA, /* value */`
185	`AR, /* array */`	187	`AR, /* array */`
186	`ST, /* string */`	188	`ST, /* string */`
187	`ES, /* escape */`	189	`ES, /* escape */`
188	`U1, /* u1 */`	190	`U1, /* u1 */`
189	`U2, /* u2 */`	191	`U2, /* u2 */`
190	`U3, /* u3 */`	192	`U3, /* u3 */`
191	`U4, /* u4 */`	193	`U4, /* u4 */`
192	`MI, /* minus */`	194	`MI, /* minus */`
193	`ZE, /* zero */`	195	`ZE, /* zero */`
194	`IT, /* integer */`	196	`IT, /* integer */`
195	`FR, /* fraction */`	197	`FR, /* fraction */`
196	`E1, /* e */`	198	`E1, /* e */`
197	`E2, /* ex */`	199	`E2, /* ex */`
198	`E3, /* exp */`	200	`E3, /* exp */`
199	`T1, /* tr */`	201	`T1, /* tr */`
200	`T2, /* tru */`	202	`T2, /* tru */`
201	`T3, /* true */`	203	`T3, /* true */`
202	`F1, /* fa */`	204	`F1, /* fa */`
203	`F2, /* fal */`	205	`F2, /* fal */`
204	`F3, /* fals */`	206	`F3, /* fals */`
205	`F4, /* false */`	207	`F4, /* false */`
206	`N1, /* nu */`	208	`N1, /* nu */`
207	`N2, /* nul */`	209	`N2, /* nul */`
208	`N3, /* null */`	210	`N3, /* null */`
209	`C1, /* / */`	211	`C1, /* / */`
210	`C2, /* / * */`	212	`C2, /* / * */`
211	`C3, /* * */`	213	`C3, /* * */`
212	`FX, /* . eE */`	214	`FX, /* . eE */`
213	`D1, /* second UTF-16 character decoding started by \ */`	215	`D1, /* second UTF-16 character decoding started by \ */`
214	`D2, /* second UTF-16 character proceeded by u */`	216	`D2, /* second UTF-16 character proceeded by u */`
215	`NR_STATES`	217	`NR_STATES`
216	`};`	218	`};`
217		219
218	`enum actions`	220	`enum actions`
219	`{`	221	`{`
220	`CB = -10, /* comment begin */`	222	`CB = -10, /* comment begin */`
221	`CE = -11, /* comment end */`	223	`CE = -11, /* comment end */`
222	`FA = -12, /* false */`	224	`FA = -12, /* false */`
223	`TR = -13, /* false */`	225	`TR = -13, /* false */`
224	`NU = -14, /* null */`	226	`NU = -14, /* null */`
225	`DE = -15, /* double detected by exponent e E */`	227	`DE = -15, /* double detected by exponent e E */`
226	`DF = -16, /* double detected by fraction . */`	228	`DF = -16, /* double detected by fraction . */`
227	`SB = -17, /* string begin */`	229	`SB = -17, /* string begin */`
228	`MX = -18, /* integer detected by minus */`	230	`MX = -18, /* integer detected by minus */`
229	`ZX = -19, /* integer detected by zero */`	231	`ZX = -19, /* integer detected by zero */`
230	`IX = -20, /* integer detected by 1-9 */`	232	`IX = -20, /* integer detected by 1-9 */`
231	`EX = -21, /* next char is escaped */`	233	`EX = -21, /* next char is escaped */`
232	`UC = -22, /* Unicode character read */`	234	`UC = -22, /* Unicode character read */`
233	`};`	235	`};`
234		236
235		237
236	`static int state_transition_table[NR_STATES][NR_CLASSES] = {`	238	`static int state_transition_table[NR_STATES][NR_CLASSES] = {`
237	`/*`	239	`/*`
238	`The state transition table takes the current state and the current symbol,`	240	`The state transition table takes the current state and the current symbol,`
239	`and returns either a new state or an action. An action is represented as a`	241	`and returns either a new state or an action. An action is represented as a`
240	`negative number. A JSON text is accepted if at the end of the text the`	242	`negative number. A JSON text is accepted if at the end of the text the`
241	`state is OK and if the mode is MODE_DONE.`	243	`state is OK and if the mode is MODE_DONE.`
242		244
243	`white 1-9 ABCDF etc`	245	`white 1-9 ABCDF etc`
244	`space \| { } [ ] : , " \ / + - . 0 \| a b c d e f l n r s t u \| E \| * */`	246	`space \| { } [ ] : , " \ / + - . 0 \| a b c d e f l n r s t u \| E \| * */`
245	`/start GO/ {GO,GO,-6,__,-5,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	247	`/start GO/ {GO,GO,-6,__,-5,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
246	`/ok OK/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	248	`/ok OK/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
247	`/object OB/ {OB,OB,__,-9,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	249	`/object OB/ {OB,OB,__,-9,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
248	`/key KE/ {KE,KE,__,__,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	250	`/key KE/ {KE,KE,__,__,__,__,__,__,SB,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
249	`/colon CO/ {CO,CO,__,__,__,__,-2,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	251	`/colon CO/ {CO,CO,__,__,__,__,-2,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
250	`/value VA/ {VA,VA,-6,__,-5,__,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},`	252	`/value VA/ {VA,VA,-6,__,-5,__,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},`
251	`/array AR/ {AR,AR,-6,__,-5,-7,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},`	253	`/array AR/ {AR,AR,-6,__,-5,-7,__,__,SB,__,CB,__,MX,__,ZX,IX,__,__,__,__,__,FA,__,NU,__,__,TR,__,__,__,__,__},`
252	`/string ST/ {ST,__,ST,ST,ST,ST,ST,ST,-4,EX,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST},`	254	`/string ST/ {ST,__,ST,ST,ST,ST,ST,ST,-4,EX,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST},`
253	`/escape ES/ {__,__,__,__,__,__,__,__,ST,ST,ST,__,__,__,__,__,__,ST,__,__,__,ST,__,ST,ST,__,ST,U1,__,__,__,__},`	255	`/escape ES/ {__,__,__,__,__,__,__,__,ST,ST,ST,__,__,__,__,__,__,ST,__,__,__,ST,__,ST,ST,__,ST,U1,__,__,__,__},`
254	`/u1 U1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U2,U2,U2,U2,U2,U2,U2,U2,__,__,__,__,__,__,U2,U2,__,__},`	256	`/u1 U1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U2,U2,U2,U2,U2,U2,U2,U2,__,__,__,__,__,__,U2,U2,__,__},`
255	`/u2 U2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U3,U3,U3,U3,U3,U3,U3,U3,__,__,__,__,__,__,U3,U3,__,__},`	257	`/u2 U2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U3,U3,U3,U3,U3,U3,U3,U3,__,__,__,__,__,__,U3,U3,__,__},`
256	`/u3 U3/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U4,U4,U4,U4,U4,U4,U4,U4,__,__,__,__,__,__,U4,U4,__,__},`	258	`/u3 U3/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,U4,U4,U4,U4,U4,U4,U4,U4,__,__,__,__,__,__,U4,U4,__,__},`
257	`/u4 U4/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,UC,UC,UC,UC,UC,UC,UC,UC,__,__,__,__,__,__,UC,UC,__,__},`	259	`/u4 U4/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,UC,UC,UC,UC,UC,UC,UC,UC,__,__,__,__,__,__,UC,UC,__,__},`
258	`/minus MI/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,ZE,IT,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	260	`/minus MI/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,ZE,IT,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
259	`/zero ZE/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	261	`/zero ZE/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
260	`/int IT/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,IT,IT,__,__,__,__,DE,__,__,__,__,__,__,__,__,DE,__,__},`	262	`/int IT/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,DF,IT,IT,__,__,__,__,DE,__,__,__,__,__,__,__,__,DE,__,__},`
261	`/frac FR/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},`	263	`/frac FR/ {OK,OK,__,-8,__,-7,__,-3,__,__,CB,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},`
262	`/e E1/ {__,__,__,__,__,__,__,__,__,__,__,E2,E2,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	264	`/e E1/ {__,__,__,__,__,__,__,__,__,__,__,E2,E2,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
263	`/ex E2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	265	`/ex E2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
264	`/exp E3/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	266	`/exp E3/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,E3,E3,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
265	`/tr T1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T2,__,__,__,__,__,__,__},`	267	`/tr T1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T2,__,__,__,__,__,__,__},`
266	`/tru T2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T3,__,__,__,__},`	268	`/tru T2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,T3,__,__,__,__},`
267	`/true T3/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},`	269	`/true T3/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},`
268	`/fa F1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	270	`/fa F1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
269	`/fal F2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F3,__,__,__,__,__,__,__,__,__},`	271	`/fal F2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F3,__,__,__,__,__,__,__,__,__},`
270	`/fals F3/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F4,__,__,__,__,__,__},`	272	`/fals F3/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,F4,__,__,__,__,__,__},`
271	`/false F4/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},`	273	`/false F4/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__},`
272	`/nu N1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N2,__,__,__,__},`	274	`/nu N1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N2,__,__,__,__},`
273	`/nul N2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N3,__,__,__,__,__,__,__,__,__},`	275	`/nul N2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N3,__,__,__,__,__,__,__,__,__},`
274	`/null N3/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__},`	276	`/null N3/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__},`
275	`// C1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,C2},`	277	`// C1/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,C2},`
276	`// C2*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},`	278	`// C2*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},`
277	`/** C3*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,CE,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},`	279	`/** C3*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,CE,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3},`
278	`/_. FX/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},`	280	`/_. FX/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__},`
279	`/\ D1/ {__,__,__,__,__,__,__,__,__,D2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`	281	`/\ D1/ {__,__,__,__,__,__,__,__,__,D2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__},`
280	`/\ D2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,U1,__,__,__,__},`	282	`/\ D2/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,U1,__,__,__,__},`
281	`};`	283	`};`
282		284
283		285
284	`/*`	286	`/*`
285	`These modes can be pushed on the stack.`	287	`These modes can be pushed on the stack.`
286	`*/`	288	`*/`
287	`enum modes {`	289	`enum modes {`
288	`MODE_ARRAY = 1,`	290	`MODE_ARRAY = 1,`
289	`MODE_DONE = 2,`	291	`MODE_DONE = 2,`
290	`MODE_KEY = 3,`	292	`MODE_KEY = 3,`
291	`MODE_OBJECT = 4`	293	`MODE_OBJECT = 4`
292	`};`	294	`};`
293		295
294	`static int`	296	`static int`
295	`push(JSON_parser jc, int mode)`	297	`push(JSON_parser jc, int mode)`
296	`{`	298	`{`
297	`/*`	299	`/*`
298	`Push a mode onto the stack. Return false if there is overflow.`	300	`Push a mode onto the stack. Return false if there is overflow.`
299	`*/`	301	`*/`
300	`jc->top += 1;`	302	`jc->top += 1;`
301	`if (jc->depth < 0) {`	303	`if (jc->depth < 0) {`
302	`if (jc->top >= jc->stack_capacity) {`	304	`if (jc->top >= jc->stack_capacity) {`
303	`size_t bytes_to_allocate;`	305	`size_t bytes_to_allocate;`
304	`jc->stack_capacity *= 2;`	306	`jc->stack_capacity *= 2;`
305	`bytes_to_allocate = jc->stack_capacity * sizeof(jc->static_stack[0]);`	307	`bytes_to_allocate = jc->stack_capacity * sizeof(jc->static_stack[0]);`
306	`if (jc->stack == &jc->static_stack[0]) {`	308	`if (jc->stack == &jc->static_stack[0]) {`
307	`jc->stack = (signed char*)malloc(bytes_to_allocate);`	309	`jc->stack = (signed char*)malloc(bytes_to_allocate);`
308	`memcpy(jc->stack, jc->static_stack, sizeof(jc->static_stack));`	310	`memcpy(jc->stack, jc->static_stack, sizeof(jc->static_stack));`
309	`} else {`	311	`} else {`
310	`jc->stack = (signed char*)realloc(jc->stack, bytes_to_allocate);`	312	`jc->stack = (signed char*)realloc(jc->stack, bytes_to_allocate);`
311	`}`	313	`}`
312	`}`	314	`}`
313	`} else {`	315	`} else {`
314	`if (jc->top >= jc->depth) {`	316	`if (jc->top >= jc->depth) {`
315	`return false;`	317	`return false;`
316	`}`	318	`}`
317	`}`	319	`}`
318		320
319	`jc->stack[jc->top] = (signed char)mode;`	321	`jc->stack[jc->top] = (signed char)mode;`
320	`return true;`	322	`return true;`
321	`}`	323	`}`
322		324
323		325
324	`static int`	326	`static int`
325	`pop(JSON_parser jc, int mode)`	327	`pop(JSON_parser jc, int mode)`
326	`{`	328	`{`
327	`/*`	329	`/*`
328	`Pop the stack, assuring that the current mode matches the expectation.`	330	`Pop the stack, assuring that the current mode matches the expectation.`
329	`Return false if there is underflow or if the modes mismatch.`	331	`Return false if there is underflow or if the modes mismatch.`
330	`*/`	332	`*/`
331	`if (jc->top < 0 \|\| jc->stack[jc->top] != mode) {`	333	`if (jc->top < 0 \|\| jc->stack[jc->top] != mode) {`
332	`return false;`	334	`return false;`
333	`}`	335	`}`
334	`jc->top -= 1;`	336	`jc->top -= 1;`
335	`return true;`	337	`return true;`
336	`}`	338	`}`
337		339
338		340
339	`#define parse_buffer_clear(jc) \`	341	`#define parse_buffer_clear(jc) \`
340	`do {\`	342	`do {\`
341	`jc->parse_buffer_count = 0;\`	343	`jc->parse_buffer_count = 0;\`
342	`jc->parse_buffer[0] = 0;\`	344	`jc->parse_buffer[0] = 0;\`
343	`} while (0)`	345	`} while (0)`
344		346
345	`#define parse_buffer_pop_back_char(jc)\`	347	`#define parse_buffer_pop_back_char(jc)\`
346	`do {\`	348	`do {\`
347	`assert(jc->parse_buffer_count >= 1);\`	349	`assert(jc->parse_buffer_count >= 1);\`
348	`--jc->parse_buffer_count;\`	350	`--jc->parse_buffer_count;\`
349	`jc->parse_buffer[jc->parse_buffer_count] = 0;\`	351	`jc->parse_buffer[jc->parse_buffer_count] = 0;\`
350	`} while (0)`	352	`} while (0)`
351		353
352	`void delete_JSON_parser(JSON_parser jc)`	354	`void delete_JSON_parser(JSON_parser jc)`
353	`{`	355	`{`
354	`if (jc) {`	356	`if (jc) {`
355	`if (jc->stack != &jc->static_stack[0]) {`	357	`if (jc->stack != &jc->static_stack[0]) {`
356	`free((void*)jc->stack);`	358	`free((void*)jc->stack);`
357	`}`	359	`}`
358	`if (jc->parse_buffer != &jc->static_parse_buffer[0]) {`	360	`if (jc->parse_buffer != &jc->static_parse_buffer[0]) {`
359	`free((void*)jc->parse_buffer);`	361	`free((void*)jc->parse_buffer);`
360	`}`	362	`}`
361	`free((void*)jc);`	363	`free((void*)jc);`
362	`}`	364	`}`
363	`}`	365	`}`
364		366
365		367
366	`JSON_parser`	368	`JSON_parser`
367	`new_JSON_parser(JSON_config* config)`	369	`new_JSON_parser(JSON_config* config)`
368	`{`	370	`{`
369	`/*`	371	`/*`
370	`new_JSON_parser starts the checking process by constructing a JSON_parser`	372	`new_JSON_parser starts the checking process by constructing a JSON_parser`
371	`object. It takes a depth parameter that restricts the level of maximum`	373	`object. It takes a depth parameter that restricts the level of maximum`
372	`nesting.`	374	`nesting.`
373		375
374	`To continue the process, call JSON_parser_char for each character in the`	376	`To continue the process, call JSON_parser_char for each character in the`
375	`JSON text, and then call JSON_parser_done to obtain the final result.`	377	`JSON text, and then call JSON_parser_done to obtain the final result.`
376	`These functions are fully reentrant.`	378	`These functions are fully reentrant.`
377	`*/`	379	`*/`
378		380
379	`int depth = 0;`	381	`int depth = 0;`
380	`JSON_config default_config;`	382	`JSON_config default_config;`
381		383
382	`JSON_parser jc = malloc(sizeof(struct JSON_parser_struct));`	384	`JSON_parser jc = malloc(sizeof(struct JSON_parser_struct));`
383		385
384	`memset(jc, 0, sizeof(*jc));`	386	`memset(jc, 0, sizeof(*jc));`
385		387
386		388
387	`/* initialize configuration */`	389	`/* initialize configuration */`
388	`init_JSON_config(&default_config);`	390	`init_JSON_config(&default_config);`
389		391
390	`/* set to default configuration if none was provided */`	392	`/* set to default configuration if none was provided */`
391	`if (config == NULL) {`	393	`if (config == NULL) {`
392	`config = &default_config;`	394	`config = &default_config;`
393	`}`	395	`}`
394		396
395	`depth = config->depth;`	397	`depth = config->depth;`
396		398
397	`/* We need to be able to push at least one object */`	399	`/* We need to be able to push at least one object */`
398	`if (depth == 0) {`	400	`if (depth == 0) {`
399	`depth = 1;`	401	`depth = 1;`
400	`}`	402	`}`
401		403
402	`jc->state = GO;`	404	`jc->state = GO;`
403	`jc->top = -1;`	405	`jc->top = -1;`
404		406
405	`/* Do we want non-bound stack? */`	407	`/* Do we want non-bound stack? */`
406	`if (depth > 0) {`	408	`if (depth > 0) {`
407	`jc->stack_capacity = depth;`	409	`jc->stack_capacity = depth;`
408	`jc->depth = depth;`	410	`jc->depth = depth;`
409	`if (depth <= COUNTOF(jc->static_stack)) {`	411	`if (depth <= COUNTOF(jc->static_stack)) {`
410	`jc->stack = &jc->static_stack[0];`	412	`jc->stack = &jc->static_stack[0];`
411	`} else {`	413	`} else {`
412	`jc->stack = (signed char)malloc(jc->stack_capacity sizeof(jc->static_stack[0]));`	414	`jc->stack = (signed char)malloc(jc->stack_capacity sizeof(jc->static_stack[0]));`
413	`}`	415	`}`
414	`} else {`	416	`} else {`
415	`jc->stack_capacity = COUNTOF(jc->static_stack);`	417	`jc->stack_capacity = COUNTOF(jc->static_stack);`
416	`jc->depth = -1;`	418	`jc->depth = -1;`
417	`jc->stack = &jc->static_stack[0];`	419	`jc->stack = &jc->static_stack[0];`
418	`}`	420	`}`
419		421
420	`/* set parser to start */`	422	`/* set parser to start */`
421	`push(jc, MODE_DONE);`	423	`push(jc, MODE_DONE);`
422		424
423	`/* set up the parse buffer */`	425	`/* set up the parse buffer */`
424	`jc->parse_buffer = &jc->static_parse_buffer[0];`	426	`jc->parse_buffer = &jc->static_parse_buffer[0];`
425	`jc->parse_buffer_capacity = COUNTOF(jc->static_parse_buffer);`	427	`jc->parse_buffer_capacity = COUNTOF(jc->static_parse_buffer);`
426	`parse_buffer_clear(jc);`	428	`parse_buffer_clear(jc);`
427		429
428	`/* set up callback, comment & float handling */`	430	`/* set up callback, comment & float handling */`
429	`jc->callback = config->callback;`	431	`jc->callback = config->callback;`
430	`jc->ctx = config->callback_ctx;`	432	`jc->ctx = config->callback_ctx;`
431	`jc->allow_comments = config->allow_comments != 0;`	433	`jc->allow_comments = config->allow_comments != 0;`
432	`jc->handle_floats_manually = config->handle_floats_manually != 0;`	434	`jc->handle_floats_manually = config->handle_floats_manually != 0;`
433	`return jc;`	435	`return jc;`
434	`}`	436	`}`
435		437
436	`static void grow_parse_buffer(JSON_parser jc)`	438	`static void grow_parse_buffer(JSON_parser jc)`
437	`{`	439	`{`
438	`size_t bytes_to_allocate;`	440	`size_t bytes_to_allocate;`
439	`jc->parse_buffer_capacity *= 2;`	441	`jc->parse_buffer_capacity *= 2;`
440	`bytes_to_allocate = jc->parse_buffer_capacity * sizeof(jc->parse_buffer[0]);`	442	`bytes_to_allocate = jc->parse_buffer_capacity * sizeof(jc->parse_buffer[0]);`
441	`if (jc->parse_buffer == &jc->static_parse_buffer[0]) {`	443	`if (jc->parse_buffer == &jc->static_parse_buffer[0]) {`
442	`jc->parse_buffer = (char*)malloc(bytes_to_allocate);`	444	`jc->parse_buffer = (char*)malloc(bytes_to_allocate);`
443	`memcpy(jc->parse_buffer, jc->static_parse_buffer, jc->parse_buffer_count);`	445	`memcpy(jc->parse_buffer, jc->static_parse_buffer, jc->parse_buffer_count);`
444	`} else {`	446	`} else {`
445	`jc->parse_buffer = (char*)realloc(jc->parse_buffer, bytes_to_allocate);`	447	`jc->parse_buffer = (char*)realloc(jc->parse_buffer, bytes_to_allocate);`
446	`}`	448	`}`
447	`}`	449	`}`
448		450
449	`#define parse_buffer_push_back_char(jc, c)\`	451	`#define parse_buffer_push_back_char(jc, c)\`
450	`do {\`	452	`do {\`
451	`if (jc->parse_buffer_count + 1 >= jc->parse_buffer_capacity) grow_parse_buffer(jc);\`	453	`if (jc->parse_buffer_count + 1 >= jc->parse_buffer_capacity) grow_parse_buffer(jc);\`
452	`jc->parse_buffer[jc->parse_buffer_count++] = c;\`	454	`jc->parse_buffer[jc->parse_buffer_count++] = c;\`
453	`jc->parse_buffer[jc->parse_buffer_count] = 0;\`	455	`jc->parse_buffer[jc->parse_buffer_count] = 0;\`
454	`} while (0)`	456	`} while (0)`
455		457
456		458
457	`static int parse_parse_buffer(JSON_parser jc)`	459	`static int parse_parse_buffer(JSON_parser jc)`
458	`{`	460	`{`
459	`if (jc->callback) {`	461	`if (jc->callback) {`
460	`JSON_value value, *arg = NULL;`	462	`JSON_value value, *arg = NULL;`
461		463
462	`if (jc->type != JSON_T_NONE) {`	464	`if (jc->type != JSON_T_NONE) {`
463	`assert(`	465	`assert(`
464	`jc->type == JSON_T_NULL \|\|`	466	`jc->type == JSON_T_NULL \|\|`
465	`jc->type == JSON_T_FALSE \|\|`	467	`jc->type == JSON_T_FALSE \|\|`
466	`jc->type == JSON_T_TRUE \|\|`	468	`jc->type == JSON_T_TRUE \|\|`
467	`jc->type == JSON_T_FLOAT \|\|`	469	`jc->type == JSON_T_FLOAT \|\|`
468	`jc->type == JSON_T_INTEGER \|\|`	470	`jc->type == JSON_T_INTEGER \|\|`
469	`jc->type == JSON_T_STRING);`	471	`jc->type == JSON_T_STRING);`
470		472
471	`switch(jc->type) {`	473	`switch(jc->type) {`
472	`case JSON_T_FLOAT:`	474	`case JSON_T_FLOAT:`
473	`arg = &value;`	475	`arg = &value;`
474	`if (jc->handle_floats_manually) {`	476	`if (jc->handle_floats_manually) {`
475	`value.vu.str.value = jc->parse_buffer;`	477	`value.vu.str.value = jc->parse_buffer;`
476	`value.vu.str.length = jc->parse_buffer_count;`	478	`value.vu.str.length = jc->parse_buffer_count;`
477	`} else {`	479	`} else {`
478	`sscanf(jc->parse_buffer, DoubleScanFormat, &value.vu.float_value);`	480	`sscanf(jc->parse_buffer, DoubleScanFormat, &value.vu.float_value);`
479	`}`	481	`}`
480	`break;`	482	`break;`
481	`case JSON_T_INTEGER: {`	483	`case JSON_T_INTEGER: {`
482	`double tmp;`	484	`double tmp;`
483	`arg = &value;`	485	`arg = &value;`
484	`// value unused`	486	`// value unused`
485	`int ok = sscanf(jc->parse_buffer, "%lf", &tmp);`	487	`int ok = sscanf(jc->parse_buffer, "%lf", &tmp);`
486	`if(tmp > MAX_INT \|\| tmp < - MAX_INT) {`	488	`if(tmp > MAX_INT \|\| tmp < - MAX_INT) {`
487	`jc->type = JSON_T_FLOAT;`	489	`jc->type = JSON_T_FLOAT;`
488	`value.vu.float_value = tmp;`	490	`value.vu.float_value = tmp;`
489	`} else`	491	`} else`
490	`value.vu.integer_value = (JSON_int_t)tmp;`	492	`value.vu.integer_value = (JSON_int_t)tmp;`
491	`break;`	493	`break;`
492	`}`	494	`}`
493	`case JSON_T_STRING:`	495	`case JSON_T_STRING:`
494	`arg = &value;`	496	`arg = &value;`
495	`value.vu.str.value = jc->parse_buffer;`	497	`value.vu.str.value = jc->parse_buffer;`
496	`value.vu.str.length = jc->parse_buffer_count;`	498	`value.vu.str.length = jc->parse_buffer_count;`
497	`break;`	499	`break;`
498	`}`	500	`}`

The R Project SVN R-packages

(root)/trunk/RJSONIO/src/JSON_parser.c – Rev 7747 → 8509