# class JSON::Ext::Parser

This is the `JSON` parser implemented as a C extension. It can be configured to be used by setting

    JSON.parser = JSON::Ext::Parser

with the method parser= in `JSON`.

### Public Class Methods

new(source, opts → {}) click to toggle source

Creates a new `JSON::Ext::Parser` instance for the string source.

Creates a new `JSON::Ext::Parser` instance for the string source.

It will be configured by the opts hash. opts can have the following keys:

opts can have the following keys:

- max_nesting: The maximum depth of nesting allowed in the parsed data structures. Disable depth checking with :max_nesting => false|nil|0, it defaults to 100.

- allow_nan: If set to true, allow NaN, Infinity and -Infinity in defiance of RFC 4627 to be parsed by the `Parser`. This option defaults to false.

- symbolize_names: If set to true, returns symbols for the names (keys) in a `JSON` object. Otherwise strings are returned, which is also the default. It's not possible to use this option in conjunction with the create_additions option.

- create_additions: If set to false, the `Parser` doesn't create additions even if a matching class and create_id was found. This option defaults to false.

- object_class: Defaults to `Hash`

- array_class: Defaults to `Array`

    static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
    {
        VALUE source, opts;
        GET_PARSER_INIT;

        if (json->Vsource) {
            rb_raise(rb_eTypeError, "already initialized instance");
        }
    #ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
        rb_scan_args(argc, argv, "1:", &source, &opts);
    #else
        rb_scan_args(argc, argv, "11", &source, &opts);
    #endif
        if (!NIL_P(opts)) {
    #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
            opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
            if (NIL_P(opts)) {
                rb_raise(rb_eArgError, "opts needs to be like a hash");
            } else {
    #endif
                VALUE tmp = ID2SYM(i_max_nesting);
                if (option_given_p(opts, tmp)) {
                    VALUE max_nesting = rb_hash_aref(opts, tmp);
                    if (RTEST(max_nesting)) {
                        Check_Type(max_nesting, T_FIXNUM);
                        json->max_nesting = FIX2INT(max_nesting);
                    } else {
                        json->max_nesting = 0;
                    }
                } else {
                    json->max_nesting = 100;
                }
                tmp = ID2SYM(i_allow_nan);
                if (option_given_p(opts, tmp)) {
                    json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
                } else {
                    json->allow_nan = 0;
                }
                tmp = ID2SYM(i_symbolize_names);
                if (option_given_p(opts, tmp)) {
                    json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
                } else {
                    json->symbolize_names = 0;
                }
                tmp = ID2SYM(i_create_additions);
                if (option_given_p(opts, tmp)) {
                    json->create_additions = RTEST(rb_hash_aref(opts, tmp));
                } else {
                    json->create_additions = 0;
                }
                if (json->symbolize_names && json->create_additions) {
                  rb_raise(rb_eArgError,
                    "options :symbolize_names and :create_additions cannot be "
                    " used in conjunction");
                }
                tmp = ID2SYM(i_create_id);
                if (option_given_p(opts, tmp)) {
                    json->create_id = rb_hash_aref(opts, tmp);
                } else {
                    json->create_id = rb_funcall(mJSON, i_create_id, 0);
                }
                tmp = ID2SYM(i_object_class);
                if (option_given_p(opts, tmp)) {
                    json->object_class = rb_hash_aref(opts, tmp);
                } else {
                    json->object_class = Qnil;
                }
                tmp = ID2SYM(i_array_class);
                if (option_given_p(opts, tmp)) {
                    json->array_class = rb_hash_aref(opts, tmp);
                } else {
                    json->array_class = Qnil;
                }
                tmp = ID2SYM(i_decimal_class);
                if (option_given_p(opts, tmp)) {
                    json->decimal_class = rb_hash_aref(opts, tmp);
                } else {
                    json->decimal_class = Qnil;
                }
                tmp = ID2SYM(i_match_string);
                if (option_given_p(opts, tmp)) {
                    VALUE match_string = rb_hash_aref(opts, tmp);
                    json->match_string = RTEST(match_string) ? match_string : Qnil;
                } else {
                    json->match_string = Qnil;
                }
    #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
            }
    #endif
        } else {
            json->max_nesting = 100;
            json->allow_nan = 0;
            json->create_additions = 0;
            json->create_id = rb_funcall(mJSON, i_create_id, 0);
            json->object_class = Qnil;
            json->array_class = Qnil;
            json->decimal_class = Qnil;
        }
        source = convert_encoding(StringValue(source));
        StringValue(source);
        json->len = RSTRING_LEN(source);
        json->source = RSTRING_PTR(source);;
        json->Vsource = source;
        return self;
    }

### Public Instance Methods

parse() click to toggle source

Parses the current `JSON` text source and returns the complete data structure as a result.

    static VALUE cParser_parse(VALUE self)
    {
      char *p, *pe;
      int cs = EVIL;
      VALUE result = Qnil;
      GET_PARSER;

    #line 1877 "parser.c"
            {
            cs = JSON_start;
            }

    #line 776 "parser.rl"
      p = json->source;
      pe = p + json->len;

    #line 1886 "parser.c"
            {
            if ( p == pe )
                    goto _test_eof;
            switch ( cs )
            {
    st1:
            if ( ++p == pe )
                    goto _test_eof1;
    case 1:
            switch( (*p) ) {
                    case 13: goto st1;
                    case 32: goto st1;
                    case 34: goto tr2;
                    case 45: goto tr2;
                    case 47: goto st6;
                    case 73: goto tr2;
                    case 78: goto tr2;
                    case 91: goto tr2;
                    case 102: goto tr2;
                    case 110: goto tr2;
                    case 116: goto tr2;
                    case 123: goto tr2;
            }
            if ( (*p) > 10 ) {
                    if ( 48 <= (*p) && (*p) <= 57 )
                            goto tr2;
            } else if ( (*p) >= 9 )
                    goto st1;
            goto st0;
    st0:
    cs = 0;
            goto _out;
    tr2:
    #line 752 "parser.rl"
            {
            char *np = JSON_parse_value(json, p, pe, &result, 0);
            if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
        }
            goto st10;
    st10:
            if ( ++p == pe )
                    goto _test_eof10;
    case 10:
    #line 1930 "parser.c"
            switch( (*p) ) {
                    case 13: goto st10;
                    case 32: goto st10;
                    case 47: goto st2;
            }
            if ( 9 <= (*p) && (*p) <= 10 )
                    goto st10;
            goto st0;
    st2:
            if ( ++p == pe )
                    goto _test_eof2;
    case 2:
            switch( (*p) ) {
                    case 42: goto st3;
                    case 47: goto st5;
            }
            goto st0;
    st3:
            if ( ++p == pe )
                    goto _test_eof3;
    case 3:
            if ( (*p) == 42 )
                    goto st4;
            goto st3;
    st4:
            if ( ++p == pe )
                    goto _test_eof4;
    case 4:
            switch( (*p) ) {
                    case 42: goto st4;
                    case 47: goto st10;
            }
            goto st3;
    st5:
            if ( ++p == pe )
                    goto _test_eof5;
    case 5:
            if ( (*p) == 10 )
                    goto st10;
            goto st5;
    st6:
            if ( ++p == pe )
                    goto _test_eof6;
    case 6:
            switch( (*p) ) {
                    case 42: goto st7;
                    case 47: goto st9;
            }
            goto st0;
    st7:
            if ( ++p == pe )
                    goto _test_eof7;
    case 7:
            if ( (*p) == 42 )
                    goto st8;
            goto st7;
    st8:
            if ( ++p == pe )
                    goto _test_eof8;
    case 8:
            switch( (*p) ) {
                    case 42: goto st8;
                    case 47: goto st1;
            }
            goto st7;
    st9:
            if ( ++p == pe )
                    goto _test_eof9;
    case 9:
            if ( (*p) == 10 )
                    goto st1;
            goto st9;
            }
            _test_eof1: cs = 1; goto _test_eof;
            _test_eof10: cs = 10; goto _test_eof;
            _test_eof2: cs = 2; goto _test_eof;
            _test_eof3: cs = 3; goto _test_eof;
            _test_eof4: cs = 4; goto _test_eof;
            _test_eof5: cs = 5; goto _test_eof;
            _test_eof6: cs = 6; goto _test_eof;
            _test_eof7: cs = 7; goto _test_eof;
            _test_eof8: cs = 8; goto _test_eof;
            _test_eof9: cs = 9; goto _test_eof;

            _test_eof: {}
            _out: {}
            }

    #line 779 "parser.rl"

      if (cs >= JSON_first_final && p == pe) {
        return result;
      } else {
        rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
        return Qnil;
      }
    }

source() click to toggle source

Returns a copy of the current source string, that was used to construct this `Parser`.

    static VALUE cParser_source(VALUE self)
    {
        GET_PARSER;
        return rb_str_dup(json->Vsource);
    }