json 2.6.2 → 2.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (29) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES.md +46 -0
  3. data/README.md +4 -13
  4. data/ext/json/ext/generator/generator.c +122 -27
  5. data/ext/json/ext/generator/generator.h +8 -5
  6. data/ext/json/ext/parser/parser.c +1828 -2964
  7. data/ext/json/ext/parser/parser.rl +85 -100
  8. data/json.gemspec +7 -6
  9. data/lib/json/add/bigdecimal.rb +37 -8
  10. data/lib/json/add/complex.rb +28 -5
  11. data/lib/json/add/date.rb +26 -6
  12. data/lib/json/add/date_time.rb +25 -8
  13. data/lib/json/add/exception.rb +24 -6
  14. data/lib/json/add/ostruct.rb +31 -8
  15. data/lib/json/add/range.rb +32 -7
  16. data/lib/json/add/rational.rb +27 -5
  17. data/lib/json/add/regexp.rb +25 -7
  18. data/lib/json/add/set.rb +25 -6
  19. data/lib/json/add/struct.rb +28 -6
  20. data/lib/json/add/symbol.rb +27 -4
  21. data/lib/json/add/time.rb +26 -5
  22. data/lib/json/common.rb +29 -34
  23. data/lib/json/generic_object.rb +6 -2
  24. data/lib/json/pure/generator.rb +62 -28
  25. data/lib/json/pure/parser.rb +1 -1
  26. data/lib/json/version.rb +1 -1
  27. data/lib/json.rb +9 -0
  28. metadata +6 -10
  29. data/VERSION +0 -1
data/ext/json/ext/parser/parser.c CHANGED
@@ -9,14 +9,14 @@
9
9
  static void
10
10
  enc_raise(rb_encoding *enc, VALUE exc, const char *fmt, ...)
11
11
  {
12
- va_list args;
13
- VALUE mesg;
12
+ va_list args;
13
+ VALUE mesg;
14
14
 
15
- va_start(args, fmt);
16
- mesg = rb_enc_vsprintf(enc, fmt, args);
17
- va_end(args);
15
+ va_start(args, fmt);
16
+ mesg = rb_enc_vsprintf(enc, fmt, args);
17
+ va_end(args);
18
18
 
19
- rb_exc_raise(rb_exc_new3(exc, mesg));
19
+ rb_exc_raise(rb_exc_new3(exc, mesg));
20
20
  }
21
21
  # define rb_enc_raise enc_raise
22
22
  # endif
@@ -28,3320 +28,2184 @@ enc_raise(rb_encoding *enc, VALUE exc, const char *fmt, ...)
28
28
  /* unicode */
29
29
 
30
30
  static const signed char digit_values[256] = {
31
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
32
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
33
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
34
- -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
35
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
36
- 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
38
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
39
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
40
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
41
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
42
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
43
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
44
- -1, -1, -1, -1, -1, -1, -1
31
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
32
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
33
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
34
+ -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
35
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
36
+ 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
38
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
39
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
40
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
41
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
42
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
43
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
44
+ -1, -1, -1, -1, -1, -1, -1
45
45
  };
46
46
 
47
47
  static UTF32 unescape_unicode(const unsigned char *p)
48
48
  {
49
- signed char b;
50
- UTF32 result = 0;
51
- b = digit_values[p[0]];
52
- if (b < 0) return UNI_REPLACEMENT_CHAR;
53
- result = (result << 4) | (unsigned char)b;
54
- b = digit_values[p[1]];
55
- if (b < 0) return UNI_REPLACEMENT_CHAR;
56
- result = (result << 4) | (unsigned char)b;
57
- b = digit_values[p[2]];
58
- if (b < 0) return UNI_REPLACEMENT_CHAR;
59
- result = (result << 4) | (unsigned char)b;
60
- b = digit_values[p[3]];
61
- if (b < 0) return UNI_REPLACEMENT_CHAR;
62
- result = (result << 4) | (unsigned char)b;
63
- return result;
49
+ signed char b;
50
+ UTF32 result = 0;
51
+ b = digit_values[p[0]];
52
+ if (b < 0) return UNI_REPLACEMENT_CHAR;
53
+ result = (result << 4) | (unsigned char)b;
54
+ b = digit_values[p[1]];
55
+ if (b < 0) return UNI_REPLACEMENT_CHAR;
56
+ result = (result << 4) | (unsigned char)b;
57
+ b = digit_values[p[2]];
58
+ if (b < 0) return UNI_REPLACEMENT_CHAR;
59
+ result = (result << 4) | (unsigned char)b;
60
+ b = digit_values[p[3]];
61
+ if (b < 0) return UNI_REPLACEMENT_CHAR;
62
+ result = (result << 4) | (unsigned char)b;
63
+ return result;
64
64
  }
65
65
 
66
66
  static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
67
67
  {
68
- int len = 1;
69
- if (ch <= 0x7F) {
70
- buf[0] = (char) ch;
71
- } else if (ch <= 0x07FF) {
72
- buf[0] = (char) ((ch >> 6) | 0xC0);
73
- buf[1] = (char) ((ch & 0x3F) | 0x80);
74
- len++;
75
- } else if (ch <= 0xFFFF) {
76
- buf[0] = (char) ((ch >> 12) | 0xE0);
77
- buf[1] = (char) (((ch >> 6) & 0x3F) | 0x80);
78
- buf[2] = (char) ((ch & 0x3F) | 0x80);
79
- len += 2;
80
- } else if (ch <= 0x1fffff) {
81
- buf[0] =(char) ((ch >> 18) | 0xF0);
82
- buf[1] =(char) (((ch >> 12) & 0x3F) | 0x80);
83
- buf[2] =(char) (((ch >> 6) & 0x3F) | 0x80);
84
- buf[3] =(char) ((ch & 0x3F) | 0x80);
85
- len += 3;
86
- } else {
87
- buf[0] = '?';
88
- }
89
- return len;
68
+ int len = 1;
69
+ if (ch <= 0x7F) {
70
+ buf[0] = (char) ch;
71
+ } else if (ch <= 0x07FF) {
72
+ buf[0] = (char) ((ch >> 6) | 0xC0);
73
+ buf[1] = (char) ((ch & 0x3F) | 0x80);
74
+ len++;
75
+ } else if (ch <= 0xFFFF) {
76
+ buf[0] = (char) ((ch >> 12) | 0xE0);
77
+ buf[1] = (char) (((ch >> 6) & 0x3F) | 0x80);
78
+ buf[2] = (char) ((ch & 0x3F) | 0x80);
79
+ len += 2;
80
+ } else if (ch <= 0x1fffff) {
81
+ buf[0] =(char) ((ch >> 18) | 0xF0);
82
+ buf[1] =(char) (((ch >> 12) & 0x3F) | 0x80);
83
+ buf[2] =(char) (((ch >> 6) & 0x3F) | 0x80);
84
+ buf[3] =(char) ((ch & 0x3F) | 0x80);
85
+ len += 3;
86
+ } else {
87
+ buf[0] = '?';
88
+ }
89
+ return len;
90
90
  }
91
91
 
92
92
  static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
93
93
  static VALUE CNaN, CInfinity, CMinusInfinity;
94
94
 
95
95
  static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
96
- i_chr, i_max_nesting, i_allow_nan, i_symbolize_names,
97
- i_object_class, i_array_class, i_decimal_class, i_key_p,
98
- i_deep_const_get, i_match, i_match_string, i_aset, i_aref,
99
- i_leftshift, i_new, i_try_convert, i_freeze, i_uminus;
96
+ i_chr, i_max_nesting, i_allow_nan, i_symbolize_names,
97
+ i_object_class, i_array_class, i_decimal_class, i_key_p,
98
+ i_deep_const_get, i_match, i_match_string, i_aset, i_aref,
99
+ i_leftshift, i_new, i_try_convert, i_freeze, i_uminus;
100
100
 
101
101
 
102
102
  #line 125 "parser.rl"
103
103
 
104
104
 
105
105
 
106
+ #line 107 "parser.c"
106
107
  enum {JSON_object_start = 1};
107
108
  enum {JSON_object_first_final = 27};
108
109
  enum {JSON_object_error = 0};
109
110
 
110
111
  enum {JSON_object_en_main = 1};
111
112
 
112
- static const char MAYBE_UNUSED(_JSON_object_nfa_targs)[] = {
113
- 0, 0
114
- };
115
-
116
- static const char MAYBE_UNUSED(_JSON_object_nfa_offsets)[] = {
117
- 0, 0, 0, 0, 0, 0, 0, 0,
118
- 0, 0, 0, 0, 0, 0, 0, 0,
119
- 0, 0, 0, 0, 0, 0, 0, 0,
120
- 0, 0, 0, 0, 0
121
- };
122
-
123
- static const char MAYBE_UNUSED(_JSON_object_nfa_push_actions)[] = {
124
- 0, 0
125
- };
126
-
127
- static const char MAYBE_UNUSED(_JSON_object_nfa_pop_trans)[] = {
128
- 0, 0
129
- };
130
-
131
113
 
132
114
  #line 167 "parser.rl"
133
115
 
134
116
 
135
117
  static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
136
118
  {
137
- int cs = EVIL;
138
- VALUE last_name = Qnil;
139
- VALUE object_class = json->object_class;
119
+ int cs = EVIL;
120
+ VALUE last_name = Qnil;
121
+ VALUE object_class = json->object_class;
140
122
 
141
- if (json->max_nesting && current_nesting > json->max_nesting) {
142
- rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
143
- }
123
+ if (json->max_nesting && current_nesting > json->max_nesting) {
124
+ rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
125
+ }
144
126
 
145
- *result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
127
+ *result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
146
128
 
147
129
 
130
+ #line 131 "parser.c"
148
131
  {
149
- cs = (int)JSON_object_start;
132
+ cs = JSON_object_start;
150
133
  }
151
134
 
152
- #line 182 "parser.rl"
153
-
135
+ #line 182 "parser.rl"
154
136
 
137
+ #line 138 "parser.c"
155
138
  {
156
- if ( p == pe )
139
+ if ( p == pe )
157
140
  goto _test_eof;
158
- switch ( cs )
159
- {
160
- case 1:
161
- goto st_case_1;
162
- case 0:
163
- goto st_case_0;
164
- case 2:
165
- goto st_case_2;
166
- case 3:
167
- goto st_case_3;
168
- case 4:
169
- goto st_case_4;
170
- case 5:
171
- goto st_case_5;
172
- case 6:
173
- goto st_case_6;
174
- case 7:
175
- goto st_case_7;
176
- case 8:
177
- goto st_case_8;
178
- case 9:
179
- goto st_case_9;
180
- case 10:
181
- goto st_case_10;
182
- case 11:
183
- goto st_case_11;
184
- case 12:
185
- goto st_case_12;
186
- case 13:
187
- goto st_case_13;
188
- case 14:
189
- goto st_case_14;
190
- case 15:
191
- goto st_case_15;
192
- case 16:
193
- goto st_case_16;
194
- case 17:
195
- goto st_case_17;
196
- case 18:
197
- goto st_case_18;
198
- case 27:
199
- goto st_case_27;
200
- case 19:
201
- goto st_case_19;
202
- case 20:
203
- goto st_case_20;
204
- case 21:
205
- goto st_case_21;
206
- case 22:
207
- goto st_case_22;
208
- case 23:
209
- goto st_case_23;
210
- case 24:
211
- goto st_case_24;
212
- case 25:
213
- goto st_case_25;
214
- case 26:
215
- goto st_case_26;
216
- }
217
- goto st_out;
218
- st_case_1:
219
- if ( ( (*( p))) == 123 ) {
220
- goto st2;
221
- }
222
- {
223
- goto st0;
224
- }
225
- st_case_0:
226
- st0:
227
- cs = 0;
228
- goto _out;
229
- st2:
230
- p+= 1;
231
- if ( p == pe )
141
+ switch ( cs )
142
+ {
143
+ case 1:
144
+ if ( (*p) == 123 )
145
+ goto st2;
146
+ goto st0;
147
+ st0:
148
+ cs = 0;
149
+ goto _out;
150
+ st2:
151
+ if ( ++p == pe )
232
152
  goto _test_eof2;
233
- st_case_2:
234
- switch( ( (*( p))) ) {
235
- case 13: {
236
- goto st2;
237
- }
238
- case 32: {
239
- goto st2;
240
- }
241
- case 34: {
242
- goto ctr2;
243
- }
244
- case 47: {
245
- goto st23;
246
- }
247
- case 125: {
248
- goto ctr4;
249
- }
250
- }
251
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
252
- goto st2;
253
- }
254
- {
255
- goto st0;
256
- }
257
- ctr2:
258
- {
259
- #line 149 "parser.rl"
260
-
261
- char *np;
262
- json->parsing_name = 1;
263
- np = JSON_parse_string(json, p, pe, &last_name);
264
- json->parsing_name = 0;
265
- if (np == NULL) { {p = p - 1; } {p+= 1; cs = 3; goto _out;} } else {p = (( np))-1;}
266
-
267
- }
268
-
269
- goto st3;
270
- st3:
271
- p+= 1;
272
- if ( p == pe )
153
+ case 2:
154
+ switch( (*p) ) {
155
+ case 13: goto st2;
156
+ case 32: goto st2;
157
+ case 34: goto tr2;
158
+ case 47: goto st23;
159
+ case 125: goto tr4;
160
+ }
161
+ if ( 9 <= (*p) && (*p) <= 10 )
162
+ goto st2;
163
+ goto st0;
164
+ tr2:
165
+ #line 149 "parser.rl"
166
+ {
167
+ char *np;
168
+ json->parsing_name = 1;
169
+ np = JSON_parse_string(json, p, pe, &last_name);
170
+ json->parsing_name = 0;
171
+ if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
172
+ }
173
+ goto st3;
174
+ st3:
175
+ if ( ++p == pe )
273
176
  goto _test_eof3;
274
- st_case_3:
275
- switch( ( (*( p))) ) {
276
- case 13: {
277
- goto st3;
278
- }
279
- case 32: {
280
- goto st3;
281
- }
282
- case 47: {
283
- goto st4;
284
- }
285
- case 58: {
286
- goto st8;
287
- }
288
- }
289
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
290
- goto st3;
291
- }
292
- {
293
- goto st0;
294
- }
295
- st4:
296
- p+= 1;
297
- if ( p == pe )
177
+ case 3:
178
+ #line 179 "parser.c"
179
+ switch( (*p) ) {
180
+ case 13: goto st3;
181
+ case 32: goto st3;
182
+ case 47: goto st4;
183
+ case 58: goto st8;
184
+ }
185
+ if ( 9 <= (*p) && (*p) <= 10 )
186
+ goto st3;
187
+ goto st0;
188
+ st4:
189
+ if ( ++p == pe )
298
190
  goto _test_eof4;
299
- st_case_4:
300
- switch( ( (*( p))) ) {
301
- case 42: {
302
- goto st5;
303
- }
304
- case 47: {
305
- goto st7;
306
- }
307
- }
308
- {
309
- goto st0;
310
- }
311
- st5:
312
- p+= 1;
313
- if ( p == pe )
191
+ case 4:
192
+ switch( (*p) ) {
193
+ case 42: goto st5;
194
+ case 47: goto st7;
195
+ }
196
+ goto st0;
197
+ st5:
198
+ if ( ++p == pe )
314
199
  goto _test_eof5;
315
- st_case_5:
316
- if ( ( (*( p))) == 42 ) {
317
- goto st6;
318
- }
319
- {
320
- goto st5;
321
- }
322
- st6:
323
- p+= 1;
324
- if ( p == pe )
200
+ case 5:
201
+ if ( (*p) == 42 )
202
+ goto st6;
203
+ goto st5;
204
+ st6:
205
+ if ( ++p == pe )
325
206
  goto _test_eof6;
326
- st_case_6:
327
- switch( ( (*( p))) ) {
328
- case 42: {
329
- goto st6;
330
- }
331
- case 47: {
332
- goto st3;
333
- }
334
- }
335
- {
336
- goto st5;
337
- }
338
- st7:
339
- p+= 1;
340
- if ( p == pe )
207
+ case 6:
208
+ switch( (*p) ) {
209
+ case 42: goto st6;
210
+ case 47: goto st3;
211
+ }
212
+ goto st5;
213
+ st7:
214
+ if ( ++p == pe )
341
215
  goto _test_eof7;
342
- st_case_7:
343
- if ( ( (*( p))) == 10 ) {
344
- goto st3;
345
- }
346
- {
347
- goto st7;
348
- }
349
- st8:
350
- p+= 1;
351
- if ( p == pe )
216
+ case 7:
217
+ if ( (*p) == 10 )
218
+ goto st3;
219
+ goto st7;
220
+ st8:
221
+ if ( ++p == pe )
352
222
  goto _test_eof8;
353
- st_case_8:
354
- switch( ( (*( p))) ) {
355
- case 13: {
356
- goto st8;
357
- }
358
- case 32: {
359
- goto st8;
360
- }
361
- case 34: {
362
- goto ctr11;
363
- }
364
- case 45: {
365
- goto ctr11;
366
- }
367
- case 47: {
368
- goto st19;
369
- }
370
- case 73: {
371
- goto ctr11;
372
- }
373
- case 78: {
374
- goto ctr11;
375
- }
376
- case 91: {
377
- goto ctr11;
378
- }
379
- case 102: {
380
- goto ctr11;
381
- }
382
- case 110: {
383
- goto ctr11;
384
- }
385
- case 116: {
386
- goto ctr11;
387
- }
388
- case 123: {
389
- goto ctr11;
390
- }
391
- }
392
- if ( ( (*( p))) > 10 ) {
393
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
394
- goto ctr11;
395
- }
396
- } else if ( ( (*( p))) >= 9 ) {
397
- goto st8;
398
- }
399
- {
400
- goto st0;
401
- }
402
- ctr11:
403
- {
404
- #line 133 "parser.rl"
405
-
406
- VALUE v = Qnil;
407
- char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
408
- if (np == NULL) {
409
- {p = p - 1; } {p+= 1; cs = 9; goto _out;}
410
- } else {
411
- if (NIL_P(json->object_class)) {
412
- OBJ_FREEZE(last_name);
413
- rb_hash_aset(*result, last_name, v);
414
- } else {
415
- rb_funcall(*result, i_aset, 2, last_name, v);
416
- }
417
- {p = (( np))-1;}
418
-
419
- }
420
- }
421
-
422
- goto st9;
423
- st9:
424
- p+= 1;
425
- if ( p == pe )
223
+ case 8:
224
+ switch( (*p) ) {
225
+ case 13: goto st8;
226
+ case 32: goto st8;
227
+ case 34: goto tr11;
228
+ case 45: goto tr11;
229
+ case 47: goto st19;
230
+ case 73: goto tr11;
231
+ case 78: goto tr11;
232
+ case 91: goto tr11;
233
+ case 102: goto tr11;
234
+ case 110: goto tr11;
235
+ case 116: goto tr11;
236
+ case 123: goto tr11;
237
+ }
238
+ if ( (*p) > 10 ) {
239
+ if ( 48 <= (*p) && (*p) <= 57 )
240
+ goto tr11;
241
+ } else if ( (*p) >= 9 )
242
+ goto st8;
243
+ goto st0;
244
+ tr11:
245
+ #line 133 "parser.rl"
246
+ {
247
+ VALUE v = Qnil;
248
+ char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
249
+ if (np == NULL) {
250
+ p--; {p++; cs = 9; goto _out;}
251
+ } else {
252
+ if (NIL_P(json->object_class)) {
253
+ OBJ_FREEZE(last_name);
254
+ rb_hash_aset(*result, last_name, v);
255
+ } else {
256
+ rb_funcall(*result, i_aset, 2, last_name, v);
257
+ }
258
+ {p = (( np))-1;}
259
+ }
260
+ }
261
+ goto st9;
262
+ st9:
263
+ if ( ++p == pe )
426
264
  goto _test_eof9;
427
- st_case_9:
428
- switch( ( (*( p))) ) {
429
- case 13: {
430
- goto st9;
431
- }
432
- case 32: {
433
- goto st9;
434
- }
435
- case 44: {
436
- goto st10;
437
- }
438
- case 47: {
439
- goto st15;
440
- }
441
- case 125: {
442
- goto ctr4;
443
- }
444
- }
445
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
446
- goto st9;
447
- }
448
- {
449
- goto st0;
450
- }
451
- st10:
452
- p+= 1;
453
- if ( p == pe )
265
+ case 9:
266
+ #line 267 "parser.c"
267
+ switch( (*p) ) {
268
+ case 13: goto st9;
269
+ case 32: goto st9;
270
+ case 44: goto st10;
271
+ case 47: goto st15;
272
+ case 125: goto tr4;
273
+ }
274
+ if ( 9 <= (*p) && (*p) <= 10 )
275
+ goto st9;
276
+ goto st0;
277
+ st10:
278
+ if ( ++p == pe )
454
279
  goto _test_eof10;
455
- st_case_10:
456
- switch( ( (*( p))) ) {
457
- case 13: {
458
- goto st10;
459
- }
460
- case 32: {
461
- goto st10;
462
- }
463
- case 34: {
464
- goto ctr2;
465
- }
466
- case 47: {
467
- goto st11;
468
- }
469
- }
470
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
471
- goto st10;
472
- }
473
- {
474
- goto st0;
475
- }
476
- st11:
477
- p+= 1;
478
- if ( p == pe )
280
+ case 10:
281
+ switch( (*p) ) {
282
+ case 13: goto st10;
283
+ case 32: goto st10;
284
+ case 34: goto tr2;
285
+ case 47: goto st11;
286
+ }
287
+ if ( 9 <= (*p) && (*p) <= 10 )
288
+ goto st10;
289
+ goto st0;
290
+ st11:
291
+ if ( ++p == pe )
479
292
  goto _test_eof11;
480
- st_case_11:
481
- switch( ( (*( p))) ) {
482
- case 42: {
483
- goto st12;
484
- }
485
- case 47: {
486
- goto st14;
487
- }
488
- }
489
- {
490
- goto st0;
491
- }
492
- st12:
493
- p+= 1;
494
- if ( p == pe )
293
+ case 11:
294
+ switch( (*p) ) {
295
+ case 42: goto st12;
296
+ case 47: goto st14;
297
+ }
298
+ goto st0;
299
+ st12:
300
+ if ( ++p == pe )
495
301
  goto _test_eof12;
496
- st_case_12:
497
- if ( ( (*( p))) == 42 ) {
498
- goto st13;
499
- }
500
- {
501
- goto st12;
502
- }
503
- st13:
504
- p+= 1;
505
- if ( p == pe )
302
+ case 12:
303
+ if ( (*p) == 42 )
304
+ goto st13;
305
+ goto st12;
306
+ st13:
307
+ if ( ++p == pe )
506
308
  goto _test_eof13;
507
- st_case_13:
508
- switch( ( (*( p))) ) {
509
- case 42: {
510
- goto st13;
511
- }
512
- case 47: {
513
- goto st10;
514
- }
515
- }
516
- {
517
- goto st12;
518
- }
519
- st14:
520
- p+= 1;
521
- if ( p == pe )
309
+ case 13:
310
+ switch( (*p) ) {
311
+ case 42: goto st13;
312
+ case 47: goto st10;
313
+ }
314
+ goto st12;
315
+ st14:
316
+ if ( ++p == pe )
522
317
  goto _test_eof14;
523
- st_case_14:
524
- if ( ( (*( p))) == 10 ) {
525
- goto st10;
526
- }
527
- {
528
- goto st14;
529
- }
530
- st15:
531
- p+= 1;
532
- if ( p == pe )
318
+ case 14:
319
+ if ( (*p) == 10 )
320
+ goto st10;
321
+ goto st14;
322
+ st15:
323
+ if ( ++p == pe )
533
324
  goto _test_eof15;
534
- st_case_15:
535
- switch( ( (*( p))) ) {
536
- case 42: {
537
- goto st16;
538
- }
539
- case 47: {
540
- goto st18;
541
- }
542
- }
543
- {
544
- goto st0;
545
- }
546
- st16:
547
- p+= 1;
548
- if ( p == pe )
325
+ case 15:
326
+ switch( (*p) ) {
327
+ case 42: goto st16;
328
+ case 47: goto st18;
329
+ }
330
+ goto st0;
331
+ st16:
332
+ if ( ++p == pe )
549
333
  goto _test_eof16;
550
- st_case_16:
551
- if ( ( (*( p))) == 42 ) {
552
- goto st17;
553
- }
554
- {
555
- goto st16;
556
- }
557
- st17:
558
- p+= 1;
559
- if ( p == pe )
334
+ case 16:
335
+ if ( (*p) == 42 )
336
+ goto st17;
337
+ goto st16;
338
+ st17:
339
+ if ( ++p == pe )
560
340
  goto _test_eof17;
561
- st_case_17:
562
- switch( ( (*( p))) ) {
563
- case 42: {
564
- goto st17;
565
- }
566
- case 47: {
567
- goto st9;
568
- }
569
- }
570
- {
571
- goto st16;
572
- }
573
- st18:
574
- p+= 1;
575
- if ( p == pe )
341
+ case 17:
342
+ switch( (*p) ) {
343
+ case 42: goto st17;
344
+ case 47: goto st9;
345
+ }
346
+ goto st16;
347
+ st18:
348
+ if ( ++p == pe )
576
349
  goto _test_eof18;
577
- st_case_18:
578
- if ( ( (*( p))) == 10 ) {
579
- goto st9;
580
- }
581
- {
582
- goto st18;
583
- }
584
- ctr4:
585
- {
586
- #line 157 "parser.rl"
587
- {p = p - 1; } {p+= 1; cs = 27; goto _out;} }
588
-
589
- goto st27;
590
- st27:
591
- p+= 1;
592
- if ( p == pe )
350
+ case 18:
351
+ if ( (*p) == 10 )
352
+ goto st9;
353
+ goto st18;
354
+ tr4:
355
+ #line 157 "parser.rl"
356
+ { p--; {p++; cs = 27; goto _out;} }
357
+ goto st27;
358
+ st27:
359
+ if ( ++p == pe )
593
360
  goto _test_eof27;
594
- st_case_27:
595
- {
596
- goto st0;
597
- }
598
- st19:
599
- p+= 1;
600
- if ( p == pe )
361
+ case 27:
362
+ #line 363 "parser.c"
363
+ goto st0;
364
+ st19:
365
+ if ( ++p == pe )
601
366
  goto _test_eof19;
602
- st_case_19:
603
- switch( ( (*( p))) ) {
604
- case 42: {
605
- goto st20;
606
- }
607
- case 47: {
608
- goto st22;
609
- }
610
- }
611
- {
612
- goto st0;
613
- }
614
- st20:
615
- p+= 1;
616
- if ( p == pe )
367
+ case 19:
368
+ switch( (*p) ) {
369
+ case 42: goto st20;
370
+ case 47: goto st22;
371
+ }
372
+ goto st0;
373
+ st20:
374
+ if ( ++p == pe )
617
375
  goto _test_eof20;
618
- st_case_20:
619
- if ( ( (*( p))) == 42 ) {
620
- goto st21;
621
- }
622
- {
623
- goto st20;
624
- }
625
- st21:
626
- p+= 1;
627
- if ( p == pe )
376
+ case 20:
377
+ if ( (*p) == 42 )
378
+ goto st21;
379
+ goto st20;
380
+ st21:
381
+ if ( ++p == pe )
628
382
  goto _test_eof21;
629
- st_case_21:
630
- switch( ( (*( p))) ) {
631
- case 42: {
632
- goto st21;
633
- }
634
- case 47: {
635
- goto st8;
636
- }
637
- }
638
- {
639
- goto st20;
640
- }
641
- st22:
642
- p+= 1;
643
- if ( p == pe )
383
+ case 21:
384
+ switch( (*p) ) {
385
+ case 42: goto st21;
386
+ case 47: goto st8;
387
+ }
388
+ goto st20;
389
+ st22:
390
+ if ( ++p == pe )
644
391
  goto _test_eof22;
645
- st_case_22:
646
- if ( ( (*( p))) == 10 ) {
647
- goto st8;
648
- }
649
- {
650
- goto st22;
651
- }
652
- st23:
653
- p+= 1;
654
- if ( p == pe )
392
+ case 22:
393
+ if ( (*p) == 10 )
394
+ goto st8;
395
+ goto st22;
396
+ st23:
397
+ if ( ++p == pe )
655
398
  goto _test_eof23;
656
- st_case_23:
657
- switch( ( (*( p))) ) {
658
- case 42: {
659
- goto st24;
660
- }
661
- case 47: {
662
- goto st26;
663
- }
664
- }
665
- {
666
- goto st0;
667
- }
668
- st24:
669
- p+= 1;
670
- if ( p == pe )
399
+ case 23:
400
+ switch( (*p) ) {
401
+ case 42: goto st24;
402
+ case 47: goto st26;
403
+ }
404
+ goto st0;
405
+ st24:
406
+ if ( ++p == pe )
671
407
  goto _test_eof24;
672
- st_case_24:
673
- if ( ( (*( p))) == 42 ) {
674
- goto st25;
675
- }
676
- {
677
- goto st24;
678
- }
679
- st25:
680
- p+= 1;
681
- if ( p == pe )
408
+ case 24:
409
+ if ( (*p) == 42 )
410
+ goto st25;
411
+ goto st24;
412
+ st25:
413
+ if ( ++p == pe )
682
414
  goto _test_eof25;
683
- st_case_25:
684
- switch( ( (*( p))) ) {
685
- case 42: {
686
- goto st25;
687
- }
688
- case 47: {
689
- goto st2;
690
- }
691
- }
692
- {
693
- goto st24;
694
- }
695
- st26:
696
- p+= 1;
697
- if ( p == pe )
415
+ case 25:
416
+ switch( (*p) ) {
417
+ case 42: goto st25;
418
+ case 47: goto st2;
419
+ }
420
+ goto st24;
421
+ st26:
422
+ if ( ++p == pe )
698
423
  goto _test_eof26;
699
- st_case_26:
700
- if ( ( (*( p))) == 10 ) {
701
- goto st2;
702
- }
703
- {
704
- goto st26;
705
- }
706
- st_out:
707
- _test_eof2: cs = 2; goto _test_eof;
708
- _test_eof3: cs = 3; goto _test_eof;
709
- _test_eof4: cs = 4; goto _test_eof;
710
- _test_eof5: cs = 5; goto _test_eof;
711
- _test_eof6: cs = 6; goto _test_eof;
712
- _test_eof7: cs = 7; goto _test_eof;
713
- _test_eof8: cs = 8; goto _test_eof;
714
- _test_eof9: cs = 9; goto _test_eof;
715
- _test_eof10: cs = 10; goto _test_eof;
716
- _test_eof11: cs = 11; goto _test_eof;
717
- _test_eof12: cs = 12; goto _test_eof;
718
- _test_eof13: cs = 13; goto _test_eof;
719
- _test_eof14: cs = 14; goto _test_eof;
720
- _test_eof15: cs = 15; goto _test_eof;
721
- _test_eof16: cs = 16; goto _test_eof;
722
- _test_eof17: cs = 17; goto _test_eof;
723
- _test_eof18: cs = 18; goto _test_eof;
724
- _test_eof27: cs = 27; goto _test_eof;
725
- _test_eof19: cs = 19; goto _test_eof;
726
- _test_eof20: cs = 20; goto _test_eof;
727
- _test_eof21: cs = 21; goto _test_eof;
728
- _test_eof22: cs = 22; goto _test_eof;
729
- _test_eof23: cs = 23; goto _test_eof;
730
- _test_eof24: cs = 24; goto _test_eof;
731
- _test_eof25: cs = 25; goto _test_eof;
732
- _test_eof26: cs = 26; goto _test_eof;
733
-
734
- _test_eof: {}
735
- _out: {}
736
- }
737
-
738
- #line 183 "parser.rl"
739
-
740
-
741
- if (cs >= JSON_object_first_final) {
742
- if (json->create_additions) {
743
- VALUE klassname;
744
- if (NIL_P(json->object_class)) {
745
- klassname = rb_hash_aref(*result, json->create_id);
746
- } else {
747
- klassname = rb_funcall(*result, i_aref, 1, json->create_id);
748
- }
749
- if (!NIL_P(klassname)) {
750
- VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
751
- if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
752
- *result = rb_funcall(klass, i_json_create, 1, *result);
753
- }
754
- }
755
- }
756
- return p + 1;
757
- } else {
758
- return NULL;
424
+ case 26:
425
+ if ( (*p) == 10 )
426
+ goto st2;
427
+ goto st26;
428
+ }
429
+ _test_eof2: cs = 2; goto _test_eof;
430
+ _test_eof3: cs = 3; goto _test_eof;
431
+ _test_eof4: cs = 4; goto _test_eof;
432
+ _test_eof5: cs = 5; goto _test_eof;
433
+ _test_eof6: cs = 6; goto _test_eof;
434
+ _test_eof7: cs = 7; goto _test_eof;
435
+ _test_eof8: cs = 8; goto _test_eof;
436
+ _test_eof9: cs = 9; goto _test_eof;
437
+ _test_eof10: cs = 10; goto _test_eof;
438
+ _test_eof11: cs = 11; goto _test_eof;
439
+ _test_eof12: cs = 12; goto _test_eof;
440
+ _test_eof13: cs = 13; goto _test_eof;
441
+ _test_eof14: cs = 14; goto _test_eof;
442
+ _test_eof15: cs = 15; goto _test_eof;
443
+ _test_eof16: cs = 16; goto _test_eof;
444
+ _test_eof17: cs = 17; goto _test_eof;
445
+ _test_eof18: cs = 18; goto _test_eof;
446
+ _test_eof27: cs = 27; goto _test_eof;
447
+ _test_eof19: cs = 19; goto _test_eof;
448
+ _test_eof20: cs = 20; goto _test_eof;
449
+ _test_eof21: cs = 21; goto _test_eof;
450
+ _test_eof22: cs = 22; goto _test_eof;
451
+ _test_eof23: cs = 23; goto _test_eof;
452
+ _test_eof24: cs = 24; goto _test_eof;
453
+ _test_eof25: cs = 25; goto _test_eof;
454
+ _test_eof26: cs = 26; goto _test_eof;
455
+
456
+ _test_eof: {}
457
+ _out: {}
759
458
  }
459
+
460
+ #line 183 "parser.rl"
461
+
462
+ if (cs >= JSON_object_first_final) {
463
+ if (json->create_additions) {
464
+ VALUE klassname;
465
+ if (NIL_P(json->object_class)) {
466
+ klassname = rb_hash_aref(*result, json->create_id);
467
+ } else {
468
+ klassname = rb_funcall(*result, i_aref, 1, json->create_id);
469
+ }
470
+ if (!NIL_P(klassname)) {
471
+ VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
472
+ if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
473
+ *result = rb_funcall(klass, i_json_create, 1, *result);
474
+ }
475
+ }
476
+ }
477
+ return p + 1;
478
+ } else {
479
+ return NULL;
480
+ }
760
481
  }
761
482
 
762
483
 
763
484
 
485
+ #line 486 "parser.c"
764
486
  enum {JSON_value_start = 1};
765
487
  enum {JSON_value_first_final = 29};
766
488
  enum {JSON_value_error = 0};
767
489
 
768
490
  enum {JSON_value_en_main = 1};
769
491
 
770
- static const char MAYBE_UNUSED(_JSON_value_nfa_targs)[] = {
771
- 0, 0
772
- };
773
-
774
- static const char MAYBE_UNUSED(_JSON_value_nfa_offsets)[] = {
775
- 0, 0, 0, 0, 0, 0, 0, 0,
776
- 0, 0, 0, 0, 0, 0, 0, 0,
777
- 0, 0, 0, 0, 0, 0, 0, 0,
778
- 0, 0, 0, 0, 0, 0, 0
779
- };
780
-
781
- static const char MAYBE_UNUSED(_JSON_value_nfa_push_actions)[] = {
782
- 0, 0
783
- };
784
-
785
- static const char MAYBE_UNUSED(_JSON_value_nfa_pop_trans)[] = {
786
- 0, 0
787
- };
788
-
789
492
 
790
493
  #line 283 "parser.rl"
791
494
 
792
495
 
793
496
  static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
794
497
  {
795
- int cs = EVIL;
498
+ int cs = EVIL;
796
499
 
797
500
 
501
+ #line 502 "parser.c"
798
502
  {
799
- cs = (int)JSON_value_start;
503
+ cs = JSON_value_start;
800
504
  }
801
505
 
802
- #line 290 "parser.rl"
803
-
506
+ #line 290 "parser.rl"
804
507
 
508
+ #line 509 "parser.c"
805
509
  {
806
- if ( p == pe )
510
+ if ( p == pe )
807
511
  goto _test_eof;
808
- switch ( cs )
809
- {
810
- case 1:
811
- goto st_case_1;
812
- case 0:
813
- goto st_case_0;
814
- case 29:
815
- goto st_case_29;
816
- case 2:
817
- goto st_case_2;
818
- case 3:
819
- goto st_case_3;
820
- case 4:
821
- goto st_case_4;
822
- case 5:
823
- goto st_case_5;
824
- case 6:
825
- goto st_case_6;
826
- case 7:
827
- goto st_case_7;
828
- case 8:
829
- goto st_case_8;
830
- case 9:
831
- goto st_case_9;
832
- case 10:
833
- goto st_case_10;
834
- case 11:
835
- goto st_case_11;
836
- case 12:
837
- goto st_case_12;
838
- case 13:
839
- goto st_case_13;
840
- case 14:
841
- goto st_case_14;
842
- case 15:
843
- goto st_case_15;
844
- case 16:
845
- goto st_case_16;
846
- case 17:
847
- goto st_case_17;
848
- case 18:
849
- goto st_case_18;
850
- case 19:
851
- goto st_case_19;
852
- case 20:
853
- goto st_case_20;
854
- case 21:
855
- goto st_case_21;
856
- case 22:
857
- goto st_case_22;
858
- case 23:
859
- goto st_case_23;
860
- case 24:
861
- goto st_case_24;
862
- case 25:
863
- goto st_case_25;
864
- case 26:
865
- goto st_case_26;
866
- case 27:
867
- goto st_case_27;
868
- case 28:
869
- goto st_case_28;
870
- }
871
- goto st_out;
872
- st1:
873
- p+= 1;
874
- if ( p == pe )
512
+ switch ( cs )
513
+ {
514
+ st1:
515
+ if ( ++p == pe )
875
516
  goto _test_eof1;
876
- st_case_1:
877
- switch( ( (*( p))) ) {
878
- case 13: {
879
- goto st1;
880
- }
881
- case 32: {
882
- goto st1;
883
- }
884
- case 34: {
885
- goto ctr2;
886
- }
887
- case 45: {
888
- goto ctr3;
889
- }
890
- case 47: {
891
- goto st6;
892
- }
893
- case 73: {
894
- goto st10;
895
- }
896
- case 78: {
897
- goto st17;
898
- }
899
- case 91: {
900
- goto ctr7;
901
- }
902
- case 102: {
903
- goto st19;
904
- }
905
- case 110: {
906
- goto st23;
907
- }
908
- case 116: {
909
- goto st26;
910
- }
911
- case 123: {
912
- goto ctr11;
913
- }
914
- }
915
- if ( ( (*( p))) > 10 ) {
916
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
917
- goto ctr3;
918
- }
919
- } else if ( ( (*( p))) >= 9 ) {
920
- goto st1;
921
- }
922
- {
923
- goto st0;
924
- }
925
- st_case_0:
926
- st0:
927
- cs = 0;
928
- goto _out;
929
- ctr2:
930
- {
931
- #line 235 "parser.rl"
932
-
933
- char *np = JSON_parse_string(json, p, pe, result);
934
- if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
935
-
936
- }
937
-
938
- goto st29;
939
- ctr3:
940
- {
941
- #line 240 "parser.rl"
942
-
943
- char *np;
944
- if(pe > p + 8 && !strncmp(MinusInfinity, p, 9)) {
945
- if (json->allow_nan) {
946
- *result = CMinusInfinity;
947
- {p = (( p + 10))-1;}
948
-
949
- {p = p - 1; } {p+= 1; cs = 29; goto _out;}
950
- } else {
951
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
952
- }
953
- }
954
- np = JSON_parse_float(json, p, pe, result);
955
- if (np != NULL) {p = (( np))-1;}
956
-
957
- np = JSON_parse_integer(json, p, pe, result);
958
- if (np != NULL) {p = (( np))-1;}
959
-
960
- {p = p - 1; } {p+= 1; cs = 29; goto _out;}
961
- }
962
-
963
- goto st29;
964
- ctr7:
965
- {
966
- #line 258 "parser.rl"
967
-
968
- char *np;
969
- np = JSON_parse_array(json, p, pe, result, current_nesting + 1);
970
- if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
971
-
972
- }
973
-
974
- goto st29;
975
- ctr11:
976
- {
977
- #line 264 "parser.rl"
978
-
979
- char *np;
980
- np = JSON_parse_object(json, p, pe, result, current_nesting + 1);
981
- if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
982
-
983
- }
984
-
985
- goto st29;
986
- ctr25:
987
- {
988
- #line 228 "parser.rl"
989
-
990
- if (json->allow_nan) {
991
- *result = CInfinity;
992
- } else {
993
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p - 8);
994
- }
995
- }
996
-
997
- goto st29;
998
- ctr27:
999
- {
1000
- #line 221 "parser.rl"
1001
-
1002
- if (json->allow_nan) {
1003
- *result = CNaN;
1004
- } else {
1005
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p - 2);
1006
- }
1007
- }
1008
-
1009
- goto st29;
1010
- ctr31:
1011
- {
1012
- #line 215 "parser.rl"
1013
-
1014
- *result = Qfalse;
1015
- }
1016
-
1017
- goto st29;
1018
- ctr34:
1019
- {
1020
- #line 212 "parser.rl"
1021
-
1022
- *result = Qnil;
1023
- }
1024
-
1025
- goto st29;
1026
- ctr37:
1027
- {
1028
- #line 218 "parser.rl"
1029
-
1030
- *result = Qtrue;
1031
- }
1032
-
1033
- goto st29;
1034
- st29:
1035
- p+= 1;
1036
- if ( p == pe )
517
+ case 1:
518
+ switch( (*p) ) {
519
+ case 13: goto st1;
520
+ case 32: goto st1;
521
+ case 34: goto tr2;
522
+ case 45: goto tr3;
523
+ case 47: goto st6;
524
+ case 73: goto st10;
525
+ case 78: goto st17;
526
+ case 91: goto tr7;
527
+ case 102: goto st19;
528
+ case 110: goto st23;
529
+ case 116: goto st26;
530
+ case 123: goto tr11;
531
+ }
532
+ if ( (*p) > 10 ) {
533
+ if ( 48 <= (*p) && (*p) <= 57 )
534
+ goto tr3;
535
+ } else if ( (*p) >= 9 )
536
+ goto st1;
537
+ goto st0;
538
+ st0:
539
+ cs = 0;
540
+ goto _out;
541
+ tr2:
542
+ #line 235 "parser.rl"
543
+ {
544
+ char *np = JSON_parse_string(json, p, pe, result);
545
+ if (np == NULL) { p--; {p++; cs = 29; goto _out;} } else {p = (( np))-1;}
546
+ }
547
+ goto st29;
548
+ tr3:
549
+ #line 240 "parser.rl"
550
+ {
551
+ char *np;
552
+ if(pe > p + 8 && !strncmp(MinusInfinity, p, 9)) {
553
+ if (json->allow_nan) {
554
+ *result = CMinusInfinity;
555
+ {p = (( p + 10))-1;}
556
+ p--; {p++; cs = 29; goto _out;}
557
+ } else {
558
+ rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
559
+ }
560
+ }
561
+ np = JSON_parse_float(json, p, pe, result);
562
+ if (np != NULL) {p = (( np))-1;}
563
+ np = JSON_parse_integer(json, p, pe, result);
564
+ if (np != NULL) {p = (( np))-1;}
565
+ p--; {p++; cs = 29; goto _out;}
566
+ }
567
+ goto st29;
568
+ tr7:
569
+ #line 258 "parser.rl"
570
+ {
571
+ char *np;
572
+ np = JSON_parse_array(json, p, pe, result, current_nesting + 1);
573
+ if (np == NULL) { p--; {p++; cs = 29; goto _out;} } else {p = (( np))-1;}
574
+ }
575
+ goto st29;
576
+ tr11:
577
+ #line 264 "parser.rl"
578
+ {
579
+ char *np;
580
+ np = JSON_parse_object(json, p, pe, result, current_nesting + 1);
581
+ if (np == NULL) { p--; {p++; cs = 29; goto _out;} } else {p = (( np))-1;}
582
+ }
583
+ goto st29;
584
+ tr25:
585
+ #line 228 "parser.rl"
586
+ {
587
+ if (json->allow_nan) {
588
+ *result = CInfinity;
589
+ } else {
590
+ rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 7);
591
+ }
592
+ }
593
+ goto st29;
594
+ tr27:
595
+ #line 221 "parser.rl"
596
+ {
597
+ if (json->allow_nan) {
598
+ *result = CNaN;
599
+ } else {
600
+ rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 2);
601
+ }
602
+ }
603
+ goto st29;
604
+ tr31:
605
+ #line 215 "parser.rl"
606
+ {
607
+ *result = Qfalse;
608
+ }
609
+ goto st29;
610
+ tr34:
611
+ #line 212 "parser.rl"
612
+ {
613
+ *result = Qnil;
614
+ }
615
+ goto st29;
616
+ tr37:
617
+ #line 218 "parser.rl"
618
+ {
619
+ *result = Qtrue;
620
+ }
621
+ goto st29;
622
+ st29:
623
+ if ( ++p == pe )
1037
624
  goto _test_eof29;
1038
- st_case_29:
1039
- {
1040
- #line 270 "parser.rl"
1041
- {p = p - 1; } {p+= 1; cs = 29; goto _out;} }
1042
- switch( ( (*( p))) ) {
1043
- case 13: {
1044
- goto st29;
1045
- }
1046
- case 32: {
1047
- goto st29;
1048
- }
1049
- case 47: {
1050
- goto st2;
1051
- }
1052
- }
1053
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
1054
- goto st29;
1055
- }
1056
- {
1057
- goto st0;
1058
- }
1059
- st2:
1060
- p+= 1;
1061
- if ( p == pe )
625
+ case 29:
626
+ #line 270 "parser.rl"
627
+ { p--; {p++; cs = 29; goto _out;} }
628
+ #line 629 "parser.c"
629
+ switch( (*p) ) {
630
+ case 13: goto st29;
631
+ case 32: goto st29;
632
+ case 47: goto st2;
633
+ }
634
+ if ( 9 <= (*p) && (*p) <= 10 )
635
+ goto st29;
636
+ goto st0;
637
+ st2:
638
+ if ( ++p == pe )
1062
639
  goto _test_eof2;
1063
- st_case_2:
1064
- switch( ( (*( p))) ) {
1065
- case 42: {
1066
- goto st3;
1067
- }
1068
- case 47: {
1069
- goto st5;
1070
- }
1071
- }
1072
- {
1073
- goto st0;
1074
- }
1075
- st3:
1076
- p+= 1;
1077
- if ( p == pe )
640
+ case 2:
641
+ switch( (*p) ) {
642
+ case 42: goto st3;
643
+ case 47: goto st5;
644
+ }
645
+ goto st0;
646
+ st3:
647
+ if ( ++p == pe )
1078
648
  goto _test_eof3;
1079
- st_case_3:
1080
- if ( ( (*( p))) == 42 ) {
1081
- goto st4;
1082
- }
1083
- {
1084
- goto st3;
1085
- }
1086
- st4:
1087
- p+= 1;
1088
- if ( p == pe )
649
+ case 3:
650
+ if ( (*p) == 42 )
651
+ goto st4;
652
+ goto st3;
653
+ st4:
654
+ if ( ++p == pe )
1089
655
  goto _test_eof4;
1090
- st_case_4:
1091
- switch( ( (*( p))) ) {
1092
- case 42: {
1093
- goto st4;
1094
- }
1095
- case 47: {
1096
- goto st29;
1097
- }
1098
- }
1099
- {
1100
- goto st3;
1101
- }
1102
- st5:
1103
- p+= 1;
1104
- if ( p == pe )
656
+ case 4:
657
+ switch( (*p) ) {
658
+ case 42: goto st4;
659
+ case 47: goto st29;
660
+ }
661
+ goto st3;
662
+ st5:
663
+ if ( ++p == pe )
1105
664
  goto _test_eof5;
1106
- st_case_5:
1107
- if ( ( (*( p))) == 10 ) {
1108
- goto st29;
1109
- }
1110
- {
1111
- goto st5;
1112
- }
1113
- st6:
1114
- p+= 1;
1115
- if ( p == pe )
665
+ case 5:
666
+ if ( (*p) == 10 )
667
+ goto st29;
668
+ goto st5;
669
+ st6:
670
+ if ( ++p == pe )
1116
671
  goto _test_eof6;
1117
- st_case_6:
1118
- switch( ( (*( p))) ) {
1119
- case 42: {
1120
- goto st7;
1121
- }
1122
- case 47: {
1123
- goto st9;
1124
- }
1125
- }
1126
- {
1127
- goto st0;
1128
- }
1129
- st7:
1130
- p+= 1;
1131
- if ( p == pe )
672
+ case 6:
673
+ switch( (*p) ) {
674
+ case 42: goto st7;
675
+ case 47: goto st9;
676
+ }
677
+ goto st0;
678
+ st7:
679
+ if ( ++p == pe )
1132
680
  goto _test_eof7;
1133
- st_case_7:
1134
- if ( ( (*( p))) == 42 ) {
1135
- goto st8;
1136
- }
1137
- {
1138
- goto st7;
1139
- }
1140
- st8:
1141
- p+= 1;
1142
- if ( p == pe )
681
+ case 7:
682
+ if ( (*p) == 42 )
683
+ goto st8;
684
+ goto st7;
685
+ st8:
686
+ if ( ++p == pe )
1143
687
  goto _test_eof8;
1144
- st_case_8:
1145
- switch( ( (*( p))) ) {
1146
- case 42: {
1147
- goto st8;
1148
- }
1149
- case 47: {
1150
- goto st1;
1151
- }
1152
- }
1153
- {
1154
- goto st7;
1155
- }
1156
- st9:
1157
- p+= 1;
1158
- if ( p == pe )
688
+ case 8:
689
+ switch( (*p) ) {
690
+ case 42: goto st8;
691
+ case 47: goto st1;
692
+ }
693
+ goto st7;
694
+ st9:
695
+ if ( ++p == pe )
1159
696
  goto _test_eof9;
1160
- st_case_9:
1161
- if ( ( (*( p))) == 10 ) {
1162
- goto st1;
1163
- }
1164
- {
1165
- goto st9;
1166
- }
1167
- st10:
1168
- p+= 1;
1169
- if ( p == pe )
697
+ case 9:
698
+ if ( (*p) == 10 )
699
+ goto st1;
700
+ goto st9;
701
+ st10:
702
+ if ( ++p == pe )
1170
703
  goto _test_eof10;
1171
- st_case_10:
1172
- if ( ( (*( p))) == 110 ) {
1173
- goto st11;
1174
- }
1175
- {
1176
- goto st0;
1177
- }
1178
- st11:
1179
- p+= 1;
1180
- if ( p == pe )
704
+ case 10:
705
+ if ( (*p) == 110 )
706
+ goto st11;
707
+ goto st0;
708
+ st11:
709
+ if ( ++p == pe )
1181
710
  goto _test_eof11;
1182
- st_case_11:
1183
- if ( ( (*( p))) == 102 ) {
1184
- goto st12;
1185
- }
1186
- {
1187
- goto st0;
1188
- }
1189
- st12:
1190
- p+= 1;
1191
- if ( p == pe )
711
+ case 11:
712
+ if ( (*p) == 102 )
713
+ goto st12;
714
+ goto st0;
715
+ st12:
716
+ if ( ++p == pe )
1192
717
  goto _test_eof12;
1193
- st_case_12:
1194
- if ( ( (*( p))) == 105 ) {
1195
- goto st13;
1196
- }
1197
- {
1198
- goto st0;
1199
- }
1200
- st13:
1201
- p+= 1;
1202
- if ( p == pe )
718
+ case 12:
719
+ if ( (*p) == 105 )
720
+ goto st13;
721
+ goto st0;
722
+ st13:
723
+ if ( ++p == pe )
1203
724
  goto _test_eof13;
1204
- st_case_13:
1205
- if ( ( (*( p))) == 110 ) {
1206
- goto st14;
1207
- }
1208
- {
1209
- goto st0;
1210
- }
1211
- st14:
1212
- p+= 1;
1213
- if ( p == pe )
725
+ case 13:
726
+ if ( (*p) == 110 )
727
+ goto st14;
728
+ goto st0;
729
+ st14:
730
+ if ( ++p == pe )
1214
731
  goto _test_eof14;
1215
- st_case_14:
1216
- if ( ( (*( p))) == 105 ) {
1217
- goto st15;
1218
- }
1219
- {
1220
- goto st0;
1221
- }
1222
- st15:
1223
- p+= 1;
1224
- if ( p == pe )
732
+ case 14:
733
+ if ( (*p) == 105 )
734
+ goto st15;
735
+ goto st0;
736
+ st15:
737
+ if ( ++p == pe )
1225
738
  goto _test_eof15;
1226
- st_case_15:
1227
- if ( ( (*( p))) == 116 ) {
1228
- goto st16;
1229
- }
1230
- {
1231
- goto st0;
1232
- }
1233
- st16:
1234
- p+= 1;
1235
- if ( p == pe )
739
+ case 15:
740
+ if ( (*p) == 116 )
741
+ goto st16;
742
+ goto st0;
743
+ st16:
744
+ if ( ++p == pe )
1236
745
  goto _test_eof16;
1237
- st_case_16:
1238
- if ( ( (*( p))) == 121 ) {
1239
- goto ctr25;
1240
- }
1241
- {
1242
- goto st0;
1243
- }
1244
- st17:
1245
- p+= 1;
1246
- if ( p == pe )
746
+ case 16:
747
+ if ( (*p) == 121 )
748
+ goto tr25;
749
+ goto st0;
750
+ st17:
751
+ if ( ++p == pe )
1247
752
  goto _test_eof17;
1248
- st_case_17:
1249
- if ( ( (*( p))) == 97 ) {
1250
- goto st18;
1251
- }
1252
- {
1253
- goto st0;
1254
- }
1255
- st18:
1256
- p+= 1;
1257
- if ( p == pe )
753
+ case 17:
754
+ if ( (*p) == 97 )
755
+ goto st18;
756
+ goto st0;
757
+ st18:
758
+ if ( ++p == pe )
1258
759
  goto _test_eof18;
1259
- st_case_18:
1260
- if ( ( (*( p))) == 78 ) {
1261
- goto ctr27;
1262
- }
1263
- {
1264
- goto st0;
1265
- }
1266
- st19:
1267
- p+= 1;
1268
- if ( p == pe )
760
+ case 18:
761
+ if ( (*p) == 78 )
762
+ goto tr27;
763
+ goto st0;
764
+ st19:
765
+ if ( ++p == pe )
1269
766
  goto _test_eof19;
1270
- st_case_19:
1271
- if ( ( (*( p))) == 97 ) {
1272
- goto st20;
1273
- }
1274
- {
1275
- goto st0;
1276
- }
1277
- st20:
1278
- p+= 1;
1279
- if ( p == pe )
767
+ case 19:
768
+ if ( (*p) == 97 )
769
+ goto st20;
770
+ goto st0;
771
+ st20:
772
+ if ( ++p == pe )
1280
773
  goto _test_eof20;
1281
- st_case_20:
1282
- if ( ( (*( p))) == 108 ) {
1283
- goto st21;
1284
- }
1285
- {
1286
- goto st0;
1287
- }
1288
- st21:
1289
- p+= 1;
1290
- if ( p == pe )
774
+ case 20:
775
+ if ( (*p) == 108 )
776
+ goto st21;
777
+ goto st0;
778
+ st21:
779
+ if ( ++p == pe )
1291
780
  goto _test_eof21;
1292
- st_case_21:
1293
- if ( ( (*( p))) == 115 ) {
1294
- goto st22;
1295
- }
1296
- {
1297
- goto st0;
1298
- }
1299
- st22:
1300
- p+= 1;
1301
- if ( p == pe )
781
+ case 21:
782
+ if ( (*p) == 115 )
783
+ goto st22;
784
+ goto st0;
785
+ st22:
786
+ if ( ++p == pe )
1302
787
  goto _test_eof22;
1303
- st_case_22:
1304
- if ( ( (*( p))) == 101 ) {
1305
- goto ctr31;
1306
- }
1307
- {
1308
- goto st0;
1309
- }
1310
- st23:
1311
- p+= 1;
1312
- if ( p == pe )
788
+ case 22:
789
+ if ( (*p) == 101 )
790
+ goto tr31;
791
+ goto st0;
792
+ st23:
793
+ if ( ++p == pe )
1313
794
  goto _test_eof23;
1314
- st_case_23:
1315
- if ( ( (*( p))) == 117 ) {
1316
- goto st24;
1317
- }
1318
- {
1319
- goto st0;
1320
- }
1321
- st24:
1322
- p+= 1;
1323
- if ( p == pe )
795
+ case 23:
796
+ if ( (*p) == 117 )
797
+ goto st24;
798
+ goto st0;
799
+ st24:
800
+ if ( ++p == pe )
1324
801
  goto _test_eof24;
1325
- st_case_24:
1326
- if ( ( (*( p))) == 108 ) {
1327
- goto st25;
1328
- }
1329
- {
1330
- goto st0;
1331
- }
1332
- st25:
1333
- p+= 1;
1334
- if ( p == pe )
802
+ case 24:
803
+ if ( (*p) == 108 )
804
+ goto st25;
805
+ goto st0;
806
+ st25:
807
+ if ( ++p == pe )
1335
808
  goto _test_eof25;
1336
- st_case_25:
1337
- if ( ( (*( p))) == 108 ) {
1338
- goto ctr34;
1339
- }
1340
- {
1341
- goto st0;
1342
- }
1343
- st26:
1344
- p+= 1;
1345
- if ( p == pe )
809
+ case 25:
810
+ if ( (*p) == 108 )
811
+ goto tr34;
812
+ goto st0;
813
+ st26:
814
+ if ( ++p == pe )
1346
815
  goto _test_eof26;
1347
- st_case_26:
1348
- if ( ( (*( p))) == 114 ) {
1349
- goto st27;
1350
- }
1351
- {
1352
- goto st0;
1353
- }
1354
- st27:
1355
- p+= 1;
1356
- if ( p == pe )
816
+ case 26:
817
+ if ( (*p) == 114 )
818
+ goto st27;
819
+ goto st0;
820
+ st27:
821
+ if ( ++p == pe )
1357
822
  goto _test_eof27;
1358
- st_case_27:
1359
- if ( ( (*( p))) == 117 ) {
1360
- goto st28;
1361
- }
1362
- {
1363
- goto st0;
1364
- }
1365
- st28:
1366
- p+= 1;
1367
- if ( p == pe )
823
+ case 27:
824
+ if ( (*p) == 117 )
825
+ goto st28;
826
+ goto st0;
827
+ st28:
828
+ if ( ++p == pe )
1368
829
  goto _test_eof28;
1369
- st_case_28:
1370
- if ( ( (*( p))) == 101 ) {
1371
- goto ctr37;
1372
- }
1373
- {
1374
- goto st0;
1375
- }
1376
- st_out:
1377
- _test_eof1: cs = 1; goto _test_eof;
1378
- _test_eof29: cs = 29; goto _test_eof;
1379
- _test_eof2: cs = 2; goto _test_eof;
1380
- _test_eof3: cs = 3; goto _test_eof;
1381
- _test_eof4: cs = 4; goto _test_eof;
1382
- _test_eof5: cs = 5; goto _test_eof;
1383
- _test_eof6: cs = 6; goto _test_eof;
1384
- _test_eof7: cs = 7; goto _test_eof;
1385
- _test_eof8: cs = 8; goto _test_eof;
1386
- _test_eof9: cs = 9; goto _test_eof;
1387
- _test_eof10: cs = 10; goto _test_eof;
1388
- _test_eof11: cs = 11; goto _test_eof;
1389
- _test_eof12: cs = 12; goto _test_eof;
1390
- _test_eof13: cs = 13; goto _test_eof;
1391
- _test_eof14: cs = 14; goto _test_eof;
1392
- _test_eof15: cs = 15; goto _test_eof;
1393
- _test_eof16: cs = 16; goto _test_eof;
1394
- _test_eof17: cs = 17; goto _test_eof;
1395
- _test_eof18: cs = 18; goto _test_eof;
1396
- _test_eof19: cs = 19; goto _test_eof;
1397
- _test_eof20: cs = 20; goto _test_eof;
1398
- _test_eof21: cs = 21; goto _test_eof;
1399
- _test_eof22: cs = 22; goto _test_eof;
1400
- _test_eof23: cs = 23; goto _test_eof;
1401
- _test_eof24: cs = 24; goto _test_eof;
1402
- _test_eof25: cs = 25; goto _test_eof;
1403
- _test_eof26: cs = 26; goto _test_eof;
1404
- _test_eof27: cs = 27; goto _test_eof;
1405
- _test_eof28: cs = 28; goto _test_eof;
1406
-
1407
- _test_eof: {}
1408
- _out: {}
1409
- }
1410
-
1411
- #line 291 "parser.rl"
1412
-
1413
-
1414
- if (json->freeze) {
1415
- OBJ_FREEZE(*result);
1416
- }
1417
-
1418
- if (cs >= JSON_value_first_final) {
1419
- return p;
1420
- } else {
1421
- return NULL;
830
+ case 28:
831
+ if ( (*p) == 101 )
832
+ goto tr37;
833
+ goto st0;
834
+ }
835
+ _test_eof1: cs = 1; goto _test_eof;
836
+ _test_eof29: cs = 29; goto _test_eof;
837
+ _test_eof2: cs = 2; goto _test_eof;
838
+ _test_eof3: cs = 3; goto _test_eof;
839
+ _test_eof4: cs = 4; goto _test_eof;
840
+ _test_eof5: cs = 5; goto _test_eof;
841
+ _test_eof6: cs = 6; goto _test_eof;
842
+ _test_eof7: cs = 7; goto _test_eof;
843
+ _test_eof8: cs = 8; goto _test_eof;
844
+ _test_eof9: cs = 9; goto _test_eof;
845
+ _test_eof10: cs = 10; goto _test_eof;
846
+ _test_eof11: cs = 11; goto _test_eof;
847
+ _test_eof12: cs = 12; goto _test_eof;
848
+ _test_eof13: cs = 13; goto _test_eof;
849
+ _test_eof14: cs = 14; goto _test_eof;
850
+ _test_eof15: cs = 15; goto _test_eof;
851
+ _test_eof16: cs = 16; goto _test_eof;
852
+ _test_eof17: cs = 17; goto _test_eof;
853
+ _test_eof18: cs = 18; goto _test_eof;
854
+ _test_eof19: cs = 19; goto _test_eof;
855
+ _test_eof20: cs = 20; goto _test_eof;
856
+ _test_eof21: cs = 21; goto _test_eof;
857
+ _test_eof22: cs = 22; goto _test_eof;
858
+ _test_eof23: cs = 23; goto _test_eof;
859
+ _test_eof24: cs = 24; goto _test_eof;
860
+ _test_eof25: cs = 25; goto _test_eof;
861
+ _test_eof26: cs = 26; goto _test_eof;
862
+ _test_eof27: cs = 27; goto _test_eof;
863
+ _test_eof28: cs = 28; goto _test_eof;
864
+
865
+ _test_eof: {}
866
+ _out: {}
1422
867
  }
868
+
869
+ #line 291 "parser.rl"
870
+
871
+ if (json->freeze) {
872
+ OBJ_FREEZE(*result);
873
+ }
874
+
875
+ if (cs >= JSON_value_first_final) {
876
+ return p;
877
+ } else {
878
+ return NULL;
879
+ }
1423
880
  }
1424
881
 
1425
882
 
883
+ #line 884 "parser.c"
1426
884
  enum {JSON_integer_start = 1};
1427
885
  enum {JSON_integer_first_final = 3};
1428
886
  enum {JSON_integer_error = 0};
1429
887
 
1430
888
  enum {JSON_integer_en_main = 1};
1431
889
 
1432
- static const char MAYBE_UNUSED(_JSON_integer_nfa_targs)[] = {
1433
- 0, 0
1434
- };
1435
-
1436
- static const char MAYBE_UNUSED(_JSON_integer_nfa_offsets)[] = {
1437
- 0, 0, 0, 0, 0, 0, 0
1438
- };
1439
-
1440
- static const char MAYBE_UNUSED(_JSON_integer_nfa_push_actions)[] = {
1441
- 0, 0
1442
- };
1443
-
1444
- static const char MAYBE_UNUSED(_JSON_integer_nfa_pop_trans)[] = {
1445
- 0, 0
1446
- };
1447
-
1448
890
 
1449
891
  #line 311 "parser.rl"
1450
892
 
1451
893
 
1452
894
  static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
1453
895
  {
1454
- int cs = EVIL;
896
+ int cs = EVIL;
1455
897
 
1456
898
 
899
+ #line 900 "parser.c"
1457
900
  {
1458
- cs = (int)JSON_integer_start;
901
+ cs = JSON_integer_start;
1459
902
  }
1460
903
 
1461
- #line 318 "parser.rl"
1462
-
1463
- json->memo = p;
904
+ #line 318 "parser.rl"
905
+ json->memo = p;
1464
906
 
907
+ #line 908 "parser.c"
1465
908
  {
1466
- if ( p == pe )
909
+ if ( p == pe )
1467
910
  goto _test_eof;
1468
- switch ( cs )
1469
- {
1470
- case 1:
1471
- goto st_case_1;
1472
- case 0:
1473
- goto st_case_0;
1474
- case 2:
1475
- goto st_case_2;
1476
- case 3:
1477
- goto st_case_3;
1478
- case 4:
1479
- goto st_case_4;
1480
- case 5:
1481
- goto st_case_5;
1482
- }
1483
- goto st_out;
1484
- st_case_1:
1485
- switch( ( (*( p))) ) {
1486
- case 45: {
1487
- goto st2;
1488
- }
1489
- case 48: {
1490
- goto st3;
1491
- }
1492
- }
1493
- if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1494
- goto st5;
1495
- }
1496
- {
1497
- goto st0;
1498
- }
1499
- st_case_0:
1500
- st0:
1501
- cs = 0;
1502
- goto _out;
1503
- st2:
1504
- p+= 1;
1505
- if ( p == pe )
911
+ switch ( cs )
912
+ {
913
+ case 1:
914
+ switch( (*p) ) {
915
+ case 45: goto st2;
916
+ case 48: goto st3;
917
+ }
918
+ if ( 49 <= (*p) && (*p) <= 57 )
919
+ goto st5;
920
+ goto st0;
921
+ st0:
922
+ cs = 0;
923
+ goto _out;
924
+ st2:
925
+ if ( ++p == pe )
1506
926
  goto _test_eof2;
1507
- st_case_2:
1508
- if ( ( (*( p))) == 48 ) {
1509
- goto st3;
1510
- }
1511
- if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1512
- goto st5;
1513
- }
1514
- {
1515
- goto st0;
1516
- }
1517
- st3:
1518
- p+= 1;
1519
- if ( p == pe )
927
+ case 2:
928
+ if ( (*p) == 48 )
929
+ goto st3;
930
+ if ( 49 <= (*p) && (*p) <= 57 )
931
+ goto st5;
932
+ goto st0;
933
+ st3:
934
+ if ( ++p == pe )
1520
935
  goto _test_eof3;
1521
- st_case_3:
1522
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1523
- goto st0;
1524
- }
1525
- {
1526
- goto ctr4;
1527
- }
1528
- ctr4:
1529
- {
1530
- #line 308 "parser.rl"
1531
- {p = p - 1; } {p+= 1; cs = 4; goto _out;} }
1532
-
1533
- goto st4;
1534
- st4:
1535
- p+= 1;
1536
- if ( p == pe )
936
+ case 3:
937
+ if ( 48 <= (*p) && (*p) <= 57 )
938
+ goto st0;
939
+ goto tr4;
940
+ tr4:
941
+ #line 308 "parser.rl"
942
+ { p--; {p++; cs = 4; goto _out;} }
943
+ goto st4;
944
+ st4:
945
+ if ( ++p == pe )
1537
946
  goto _test_eof4;
1538
- st_case_4:
1539
- {
1540
- goto st0;
1541
- }
1542
- st5:
1543
- p+= 1;
1544
- if ( p == pe )
947
+ case 4:
948
+ #line 949 "parser.c"
949
+ goto st0;
950
+ st5:
951
+ if ( ++p == pe )
1545
952
  goto _test_eof5;
1546
- st_case_5:
1547
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1548
- goto st5;
1549
- }
1550
- {
1551
- goto ctr4;
1552
- }
1553
- st_out:
1554
- _test_eof2: cs = 2; goto _test_eof;
1555
- _test_eof3: cs = 3; goto _test_eof;
1556
- _test_eof4: cs = 4; goto _test_eof;
1557
- _test_eof5: cs = 5; goto _test_eof;
1558
-
1559
- _test_eof: {}
1560
- _out: {}
1561
- }
1562
-
1563
- #line 320 "parser.rl"
1564
-
1565
-
1566
- if (cs >= JSON_integer_first_final) {
1567
- long len = p - json->memo;
1568
- fbuffer_clear(json->fbuffer);
1569
- fbuffer_append(json->fbuffer, json->memo, len);
1570
- fbuffer_append_char(json->fbuffer, '\0');
1571
- *result = rb_cstr2inum(FBUFFER_PTR(json->fbuffer), 10);
1572
- return p + 1;
1573
- } else {
1574
- return NULL;
953
+ case 5:
954
+ if ( 48 <= (*p) && (*p) <= 57 )
955
+ goto st5;
956
+ goto tr4;
957
+ }
958
+ _test_eof2: cs = 2; goto _test_eof;
959
+ _test_eof3: cs = 3; goto _test_eof;
960
+ _test_eof4: cs = 4; goto _test_eof;
961
+ _test_eof5: cs = 5; goto _test_eof;
962
+
963
+ _test_eof: {}
964
+ _out: {}
1575
965
  }
966
+
967
+ #line 320 "parser.rl"
968
+
969
+ if (cs >= JSON_integer_first_final) {
970
+ long len = p - json->memo;
971
+ fbuffer_clear(json->fbuffer);
972
+ fbuffer_append(json->fbuffer, json->memo, len);
973
+ fbuffer_append_char(json->fbuffer, '\0');
974
+ *result = rb_cstr2inum(FBUFFER_PTR(json->fbuffer), 10);
975
+ return p + 1;
976
+ } else {
977
+ return NULL;
978
+ }
1576
979
  }
1577
980
 
1578
981
 
982
+ #line 983 "parser.c"
1579
983
  enum {JSON_float_start = 1};
1580
984
  enum {JSON_float_first_final = 8};
1581
985
  enum {JSON_float_error = 0};
1582
986
 
1583
987
  enum {JSON_float_en_main = 1};
1584
988
 
1585
- static const char MAYBE_UNUSED(_JSON_float_nfa_targs)[] = {
1586
- 0, 0
1587
- };
1588
-
1589
- static const char MAYBE_UNUSED(_JSON_float_nfa_offsets)[] = {
1590
- 0, 0, 0, 0, 0, 0, 0, 0,
1591
- 0, 0, 0, 0
1592
- };
1593
-
1594
- static const char MAYBE_UNUSED(_JSON_float_nfa_push_actions)[] = {
1595
- 0, 0
1596
- };
1597
-
1598
- static const char MAYBE_UNUSED(_JSON_float_nfa_pop_trans)[] = {
1599
- 0, 0
1600
- };
1601
-
1602
989
 
1603
990
  #line 345 "parser.rl"
1604
991
 
1605
992
 
1606
993
  static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
1607
994
  {
1608
- int cs = EVIL;
995
+ int cs = EVIL;
1609
996
 
1610
997
 
998
+ #line 999 "parser.c"
1611
999
  {
1612
- cs = (int)JSON_float_start;
1000
+ cs = JSON_float_start;
1613
1001
  }
1614
1002
 
1615
- #line 352 "parser.rl"
1616
-
1617
- json->memo = p;
1003
+ #line 352 "parser.rl"
1004
+ json->memo = p;
1618
1005
 
1006
+ #line 1007 "parser.c"
1619
1007
  {
1620
- if ( p == pe )
1008
+ if ( p == pe )
1621
1009
  goto _test_eof;
1622
- switch ( cs )
1623
- {
1624
- case 1:
1625
- goto st_case_1;
1626
- case 0:
1627
- goto st_case_0;
1628
- case 2:
1629
- goto st_case_2;
1630
- case 3:
1631
- goto st_case_3;
1632
- case 4:
1633
- goto st_case_4;
1634
- case 8:
1635
- goto st_case_8;
1636
- case 9:
1637
- goto st_case_9;
1638
- case 5:
1639
- goto st_case_5;
1640
- case 6:
1641
- goto st_case_6;
1642
- case 10:
1643
- goto st_case_10;
1644
- case 7:
1645
- goto st_case_7;
1646
- }
1647
- goto st_out;
1648
- st_case_1:
1649
- switch( ( (*( p))) ) {
1650
- case 45: {
1651
- goto st2;
1652
- }
1653
- case 48: {
1654
- goto st3;
1655
- }
1656
- }
1657
- if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1658
- goto st7;
1659
- }
1660
- {
1661
- goto st0;
1662
- }
1663
- st_case_0:
1664
- st0:
1665
- cs = 0;
1666
- goto _out;
1667
- st2:
1668
- p+= 1;
1669
- if ( p == pe )
1010
+ switch ( cs )
1011
+ {
1012
+ case 1:
1013
+ switch( (*p) ) {
1014
+ case 45: goto st2;
1015
+ case 48: goto st3;
1016
+ }
1017
+ if ( 49 <= (*p) && (*p) <= 57 )
1018
+ goto st7;
1019
+ goto st0;
1020
+ st0:
1021
+ cs = 0;
1022
+ goto _out;
1023
+ st2:
1024
+ if ( ++p == pe )
1670
1025
  goto _test_eof2;
1671
- st_case_2:
1672
- if ( ( (*( p))) == 48 ) {
1673
- goto st3;
1674
- }
1675
- if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1676
- goto st7;
1677
- }
1678
- {
1679
- goto st0;
1680
- }
1681
- st3:
1682
- p+= 1;
1683
- if ( p == pe )
1026
+ case 2:
1027
+ if ( (*p) == 48 )
1028
+ goto st3;
1029
+ if ( 49 <= (*p) && (*p) <= 57 )
1030
+ goto st7;
1031
+ goto st0;
1032
+ st3:
1033
+ if ( ++p == pe )
1684
1034
  goto _test_eof3;
1685
- st_case_3:
1686
- switch( ( (*( p))) ) {
1687
- case 46: {
1688
- goto st4;
1689
- }
1690
- case 69: {
1691
- goto st5;
1692
- }
1693
- case 101: {
1694
- goto st5;
1695
- }
1696
- }
1697
- {
1698
- goto st0;
1699
- }
1700
- st4:
1701
- p+= 1;
1702
- if ( p == pe )
1035
+ case 3:
1036
+ switch( (*p) ) {
1037
+ case 46: goto st4;
1038
+ case 69: goto st5;
1039
+ case 101: goto st5;
1040
+ }
1041
+ goto st0;
1042
+ st4:
1043
+ if ( ++p == pe )
1703
1044
  goto _test_eof4;
1704
- st_case_4:
1705
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1706
- goto st8;
1707
- }
1708
- {
1709
- goto st0;
1710
- }
1711
- st8:
1712
- p+= 1;
1713
- if ( p == pe )
1045
+ case 4:
1046
+ if ( 48 <= (*p) && (*p) <= 57 )
1047
+ goto st8;
1048
+ goto st0;
1049
+ st8:
1050
+ if ( ++p == pe )
1714
1051
  goto _test_eof8;
1715
- st_case_8:
1716
- switch( ( (*( p))) ) {
1717
- case 69: {
1718
- goto st5;
1719
- }
1720
- case 101: {
1721
- goto st5;
1722
- }
1723
- }
1724
- if ( ( (*( p))) > 46 ) {
1725
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1726
- goto st8;
1727
- }
1728
- } else if ( ( (*( p))) >= 45 ) {
1729
- goto st0;
1730
- }
1731
- {
1732
- goto ctr9;
1733
- }
1734
- ctr9:
1735
- {
1736
- #line 339 "parser.rl"
1737
- {p = p - 1; } {p+= 1; cs = 9; goto _out;} }
1738
-
1739
- goto st9;
1740
- st9:
1741
- p+= 1;
1742
- if ( p == pe )
1052
+ case 8:
1053
+ switch( (*p) ) {
1054
+ case 69: goto st5;
1055
+ case 101: goto st5;
1056
+ }
1057
+ if ( (*p) > 46 ) {
1058
+ if ( 48 <= (*p) && (*p) <= 57 )
1059
+ goto st8;
1060
+ } else if ( (*p) >= 45 )
1061
+ goto st0;
1062
+ goto tr9;
1063
+ tr9:
1064
+ #line 339 "parser.rl"
1065
+ { p--; {p++; cs = 9; goto _out;} }
1066
+ goto st9;
1067
+ st9:
1068
+ if ( ++p == pe )
1743
1069
  goto _test_eof9;
1744
- st_case_9:
1745
- {
1746
- goto st0;
1747
- }
1748
- st5:
1749
- p+= 1;
1750
- if ( p == pe )
1070
+ case 9:
1071
+ #line 1072 "parser.c"
1072
+ goto st0;
1073
+ st5:
1074
+ if ( ++p == pe )
1751
1075
  goto _test_eof5;
1752
- st_case_5:
1753
- switch( ( (*( p))) ) {
1754
- case 43: {
1755
- goto st6;
1756
- }
1757
- case 45: {
1758
- goto st6;
1759
- }
1760
- }
1761
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1762
- goto st10;
1763
- }
1764
- {
1765
- goto st0;
1766
- }
1767
- st6:
1768
- p+= 1;
1769
- if ( p == pe )
1076
+ case 5:
1077
+ switch( (*p) ) {
1078
+ case 43: goto st6;
1079
+ case 45: goto st6;
1080
+ }
1081
+ if ( 48 <= (*p) && (*p) <= 57 )
1082
+ goto st10;
1083
+ goto st0;
1084
+ st6:
1085
+ if ( ++p == pe )
1770
1086
  goto _test_eof6;
1771
- st_case_6:
1772
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1773
- goto st10;
1774
- }
1775
- {
1776
- goto st0;
1777
- }
1778
- st10:
1779
- p+= 1;
1780
- if ( p == pe )
1087
+ case 6:
1088
+ if ( 48 <= (*p) && (*p) <= 57 )
1089
+ goto st10;
1090
+ goto st0;
1091
+ st10:
1092
+ if ( ++p == pe )
1781
1093
  goto _test_eof10;
1782
- st_case_10:
1783
- switch( ( (*( p))) ) {
1784
- case 69: {
1785
- goto st0;
1786
- }
1787
- case 101: {
1788
- goto st0;
1789
- }
1790
- }
1791
- if ( ( (*( p))) > 46 ) {
1792
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1793
- goto st10;
1794
- }
1795
- } else if ( ( (*( p))) >= 45 ) {
1796
- goto st0;
1797
- }
1798
- {
1799
- goto ctr9;
1800
- }
1801
- st7:
1802
- p+= 1;
1803
- if ( p == pe )
1094
+ case 10:
1095
+ switch( (*p) ) {
1096
+ case 69: goto st0;
1097
+ case 101: goto st0;
1098
+ }
1099
+ if ( (*p) > 46 ) {
1100
+ if ( 48 <= (*p) && (*p) <= 57 )
1101
+ goto st10;
1102
+ } else if ( (*p) >= 45 )
1103
+ goto st0;
1104
+ goto tr9;
1105
+ st7:
1106
+ if ( ++p == pe )
1804
1107
  goto _test_eof7;
1805
- st_case_7:
1806
- switch( ( (*( p))) ) {
1807
- case 46: {
1808
- goto st4;
1809
- }
1810
- case 69: {
1811
- goto st5;
1812
- }
1813
- case 101: {
1814
- goto st5;
1815
- }
1816
- }
1817
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1818
- goto st7;
1819
- }
1820
- {
1821
- goto st0;
1822
- }
1823
- st_out:
1824
- _test_eof2: cs = 2; goto _test_eof;
1825
- _test_eof3: cs = 3; goto _test_eof;
1826
- _test_eof4: cs = 4; goto _test_eof;
1827
- _test_eof8: cs = 8; goto _test_eof;
1828
- _test_eof9: cs = 9; goto _test_eof;
1829
- _test_eof5: cs = 5; goto _test_eof;
1830
- _test_eof6: cs = 6; goto _test_eof;
1831
- _test_eof10: cs = 10; goto _test_eof;
1832
- _test_eof7: cs = 7; goto _test_eof;
1833
-
1834
- _test_eof: {}
1835
- _out: {}
1836
- }
1837
-
1838
- #line 354 "parser.rl"
1839
-
1840
-
1841
- if (cs >= JSON_float_first_final) {
1842
- VALUE mod = Qnil;
1843
- ID method_id = 0;
1844
- if (rb_respond_to(json->decimal_class, i_try_convert)) {
1845
- mod = json->decimal_class;
1846
- method_id = i_try_convert;
1847
- } else if (rb_respond_to(json->decimal_class, i_new)) {
1848
- mod = json->decimal_class;
1849
- method_id = i_new;
1850
- } else if (RB_TYPE_P(json->decimal_class, T_CLASS)) {
1851
- VALUE name = rb_class_name(json->decimal_class);
1852
- const char *name_cstr = RSTRING_PTR(name);
1853
- const char *last_colon = strrchr(name_cstr, ':');
1854
- if (last_colon) {
1855
- const char *mod_path_end = last_colon - 1;
1856
- VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
1857
- mod = rb_path_to_class(mod_path);
1858
-
1859
- const char *method_name_beg = last_colon + 1;
1860
- long before_len = method_name_beg - name_cstr;
1861
- long len = RSTRING_LEN(name) - before_len;
1862
- VALUE method_name = rb_str_substr(name, before_len, len);
1863
- method_id = SYM2ID(rb_str_intern(method_name));
1864
- } else {
1865
- mod = rb_mKernel;
1866
- method_id = SYM2ID(rb_str_intern(name));
1867
- }
1868
- }
1869
-
1870
- long len = p - json->memo;
1871
- fbuffer_clear(json->fbuffer);
1872
- fbuffer_append(json->fbuffer, json->memo, len);
1873
- fbuffer_append_char(json->fbuffer, '\0');
1874
-
1875
- if (method_id) {
1876
- VALUE text = rb_str_new2(FBUFFER_PTR(json->fbuffer));
1877
- *result = rb_funcallv(mod, method_id, 1, &text);
1878
- } else {
1879
- *result = DBL2NUM(rb_cstr_to_dbl(FBUFFER_PTR(json->fbuffer), 1));
1880
- }
1881
-
1882
- return p + 1;
1883
- } else {
1884
- return NULL;
1108
+ case 7:
1109
+ switch( (*p) ) {
1110
+ case 46: goto st4;
1111
+ case 69: goto st5;
1112
+ case 101: goto st5;
1113
+ }
1114
+ if ( 48 <= (*p) && (*p) <= 57 )
1115
+ goto st7;
1116
+ goto st0;
1117
+ }
1118
+ _test_eof2: cs = 2; goto _test_eof;
1119
+ _test_eof3: cs = 3; goto _test_eof;
1120
+ _test_eof4: cs = 4; goto _test_eof;
1121
+ _test_eof8: cs = 8; goto _test_eof;
1122
+ _test_eof9: cs = 9; goto _test_eof;
1123
+ _test_eof5: cs = 5; goto _test_eof;
1124
+ _test_eof6: cs = 6; goto _test_eof;
1125
+ _test_eof10: cs = 10; goto _test_eof;
1126
+ _test_eof7: cs = 7; goto _test_eof;
1127
+
1128
+ _test_eof: {}
1129
+ _out: {}
1885
1130
  }
1131
+
1132
+ #line 354 "parser.rl"
1133
+
1134
+ if (cs >= JSON_float_first_final) {
1135
+ VALUE mod = Qnil;
1136
+ ID method_id = 0;
1137
+ if (rb_respond_to(json->decimal_class, i_try_convert)) {
1138
+ mod = json->decimal_class;
1139
+ method_id = i_try_convert;
1140
+ } else if (rb_respond_to(json->decimal_class, i_new)) {
1141
+ mod = json->decimal_class;
1142
+ method_id = i_new;
1143
+ } else if (RB_TYPE_P(json->decimal_class, T_CLASS)) {
1144
+ VALUE name = rb_class_name(json->decimal_class);
1145
+ const char *name_cstr = RSTRING_PTR(name);
1146
+ const char *last_colon = strrchr(name_cstr, ':');
1147
+ if (last_colon) {
1148
+ const char *mod_path_end = last_colon - 1;
1149
+ VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
1150
+ mod = rb_path_to_class(mod_path);
1151
+
1152
+ const char *method_name_beg = last_colon + 1;
1153
+ long before_len = method_name_beg - name_cstr;
1154
+ long len = RSTRING_LEN(name) - before_len;
1155
+ VALUE method_name = rb_str_substr(name, before_len, len);
1156
+ method_id = SYM2ID(rb_str_intern(method_name));
1157
+ } else {
1158
+ mod = rb_mKernel;
1159
+ method_id = SYM2ID(rb_str_intern(name));
1160
+ }
1161
+ }
1162
+
1163
+ long len = p - json->memo;
1164
+ fbuffer_clear(json->fbuffer);
1165
+ fbuffer_append(json->fbuffer, json->memo, len);
1166
+ fbuffer_append_char(json->fbuffer, '\0');
1167
+
1168
+ if (method_id) {
1169
+ VALUE text = rb_str_new2(FBUFFER_PTR(json->fbuffer));
1170
+ *result = rb_funcallv(mod, method_id, 1, &text);
1171
+ } else {
1172
+ *result = DBL2NUM(rb_cstr_to_dbl(FBUFFER_PTR(json->fbuffer), 1));
1173
+ }
1174
+
1175
+ return p + 1;
1176
+ } else {
1177
+ return NULL;
1178
+ }
1886
1179
  }
1887
1180
 
1888
1181
 
1889
1182
 
1183
+ #line 1184 "parser.c"
1890
1184
  enum {JSON_array_start = 1};
1891
1185
  enum {JSON_array_first_final = 17};
1892
1186
  enum {JSON_array_error = 0};
1893
1187
 
1894
1188
  enum {JSON_array_en_main = 1};
1895
1189
 
1896
- static const char MAYBE_UNUSED(_JSON_array_nfa_targs)[] = {
1897
- 0, 0
1898
- };
1899
-
1900
- static const char MAYBE_UNUSED(_JSON_array_nfa_offsets)[] = {
1901
- 0, 0, 0, 0, 0, 0, 0, 0,
1902
- 0, 0, 0, 0, 0, 0, 0, 0,
1903
- 0, 0, 0
1904
- };
1905
-
1906
- static const char MAYBE_UNUSED(_JSON_array_nfa_push_actions)[] = {
1907
- 0, 0
1908
- };
1909
-
1910
- static const char MAYBE_UNUSED(_JSON_array_nfa_pop_trans)[] = {
1911
- 0, 0
1912
- };
1913
-
1914
1190
 
1915
1191
  #line 432 "parser.rl"
1916
1192
 
1917
1193
 
1918
1194
  static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
1919
1195
  {
1920
- int cs = EVIL;
1921
- VALUE array_class = json->array_class;
1196
+ int cs = EVIL;
1197
+ VALUE array_class = json->array_class;
1922
1198
 
1923
- if (json->max_nesting && current_nesting > json->max_nesting) {
1924
- rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
1925
- }
1926
- *result = NIL_P(array_class) ? rb_ary_new() : rb_class_new_instance(0, 0, array_class);
1199
+ if (json->max_nesting && current_nesting > json->max_nesting) {
1200
+ rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
1201
+ }
1202
+ *result = NIL_P(array_class) ? rb_ary_new() : rb_class_new_instance(0, 0, array_class);
1927
1203
 
1928
1204
 
1205
+ #line 1206 "parser.c"
1929
1206
  {
1930
- cs = (int)JSON_array_start;
1207
+ cs = JSON_array_start;
1931
1208
  }
1932
1209
 
1933
- #line 445 "parser.rl"
1934
-
1210
+ #line 445 "parser.rl"
1935
1211
 
1212
+ #line 1213 "parser.c"
1936
1213
  {
1937
- if ( p == pe )
1214
+ if ( p == pe )
1938
1215
  goto _test_eof;
1939
- switch ( cs )
1940
- {
1941
- case 1:
1942
- goto st_case_1;
1943
- case 0:
1944
- goto st_case_0;
1945
- case 2:
1946
- goto st_case_2;
1947
- case 3:
1948
- goto st_case_3;
1949
- case 4:
1950
- goto st_case_4;
1951
- case 5:
1952
- goto st_case_5;
1953
- case 6:
1954
- goto st_case_6;
1955
- case 7:
1956
- goto st_case_7;
1957
- case 8:
1958
- goto st_case_8;
1959
- case 9:
1960
- goto st_case_9;
1961
- case 10:
1962
- goto st_case_10;
1963
- case 11:
1964
- goto st_case_11;
1965
- case 12:
1966
- goto st_case_12;
1967
- case 17:
1968
- goto st_case_17;
1969
- case 13:
1970
- goto st_case_13;
1971
- case 14:
1972
- goto st_case_14;
1973
- case 15:
1974
- goto st_case_15;
1975
- case 16:
1976
- goto st_case_16;
1977
- }
1978
- goto st_out;
1979
- st_case_1:
1980
- if ( ( (*( p))) == 91 ) {
1981
- goto st2;
1982
- }
1983
- {
1984
- goto st0;
1985
- }
1986
- st_case_0:
1987
- st0:
1988
- cs = 0;
1989
- goto _out;
1990
- st2:
1991
- p+= 1;
1992
- if ( p == pe )
1216
+ switch ( cs )
1217
+ {
1218
+ case 1:
1219
+ if ( (*p) == 91 )
1220
+ goto st2;
1221
+ goto st0;
1222
+ st0:
1223
+ cs = 0;
1224
+ goto _out;
1225
+ st2:
1226
+ if ( ++p == pe )
1993
1227
  goto _test_eof2;
1994
- st_case_2:
1995
- switch( ( (*( p))) ) {
1996
- case 13: {
1997
- goto st2;
1998
- }
1999
- case 32: {
2000
- goto st2;
2001
- }
2002
- case 34: {
2003
- goto ctr2;
2004
- }
2005
- case 45: {
2006
- goto ctr2;
2007
- }
2008
- case 47: {
2009
- goto st13;
2010
- }
2011
- case 73: {
2012
- goto ctr2;
2013
- }
2014
- case 78: {
2015
- goto ctr2;
2016
- }
2017
- case 91: {
2018
- goto ctr2;
2019
- }
2020
- case 93: {
2021
- goto ctr4;
2022
- }
2023
- case 102: {
2024
- goto ctr2;
2025
- }
2026
- case 110: {
2027
- goto ctr2;
2028
- }
2029
- case 116: {
2030
- goto ctr2;
2031
- }
2032
- case 123: {
2033
- goto ctr2;
2034
- }
2035
- }
2036
- if ( ( (*( p))) > 10 ) {
2037
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2038
- goto ctr2;
2039
- }
2040
- } else if ( ( (*( p))) >= 9 ) {
2041
- goto st2;
2042
- }
2043
- {
2044
- goto st0;
2045
- }
2046
- ctr2:
2047
- {
2048
- #line 409 "parser.rl"
2049
-
2050
- VALUE v = Qnil;
2051
- char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
2052
- if (np == NULL) {
2053
- {p = p - 1; } {p+= 1; cs = 3; goto _out;}
2054
- } else {
2055
- if (NIL_P(json->array_class)) {
2056
- rb_ary_push(*result, v);
2057
- } else {
2058
- rb_funcall(*result, i_leftshift, 1, v);
2059
- }
2060
- {p = (( np))-1;}
2061
-
2062
- }
2063
- }
2064
-
2065
- goto st3;
2066
- st3:
2067
- p+= 1;
2068
- if ( p == pe )
1228
+ case 2:
1229
+ switch( (*p) ) {
1230
+ case 13: goto st2;
1231
+ case 32: goto st2;
1232
+ case 34: goto tr2;
1233
+ case 45: goto tr2;
1234
+ case 47: goto st13;
1235
+ case 73: goto tr2;
1236
+ case 78: goto tr2;
1237
+ case 91: goto tr2;
1238
+ case 93: goto tr4;
1239
+ case 102: goto tr2;
1240
+ case 110: goto tr2;
1241
+ case 116: goto tr2;
1242
+ case 123: goto tr2;
1243
+ }
1244
+ if ( (*p) > 10 ) {
1245
+ if ( 48 <= (*p) && (*p) <= 57 )
1246
+ goto tr2;
1247
+ } else if ( (*p) >= 9 )
1248
+ goto st2;
1249
+ goto st0;
1250
+ tr2:
1251
+ #line 409 "parser.rl"
1252
+ {
1253
+ VALUE v = Qnil;
1254
+ char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
1255
+ if (np == NULL) {
1256
+ p--; {p++; cs = 3; goto _out;}
1257
+ } else {
1258
+ if (NIL_P(json->array_class)) {
1259
+ rb_ary_push(*result, v);
1260
+ } else {
1261
+ rb_funcall(*result, i_leftshift, 1, v);
1262
+ }
1263
+ {p = (( np))-1;}
1264
+ }
1265
+ }
1266
+ goto st3;
1267
+ st3:
1268
+ if ( ++p == pe )
2069
1269
  goto _test_eof3;
2070
- st_case_3:
2071
- switch( ( (*( p))) ) {
2072
- case 13: {
2073
- goto st3;
2074
- }
2075
- case 32: {
2076
- goto st3;
2077
- }
2078
- case 44: {
2079
- goto st4;
2080
- }
2081
- case 47: {
2082
- goto st9;
2083
- }
2084
- case 93: {
2085
- goto ctr4;
2086
- }
2087
- }
2088
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
2089
- goto st3;
2090
- }
2091
- {
2092
- goto st0;
2093
- }
2094
- st4:
2095
- p+= 1;
2096
- if ( p == pe )
1270
+ case 3:
1271
+ #line 1272 "parser.c"
1272
+ switch( (*p) ) {
1273
+ case 13: goto st3;
1274
+ case 32: goto st3;
1275
+ case 44: goto st4;
1276
+ case 47: goto st9;
1277
+ case 93: goto tr4;
1278
+ }
1279
+ if ( 9 <= (*p) && (*p) <= 10 )
1280
+ goto st3;
1281
+ goto st0;
1282
+ st4:
1283
+ if ( ++p == pe )
2097
1284
  goto _test_eof4;
2098
- st_case_4:
2099
- switch( ( (*( p))) ) {
2100
- case 13: {
2101
- goto st4;
2102
- }
2103
- case 32: {
2104
- goto st4;
2105
- }
2106
- case 34: {
2107
- goto ctr2;
2108
- }
2109
- case 45: {
2110
- goto ctr2;
2111
- }
2112
- case 47: {
2113
- goto st5;
2114
- }
2115
- case 73: {
2116
- goto ctr2;
2117
- }
2118
- case 78: {
2119
- goto ctr2;
2120
- }
2121
- case 91: {
2122
- goto ctr2;
2123
- }
2124
- case 102: {
2125
- goto ctr2;
2126
- }
2127
- case 110: {
2128
- goto ctr2;
2129
- }
2130
- case 116: {
2131
- goto ctr2;
2132
- }
2133
- case 123: {
2134
- goto ctr2;
2135
- }
2136
- }
2137
- if ( ( (*( p))) > 10 ) {
2138
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2139
- goto ctr2;
2140
- }
2141
- } else if ( ( (*( p))) >= 9 ) {
2142
- goto st4;
2143
- }
2144
- {
2145
- goto st0;
2146
- }
2147
- st5:
2148
- p+= 1;
2149
- if ( p == pe )
1285
+ case 4:
1286
+ switch( (*p) ) {
1287
+ case 13: goto st4;
1288
+ case 32: goto st4;
1289
+ case 34: goto tr2;
1290
+ case 45: goto tr2;
1291
+ case 47: goto st5;
1292
+ case 73: goto tr2;
1293
+ case 78: goto tr2;
1294
+ case 91: goto tr2;
1295
+ case 102: goto tr2;
1296
+ case 110: goto tr2;
1297
+ case 116: goto tr2;
1298
+ case 123: goto tr2;
1299
+ }
1300
+ if ( (*p) > 10 ) {
1301
+ if ( 48 <= (*p) && (*p) <= 57 )
1302
+ goto tr2;
1303
+ } else if ( (*p) >= 9 )
1304
+ goto st4;
1305
+ goto st0;
1306
+ st5:
1307
+ if ( ++p == pe )
2150
1308
  goto _test_eof5;
2151
- st_case_5:
2152
- switch( ( (*( p))) ) {
2153
- case 42: {
2154
- goto st6;
2155
- }
2156
- case 47: {
2157
- goto st8;
2158
- }
2159
- }
2160
- {
2161
- goto st0;
2162
- }
2163
- st6:
2164
- p+= 1;
2165
- if ( p == pe )
1309
+ case 5:
1310
+ switch( (*p) ) {
1311
+ case 42: goto st6;
1312
+ case 47: goto st8;
1313
+ }
1314
+ goto st0;
1315
+ st6:
1316
+ if ( ++p == pe )
2166
1317
  goto _test_eof6;
2167
- st_case_6:
2168
- if ( ( (*( p))) == 42 ) {
2169
- goto st7;
2170
- }
2171
- {
2172
- goto st6;
2173
- }
2174
- st7:
2175
- p+= 1;
2176
- if ( p == pe )
1318
+ case 6:
1319
+ if ( (*p) == 42 )
1320
+ goto st7;
1321
+ goto st6;
1322
+ st7:
1323
+ if ( ++p == pe )
2177
1324
  goto _test_eof7;
2178
- st_case_7:
2179
- switch( ( (*( p))) ) {
2180
- case 42: {
2181
- goto st7;
2182
- }
2183
- case 47: {
2184
- goto st4;
2185
- }
2186
- }
2187
- {
2188
- goto st6;
2189
- }
2190
- st8:
2191
- p+= 1;
2192
- if ( p == pe )
1325
+ case 7:
1326
+ switch( (*p) ) {
1327
+ case 42: goto st7;
1328
+ case 47: goto st4;
1329
+ }
1330
+ goto st6;
1331
+ st8:
1332
+ if ( ++p == pe )
2193
1333
  goto _test_eof8;
2194
- st_case_8:
2195
- if ( ( (*( p))) == 10 ) {
2196
- goto st4;
2197
- }
2198
- {
2199
- goto st8;
2200
- }
2201
- st9:
2202
- p+= 1;
2203
- if ( p == pe )
1334
+ case 8:
1335
+ if ( (*p) == 10 )
1336
+ goto st4;
1337
+ goto st8;
1338
+ st9:
1339
+ if ( ++p == pe )
2204
1340
  goto _test_eof9;
2205
- st_case_9:
2206
- switch( ( (*( p))) ) {
2207
- case 42: {
2208
- goto st10;
2209
- }
2210
- case 47: {
2211
- goto st12;
2212
- }
2213
- }
2214
- {
2215
- goto st0;
2216
- }
2217
- st10:
2218
- p+= 1;
2219
- if ( p == pe )
1341
+ case 9:
1342
+ switch( (*p) ) {
1343
+ case 42: goto st10;
1344
+ case 47: goto st12;
1345
+ }
1346
+ goto st0;
1347
+ st10:
1348
+ if ( ++p == pe )
2220
1349
  goto _test_eof10;
2221
- st_case_10:
2222
- if ( ( (*( p))) == 42 ) {
2223
- goto st11;
2224
- }
2225
- {
2226
- goto st10;
2227
- }
2228
- st11:
2229
- p+= 1;
2230
- if ( p == pe )
1350
+ case 10:
1351
+ if ( (*p) == 42 )
1352
+ goto st11;
1353
+ goto st10;
1354
+ st11:
1355
+ if ( ++p == pe )
2231
1356
  goto _test_eof11;
2232
- st_case_11:
2233
- switch( ( (*( p))) ) {
2234
- case 42: {
2235
- goto st11;
2236
- }
2237
- case 47: {
2238
- goto st3;
2239
- }
2240
- }
2241
- {
2242
- goto st10;
2243
- }
2244
- st12:
2245
- p+= 1;
2246
- if ( p == pe )
1357
+ case 11:
1358
+ switch( (*p) ) {
1359
+ case 42: goto st11;
1360
+ case 47: goto st3;
1361
+ }
1362
+ goto st10;
1363
+ st12:
1364
+ if ( ++p == pe )
2247
1365
  goto _test_eof12;
2248
- st_case_12:
2249
- if ( ( (*( p))) == 10 ) {
2250
- goto st3;
2251
- }
2252
- {
2253
- goto st12;
2254
- }
2255
- ctr4:
2256
- {
2257
- #line 424 "parser.rl"
2258
- {p = p - 1; } {p+= 1; cs = 17; goto _out;} }
2259
-
2260
- goto st17;
2261
- st17:
2262
- p+= 1;
2263
- if ( p == pe )
1366
+ case 12:
1367
+ if ( (*p) == 10 )
1368
+ goto st3;
1369
+ goto st12;
1370
+ tr4:
1371
+ #line 424 "parser.rl"
1372
+ { p--; {p++; cs = 17; goto _out;} }
1373
+ goto st17;
1374
+ st17:
1375
+ if ( ++p == pe )
2264
1376
  goto _test_eof17;
2265
- st_case_17:
2266
- {
2267
- goto st0;
2268
- }
2269
- st13:
2270
- p+= 1;
2271
- if ( p == pe )
1377
+ case 17:
1378
+ #line 1379 "parser.c"
1379
+ goto st0;
1380
+ st13:
1381
+ if ( ++p == pe )
2272
1382
  goto _test_eof13;
2273
- st_case_13:
2274
- switch( ( (*( p))) ) {
2275
- case 42: {
2276
- goto st14;
2277
- }
2278
- case 47: {
2279
- goto st16;
2280
- }
2281
- }
2282
- {
2283
- goto st0;
2284
- }
2285
- st14:
2286
- p+= 1;
2287
- if ( p == pe )
1383
+ case 13:
1384
+ switch( (*p) ) {
1385
+ case 42: goto st14;
1386
+ case 47: goto st16;
1387
+ }
1388
+ goto st0;
1389
+ st14:
1390
+ if ( ++p == pe )
2288
1391
  goto _test_eof14;
2289
- st_case_14:
2290
- if ( ( (*( p))) == 42 ) {
2291
- goto st15;
2292
- }
2293
- {
2294
- goto st14;
2295
- }
2296
- st15:
2297
- p+= 1;
2298
- if ( p == pe )
1392
+ case 14:
1393
+ if ( (*p) == 42 )
1394
+ goto st15;
1395
+ goto st14;
1396
+ st15:
1397
+ if ( ++p == pe )
2299
1398
  goto _test_eof15;
2300
- st_case_15:
2301
- switch( ( (*( p))) ) {
2302
- case 42: {
2303
- goto st15;
2304
- }
2305
- case 47: {
2306
- goto st2;
2307
- }
2308
- }
2309
- {
2310
- goto st14;
2311
- }
2312
- st16:
2313
- p+= 1;
2314
- if ( p == pe )
1399
+ case 15:
1400
+ switch( (*p) ) {
1401
+ case 42: goto st15;
1402
+ case 47: goto st2;
1403
+ }
1404
+ goto st14;
1405
+ st16:
1406
+ if ( ++p == pe )
2315
1407
  goto _test_eof16;
2316
- st_case_16:
2317
- if ( ( (*( p))) == 10 ) {
2318
- goto st2;
2319
- }
2320
- {
2321
- goto st16;
2322
- }
2323
- st_out:
2324
- _test_eof2: cs = 2; goto _test_eof;
2325
- _test_eof3: cs = 3; goto _test_eof;
2326
- _test_eof4: cs = 4; goto _test_eof;
2327
- _test_eof5: cs = 5; goto _test_eof;
2328
- _test_eof6: cs = 6; goto _test_eof;
2329
- _test_eof7: cs = 7; goto _test_eof;
2330
- _test_eof8: cs = 8; goto _test_eof;
2331
- _test_eof9: cs = 9; goto _test_eof;
2332
- _test_eof10: cs = 10; goto _test_eof;
2333
- _test_eof11: cs = 11; goto _test_eof;
2334
- _test_eof12: cs = 12; goto _test_eof;
2335
- _test_eof17: cs = 17; goto _test_eof;
2336
- _test_eof13: cs = 13; goto _test_eof;
2337
- _test_eof14: cs = 14; goto _test_eof;
2338
- _test_eof15: cs = 15; goto _test_eof;
2339
- _test_eof16: cs = 16; goto _test_eof;
2340
-
2341
- _test_eof: {}
2342
- _out: {}
2343
- }
2344
-
2345
- #line 446 "parser.rl"
2346
-
2347
-
2348
- if(cs >= JSON_array_first_final) {
2349
- return p + 1;
2350
- } else {
2351
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
2352
- return NULL;
1408
+ case 16:
1409
+ if ( (*p) == 10 )
1410
+ goto st2;
1411
+ goto st16;
2353
1412
  }
1413
+ _test_eof2: cs = 2; goto _test_eof;
1414
+ _test_eof3: cs = 3; goto _test_eof;
1415
+ _test_eof4: cs = 4; goto _test_eof;
1416
+ _test_eof5: cs = 5; goto _test_eof;
1417
+ _test_eof6: cs = 6; goto _test_eof;
1418
+ _test_eof7: cs = 7; goto _test_eof;
1419
+ _test_eof8: cs = 8; goto _test_eof;
1420
+ _test_eof9: cs = 9; goto _test_eof;
1421
+ _test_eof10: cs = 10; goto _test_eof;
1422
+ _test_eof11: cs = 11; goto _test_eof;
1423
+ _test_eof12: cs = 12; goto _test_eof;
1424
+ _test_eof17: cs = 17; goto _test_eof;
1425
+ _test_eof13: cs = 13; goto _test_eof;
1426
+ _test_eof14: cs = 14; goto _test_eof;
1427
+ _test_eof15: cs = 15; goto _test_eof;
1428
+ _test_eof16: cs = 16; goto _test_eof;
1429
+
1430
+ _test_eof: {}
1431
+ _out: {}
1432
+ }
1433
+
1434
+ #line 446 "parser.rl"
1435
+
1436
+ if(cs >= JSON_array_first_final) {
1437
+ return p + 1;
1438
+ } else {
1439
+ rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
1440
+ return NULL;
1441
+ }
2354
1442
  }
2355
1443
 
2356
1444
  static const size_t MAX_STACK_BUFFER_SIZE = 128;
2357
1445
  static VALUE json_string_unescape(char *string, char *stringEnd, int intern, int symbolize)
2358
1446
  {
2359
- VALUE result = Qnil;
2360
- size_t bufferSize = stringEnd - string;
2361
- char *p = string, *pe = string, *unescape, *bufferStart, *buffer;
2362
- int unescape_len;
2363
- char buf[4];
1447
+ VALUE result = Qnil;
1448
+ size_t bufferSize = stringEnd - string;
1449
+ char *p = string, *pe = string, *unescape, *bufferStart, *buffer;
1450
+ int unescape_len;
1451
+ char buf[4];
2364
1452
 
2365
- if (bufferSize > MAX_STACK_BUFFER_SIZE) {
1453
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2366
1454
  # ifdef HAVE_RB_ENC_INTERNED_STR
2367
- bufferStart = buffer = ALLOC_N(char, bufferSize ? bufferSize : 1);
1455
+ bufferStart = buffer = ALLOC_N(char, bufferSize ? bufferSize : 1);
2368
1456
  # else
2369
- bufferStart = buffer = ALLOC_N(char, bufferSize);
1457
+ bufferStart = buffer = ALLOC_N(char, bufferSize);
2370
1458
  # endif
2371
- } else {
1459
+ } else {
2372
1460
  # ifdef HAVE_RB_ENC_INTERNED_STR
2373
- bufferStart = buffer = ALLOCA_N(char, bufferSize ? bufferSize : 1);
1461
+ bufferStart = buffer = ALLOCA_N(char, bufferSize ? bufferSize : 1);
2374
1462
  # else
2375
- bufferStart = buffer = ALLOCA_N(char, bufferSize);
1463
+ bufferStart = buffer = ALLOCA_N(char, bufferSize);
2376
1464
  # endif
2377
- }
2378
-
2379
- while (pe < stringEnd) {
2380
- if (*pe == '\\') {
2381
- unescape = (char *) "?";
2382
- unescape_len = 1;
2383
- if (pe > p) {
2384
- MEMCPY(buffer, p, char, pe - p);
2385
- buffer += pe - p;
2386
- }
2387
- switch (*++pe) {
2388
- case 'n':
2389
- unescape = (char *) "\n";
2390
- break;
2391
- case 'r':
2392
- unescape = (char *) "\r";
2393
- break;
2394
- case 't':
2395
- unescape = (char *) "\t";
2396
- break;
2397
- case '"':
2398
- unescape = (char *) "\"";
2399
- break;
2400
- case '\\':
2401
- unescape = (char *) "\\";
2402
- break;
2403
- case 'b':
2404
- unescape = (char *) "\b";
2405
- break;
2406
- case 'f':
2407
- unescape = (char *) "\f";
2408
- break;
2409
- case 'u':
2410
- if (pe > stringEnd - 4) {
2411
- if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2412
- free(bufferStart);
2413
- }
2414
- rb_enc_raise(
2415
- EXC_ENCODING eParserError,
2416
- "%u: incomplete unicode character escape sequence at '%s'", __LINE__, p
2417
- );
2418
- } else {
2419
- UTF32 ch = unescape_unicode((unsigned char *) ++pe);
2420
- pe += 3;
2421
- if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
2422
- pe++;
2423
- if (pe > stringEnd - 6) {
2424
- if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2425
- free(bufferStart);
2426
- }
2427
- rb_enc_raise(
2428
- EXC_ENCODING eParserError,
2429
- "%u: incomplete surrogate pair at '%s'", __LINE__, p
2430
- );
2431
- }
2432
- if (pe[0] == '\\' && pe[1] == 'u') {
2433
- UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
2434
- ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
2435
- | (sur & 0x3FF));
2436
- pe += 5;
2437
- } else {
2438
- unescape = (char *) "?";
2439
- break;
2440
- }
2441
- }
2442
- unescape_len = convert_UTF32_to_UTF8(buf, ch);
2443
- unescape = buf;
2444
- }
2445
- break;
2446
- default:
2447
- p = pe;
2448
- continue;
2449
- }
2450
- MEMCPY(buffer, unescape, char, unescape_len);
2451
- buffer += unescape_len;
2452
- p = ++pe;
2453
- } else {
2454
- pe++;
2455
- }
2456
- }
2457
-
2458
- if (pe > p) {
2459
- MEMCPY(buffer, p, char, pe - p);
2460
- buffer += pe - p;
2461
- }
2462
-
2463
- # ifdef HAVE_RB_ENC_INTERNED_STR
2464
- if (intern) {
2465
- result = rb_enc_interned_str(bufferStart, (long)(buffer - bufferStart), rb_utf8_encoding());
2466
- } else {
2467
- result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
2468
- }
2469
- if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2470
- free(bufferStart);
2471
- }
2472
- # else
2473
- result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
1465
+ }
1466
+
1467
+ while (pe < stringEnd) {
1468
+ if (*pe == '\\') {
1469
+ unescape = (char *) "?";
1470
+ unescape_len = 1;
1471
+ if (pe > p) {
1472
+ MEMCPY(buffer, p, char, pe - p);
1473
+ buffer += pe - p;
1474
+ }
1475
+ switch (*++pe) {
1476
+ case 'n':
1477
+ unescape = (char *) "\n";
1478
+ break;
1479
+ case 'r':
1480
+ unescape = (char *) "\r";
1481
+ break;
1482
+ case 't':
1483
+ unescape = (char *) "\t";
1484
+ break;
1485
+ case '"':
1486
+ unescape = (char *) "\"";
1487
+ break;
1488
+ case '\\':
1489
+ unescape = (char *) "\\";
1490
+ break;
1491
+ case 'b':
1492
+ unescape = (char *) "\b";
1493
+ break;
1494
+ case 'f':
1495
+ unescape = (char *) "\f";
1496
+ break;
1497
+ case 'u':
1498
+ if (pe > stringEnd - 4) {
1499
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
1500
+ ruby_xfree(bufferStart);
1501
+ }
1502
+ rb_enc_raise(
1503
+ EXC_ENCODING eParserError,
1504
+ "incomplete unicode character escape sequence at '%s'", p
1505
+ );
1506
+ } else {
1507
+ UTF32 ch = unescape_unicode((unsigned char *) ++pe);
1508
+ pe += 3;
1509
+ if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
1510
+ pe++;
1511
+ if (pe > stringEnd - 6) {
1512
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
1513
+ ruby_xfree(bufferStart);
1514
+ }
1515
+ rb_enc_raise(
1516
+ EXC_ENCODING eParserError,
1517
+ "incomplete surrogate pair at '%s'", p
1518
+ );
1519
+ }
1520
+ if (pe[0] == '\\' && pe[1] == 'u') {
1521
+ UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
1522
+ ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
1523
+ | (sur & 0x3FF));
1524
+ pe += 5;
1525
+ } else {
1526
+ unescape = (char *) "?";
1527
+ break;
1528
+ }
1529
+ }
1530
+ unescape_len = convert_UTF32_to_UTF8(buf, ch);
1531
+ unescape = buf;
1532
+ }
1533
+ break;
1534
+ default:
1535
+ p = pe;
1536
+ continue;
1537
+ }
1538
+ MEMCPY(buffer, unescape, char, unescape_len);
1539
+ buffer += unescape_len;
1540
+ p = ++pe;
1541
+ } else {
1542
+ pe++;
1543
+ }
1544
+ }
1545
+
1546
+ if (pe > p) {
1547
+ MEMCPY(buffer, p, char, pe - p);
1548
+ buffer += pe - p;
1549
+ }
2474
1550
 
2475
- if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2476
- free(bufferStart);
2477
- }
2478
-
2479
- if (intern) {
2480
- # if STR_UMINUS_DEDUPE_FROZEN
2481
- // Starting from MRI 2.8 it is preferable to freeze the string
2482
- // before deduplication so that it can be interned directly
2483
- // otherwise it would be duplicated first which is wasteful.
2484
- result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
2485
- # elif STR_UMINUS_DEDUPE
2486
- // MRI 2.5 and older do not deduplicate strings that are already
2487
- // frozen.
2488
- result = rb_funcall(result, i_uminus, 0);
2489
- # else
2490
- result = rb_str_freeze(result);
2491
- # endif
2492
- }
2493
- # endif
1551
+ # ifdef HAVE_RB_ENC_INTERNED_STR
1552
+ if (intern) {
1553
+ result = rb_enc_interned_str(bufferStart, (long)(buffer - bufferStart), rb_utf8_encoding());
1554
+ } else {
1555
+ result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
1556
+ }
1557
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
1558
+ ruby_xfree(bufferStart);
1559
+ }
1560
+ # else
1561
+ result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
1562
+
1563
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
1564
+ ruby_xfree(bufferStart);
1565
+ }
1566
+
1567
+ if (intern) {
1568
+ # if STR_UMINUS_DEDUPE_FROZEN
1569
+ // Starting from MRI 2.8 it is preferable to freeze the string
1570
+ // before deduplication so that it can be interned directly
1571
+ // otherwise it would be duplicated first which is wasteful.
1572
+ result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
1573
+ # elif STR_UMINUS_DEDUPE
1574
+ // MRI 2.5 and older do not deduplicate strings that are already
1575
+ // frozen.
1576
+ result = rb_funcall(result, i_uminus, 0);
1577
+ # else
1578
+ result = rb_str_freeze(result);
1579
+ # endif
1580
+ }
1581
+ # endif
2494
1582
 
2495
- if (symbolize) {
2496
- result = rb_str_intern(result);
2497
- }
1583
+ if (symbolize) {
1584
+ result = rb_str_intern(result);
1585
+ }
2498
1586
 
2499
- return result;
1587
+ return result;
2500
1588
  }
2501
1589
 
2502
1590
 
1591
+ #line 1592 "parser.c"
2503
1592
  enum {JSON_string_start = 1};
2504
1593
  enum {JSON_string_first_final = 8};
2505
1594
  enum {JSON_string_error = 0};
2506
1595
 
2507
1596
  enum {JSON_string_en_main = 1};
2508
1597
 
2509
- static const char MAYBE_UNUSED(_JSON_string_nfa_targs)[] = {
2510
- 0, 0
2511
- };
2512
-
2513
- static const char MAYBE_UNUSED(_JSON_string_nfa_offsets)[] = {
2514
- 0, 0, 0, 0, 0, 0, 0, 0,
2515
- 0, 0
2516
- };
2517
1598
 
2518
- static const char MAYBE_UNUSED(_JSON_string_nfa_push_actions)[] = {
2519
- 0, 0
2520
- };
2521
-
2522
- static const char MAYBE_UNUSED(_JSON_string_nfa_pop_trans)[] = {
2523
- 0, 0
2524
- };
2525
-
2526
-
2527
- #line 612 "parser.rl"
1599
+ #line 620 "parser.rl"
2528
1600
 
2529
1601
 
2530
1602
  static int
2531
1603
  match_i(VALUE regexp, VALUE klass, VALUE memo)
2532
1604
  {
2533
- if (regexp == Qundef) return ST_STOP;
2534
- if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
2535
- RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
2536
- rb_ary_push(memo, klass);
2537
- return ST_STOP;
2538
- }
2539
- return ST_CONTINUE;
1605
+ if (regexp == Qundef) return ST_STOP;
1606
+ if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
1607
+ RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
1608
+ rb_ary_push(memo, klass);
1609
+ return ST_STOP;
1610
+ }
1611
+ return ST_CONTINUE;
2540
1612
  }
2541
1613
 
2542
1614
  static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
2543
1615
  {
2544
- int cs = EVIL;
2545
- VALUE match_string;
1616
+ int cs = EVIL;
1617
+ VALUE match_string;
2546
1618
 
2547
1619
 
1620
+ #line 1621 "parser.c"
2548
1621
  {
2549
- cs = (int)JSON_string_start;
1622
+ cs = JSON_string_start;
2550
1623
  }
2551
1624
 
2552
- #line 632 "parser.rl"
2553
-
2554
- json->memo = p;
1625
+ #line 640 "parser.rl"
1626
+ json->memo = p;
2555
1627
 
1628
+ #line 1629 "parser.c"
2556
1629
  {
2557
- if ( p == pe )
1630
+ if ( p == pe )
2558
1631
  goto _test_eof;
2559
- switch ( cs )
2560
- {
2561
- case 1:
2562
- goto st_case_1;
2563
- case 0:
2564
- goto st_case_0;
2565
- case 2:
2566
- goto st_case_2;
2567
- case 8:
2568
- goto st_case_8;
2569
- case 3:
2570
- goto st_case_3;
2571
- case 4:
2572
- goto st_case_4;
2573
- case 5:
2574
- goto st_case_5;
2575
- case 6:
2576
- goto st_case_6;
2577
- case 7:
2578
- goto st_case_7;
2579
- }
2580
- goto st_out;
2581
- st_case_1:
2582
- if ( ( (*( p))) == 34 ) {
2583
- goto st2;
2584
- }
2585
- {
2586
- goto st0;
2587
- }
2588
- st_case_0:
2589
- st0:
2590
- cs = 0;
2591
- goto _out;
2592
- st2:
2593
- p+= 1;
2594
- if ( p == pe )
1632
+ switch ( cs )
1633
+ {
1634
+ case 1:
1635
+ if ( (*p) == 34 )
1636
+ goto st2;
1637
+ goto st0;
1638
+ st0:
1639
+ cs = 0;
1640
+ goto _out;
1641
+ st2:
1642
+ if ( ++p == pe )
2595
1643
  goto _test_eof2;
2596
- st_case_2:
2597
- switch( ( (*( p))) ) {
2598
- case 34: {
2599
- goto ctr2;
2600
- }
2601
- case 92: {
2602
- goto st3;
2603
- }
2604
- }
2605
- if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
2606
- goto st0;
2607
- }
2608
- {
2609
- goto st2;
2610
- }
2611
- ctr2:
2612
- {
2613
- #line 599 "parser.rl"
2614
-
2615
- *result = json_string_unescape(json->memo + 1, p, json->parsing_name || json-> freeze, json->parsing_name && json->symbolize_names);
2616
- if (NIL_P(*result)) {
2617
- {p = p - 1; }
2618
- {p+= 1; cs = 8; goto _out;}
2619
- } else {
2620
- {p = (( p + 1))-1;}
2621
-
2622
- }
2623
- }
2624
- {
2625
- #line 609 "parser.rl"
2626
- {p = p - 1; } {p+= 1; cs = 8; goto _out;} }
2627
-
2628
- goto st8;
2629
- st8:
2630
- p+= 1;
2631
- if ( p == pe )
1644
+ case 2:
1645
+ switch( (*p) ) {
1646
+ case 34: goto tr2;
1647
+ case 92: goto st3;
1648
+ }
1649
+ if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 )
1650
+ goto st0;
1651
+ goto st2;
1652
+ tr2:
1653
+ #line 607 "parser.rl"
1654
+ {
1655
+ *result = json_string_unescape(json->memo + 1, p, json->parsing_name || json-> freeze, json->parsing_name && json->symbolize_names);
1656
+ if (NIL_P(*result)) {
1657
+ p--;
1658
+ {p++; cs = 8; goto _out;}
1659
+ } else {
1660
+ {p = (( p + 1))-1;}
1661
+ }
1662
+ }
1663
+ #line 617 "parser.rl"
1664
+ { p--; {p++; cs = 8; goto _out;} }
1665
+ goto st8;
1666
+ st8:
1667
+ if ( ++p == pe )
2632
1668
  goto _test_eof8;
2633
- st_case_8:
2634
- {
2635
- goto st0;
2636
- }
2637
- st3:
2638
- p+= 1;
2639
- if ( p == pe )
1669
+ case 8:
1670
+ #line 1671 "parser.c"
1671
+ goto st0;
1672
+ st3:
1673
+ if ( ++p == pe )
2640
1674
  goto _test_eof3;
2641
- st_case_3:
2642
- if ( ( (*( p))) == 117 ) {
2643
- goto st4;
2644
- }
2645
- if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
2646
- goto st0;
2647
- }
2648
- {
2649
- goto st2;
2650
- }
2651
- st4:
2652
- p+= 1;
2653
- if ( p == pe )
1675
+ case 3:
1676
+ if ( (*p) == 117 )
1677
+ goto st4;
1678
+ if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 )
1679
+ goto st0;
1680
+ goto st2;
1681
+ st4:
1682
+ if ( ++p == pe )
2654
1683
  goto _test_eof4;
2655
- st_case_4:
2656
- if ( ( (*( p))) < 65 ) {
2657
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2658
- goto st5;
2659
- }
2660
- } else if ( ( (*( p))) > 70 ) {
2661
- if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2662
- goto st5;
2663
- }
2664
- } else {
1684
+ case 4:
1685
+ if ( (*p) < 65 ) {
1686
+ if ( 48 <= (*p) && (*p) <= 57 )
2665
1687
  goto st5;
2666
- }
2667
- {
2668
- goto st0;
2669
- }
2670
- st5:
2671
- p+= 1;
2672
- if ( p == pe )
1688
+ } else if ( (*p) > 70 ) {
1689
+ if ( 97 <= (*p) && (*p) <= 102 )
1690
+ goto st5;
1691
+ } else
1692
+ goto st5;
1693
+ goto st0;
1694
+ st5:
1695
+ if ( ++p == pe )
2673
1696
  goto _test_eof5;
2674
- st_case_5:
2675
- if ( ( (*( p))) < 65 ) {
2676
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2677
- goto st6;
2678
- }
2679
- } else if ( ( (*( p))) > 70 ) {
2680
- if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2681
- goto st6;
2682
- }
2683
- } else {
1697
+ case 5:
1698
+ if ( (*p) < 65 ) {
1699
+ if ( 48 <= (*p) && (*p) <= 57 )
1700
+ goto st6;
1701
+ } else if ( (*p) > 70 ) {
1702
+ if ( 97 <= (*p) && (*p) <= 102 )
2684
1703
  goto st6;
2685
- }
2686
- {
2687
- goto st0;
2688
- }
2689
- st6:
2690
- p+= 1;
2691
- if ( p == pe )
1704
+ } else
1705
+ goto st6;
1706
+ goto st0;
1707
+ st6:
1708
+ if ( ++p == pe )
2692
1709
  goto _test_eof6;
2693
- st_case_6:
2694
- if ( ( (*( p))) < 65 ) {
2695
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2696
- goto st7;
2697
- }
2698
- } else if ( ( (*( p))) > 70 ) {
2699
- if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2700
- goto st7;
2701
- }
2702
- } else {
1710
+ case 6:
1711
+ if ( (*p) < 65 ) {
1712
+ if ( 48 <= (*p) && (*p) <= 57 )
2703
1713
  goto st7;
2704
- }
2705
- {
2706
- goto st0;
2707
- }
2708
- st7:
2709
- p+= 1;
2710
- if ( p == pe )
1714
+ } else if ( (*p) > 70 ) {
1715
+ if ( 97 <= (*p) && (*p) <= 102 )
1716
+ goto st7;
1717
+ } else
1718
+ goto st7;
1719
+ goto st0;
1720
+ st7:
1721
+ if ( ++p == pe )
2711
1722
  goto _test_eof7;
2712
- st_case_7:
2713
- if ( ( (*( p))) < 65 ) {
2714
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2715
- goto st2;
2716
- }
2717
- } else if ( ( (*( p))) > 70 ) {
2718
- if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2719
- goto st2;
2720
- }
2721
- } else {
1723
+ case 7:
1724
+ if ( (*p) < 65 ) {
1725
+ if ( 48 <= (*p) && (*p) <= 57 )
2722
1726
  goto st2;
2723
- }
2724
- {
2725
- goto st0;
2726
- }
2727
- st_out:
2728
- _test_eof2: cs = 2; goto _test_eof;
2729
- _test_eof8: cs = 8; goto _test_eof;
2730
- _test_eof3: cs = 3; goto _test_eof;
2731
- _test_eof4: cs = 4; goto _test_eof;
2732
- _test_eof5: cs = 5; goto _test_eof;
2733
- _test_eof6: cs = 6; goto _test_eof;
2734
- _test_eof7: cs = 7; goto _test_eof;
2735
-
2736
- _test_eof: {}
2737
- _out: {}
2738
- }
2739
-
2740
- #line 634 "parser.rl"
2741
-
2742
-
2743
- if (json->create_additions && RTEST(match_string = json->match_string)) {
2744
- VALUE klass;
2745
- VALUE memo = rb_ary_new2(2);
2746
- rb_ary_push(memo, *result);
2747
- rb_hash_foreach(match_string, match_i, memo);
2748
- klass = rb_ary_entry(memo, 1);
2749
- if (RTEST(klass)) {
2750
- *result = rb_funcall(klass, i_json_create, 1, *result);
2751
- }
2752
- }
2753
-
2754
- if (cs >= JSON_string_first_final) {
2755
- return p + 1;
2756
- } else {
2757
- return NULL;
1727
+ } else if ( (*p) > 70 ) {
1728
+ if ( 97 <= (*p) && (*p) <= 102 )
1729
+ goto st2;
1730
+ } else
1731
+ goto st2;
1732
+ goto st0;
2758
1733
  }
1734
+ _test_eof2: cs = 2; goto _test_eof;
1735
+ _test_eof8: cs = 8; goto _test_eof;
1736
+ _test_eof3: cs = 3; goto _test_eof;
1737
+ _test_eof4: cs = 4; goto _test_eof;
1738
+ _test_eof5: cs = 5; goto _test_eof;
1739
+ _test_eof6: cs = 6; goto _test_eof;
1740
+ _test_eof7: cs = 7; goto _test_eof;
1741
+
1742
+ _test_eof: {}
1743
+ _out: {}
1744
+ }
1745
+
1746
+ #line 642 "parser.rl"
1747
+
1748
+ if (json->create_additions && RTEST(match_string = json->match_string)) {
1749
+ VALUE klass;
1750
+ VALUE memo = rb_ary_new2(2);
1751
+ rb_ary_push(memo, *result);
1752
+ rb_hash_foreach(match_string, match_i, memo);
1753
+ klass = rb_ary_entry(memo, 1);
1754
+ if (RTEST(klass)) {
1755
+ *result = rb_funcall(klass, i_json_create, 1, *result);
1756
+ }
1757
+ }
1758
+
1759
+ if (cs >= JSON_string_first_final) {
1760
+ return p + 1;
1761
+ } else {
1762
+ return NULL;
1763
+ }
2759
1764
  }
2760
1765
 
2761
1766
  /*
2762
- * Document-class: JSON::Ext::Parser
2763
- *
2764
- * This is the JSON parser implemented as a C extension. It can be configured
2765
- * to be used by setting
2766
- *
2767
- * JSON.parser = JSON::Ext::Parser
2768
- *
2769
- * with the method parser= in JSON.
2770
- *
2771
- */
1767
+ * Document-class: JSON::Ext::Parser
1768
+ *
1769
+ * This is the JSON parser implemented as a C extension. It can be configured
1770
+ * to be used by setting
1771
+ *
1772
+ * JSON.parser = JSON::Ext::Parser
1773
+ *
1774
+ * with the method parser= in JSON.
1775
+ *
1776
+ */
2772
1777
 
2773
1778
  static VALUE convert_encoding(VALUE source)
2774
1779
  {
2775
- #ifdef HAVE_RUBY_ENCODING_H
2776
- rb_encoding *enc = rb_enc_get(source);
2777
- if (enc == rb_ascii8bit_encoding()) {
2778
- if (OBJ_FROZEN(source)) {
2779
- source = rb_str_dup(source);
2780
- }
2781
- FORCE_UTF8(source);
2782
- } else {
2783
- source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
2784
- }
2785
- #endif
2786
- return source;
1780
+ #ifdef HAVE_RUBY_ENCODING_H
1781
+ rb_encoding *enc = rb_enc_get(source);
1782
+ if (enc == rb_ascii8bit_encoding()) {
1783
+ if (OBJ_FROZEN(source)) {
1784
+ source = rb_str_dup(source);
1785
+ }
1786
+ FORCE_UTF8(source);
1787
+ } else {
1788
+ source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
1789
+ }
1790
+ #endif
1791
+ return source;
2787
1792
  }
2788
1793
 
2789
1794
  /*
2790
- * call-seq: new(source, opts => {})
2791
- *
2792
- * Creates a new JSON::Ext::Parser instance for the string _source_.
2793
- *
2794
- * Creates a new JSON::Ext::Parser instance for the string _source_.
2795
- *
2796
- * It will be configured by the _opts_ hash. _opts_ can have the following
2797
- * keys:
2798
- *
2799
- * _opts_ can have the following keys:
2800
- * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
2801
- * structures. Disable depth checking with :max_nesting => false|nil|0, it
2802
- * defaults to 100.
2803
- * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
2804
- * defiance of RFC 4627 to be parsed by the Parser. This option defaults to
2805
- * false.
2806
- * * *symbolize_names*: If set to true, returns symbols for the names
2807
- * (keys) in a JSON object. Otherwise strings are returned, which is
2808
- * also the default. It's not possible to use this option in
2809
- * conjunction with the *create_additions* option.
2810
- * * *create_additions*: If set to false, the Parser doesn't create
2811
- * additions even if a matching class and create_id was found. This option
2812
- * defaults to false.
2813
- * * *object_class*: Defaults to Hash
2814
- * * *array_class*: Defaults to Array
2815
- */
1795
+ * call-seq: new(source, opts => {})
1796
+ *
1797
+ * Creates a new JSON::Ext::Parser instance for the string _source_.
1798
+ *
1799
+ * It will be configured by the _opts_ hash. _opts_ can have the following
1800
+ * keys:
1801
+ *
1802
+ * _opts_ can have the following keys:
1803
+ * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
1804
+ * structures. Disable depth checking with :max_nesting => false|nil|0, it
1805
+ * defaults to 100.
1806
+ * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
1807
+ * defiance of RFC 4627 to be parsed by the Parser. This option defaults to
1808
+ * false.
1809
+ * * *symbolize_names*: If set to true, returns symbols for the names
1810
+ * (keys) in a JSON object. Otherwise strings are returned, which is
1811
+ * also the default. It's not possible to use this option in
1812
+ * conjunction with the *create_additions* option.
1813
+ * * *create_additions*: If set to false, the Parser doesn't create
1814
+ * additions even if a matching class and create_id was found. This option
1815
+ * defaults to false.
1816
+ * * *object_class*: Defaults to Hash
1817
+ * * *array_class*: Defaults to Array
1818
+ */
2816
1819
  static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
2817
1820
  {
2818
- VALUE source, opts;
2819
- GET_PARSER_INIT;
2820
-
2821
- if (json->Vsource) {
2822
- rb_raise(rb_eTypeError, "already initialized instance");
2823
- }
2824
- #ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2825
- rb_scan_args(argc, argv, "1:", &source, &opts);
2826
- #else
2827
- rb_scan_args(argc, argv, "11", &source, &opts);
2828
- #endif
2829
- if (!NIL_P(opts)) {
2830
- #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2831
- opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
2832
- if (NIL_P(opts)) {
2833
- rb_raise(rb_eArgError, "opts needs to be like a hash");
2834
- } else {
2835
- #endif
2836
- VALUE tmp = ID2SYM(i_max_nesting);
2837
- if (option_given_p(opts, tmp)) {
2838
- VALUE max_nesting = rb_hash_aref(opts, tmp);
2839
- if (RTEST(max_nesting)) {
2840
- Check_Type(max_nesting, T_FIXNUM);
2841
- json->max_nesting = FIX2INT(max_nesting);
2842
- } else {
2843
- json->max_nesting = 0;
2844
- }
2845
- } else {
2846
- json->max_nesting = 100;
2847
- }
2848
- tmp = ID2SYM(i_allow_nan);
2849
- if (option_given_p(opts, tmp)) {
2850
- json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2851
- } else {
2852
- json->allow_nan = 0;
2853
- }
2854
- tmp = ID2SYM(i_symbolize_names);
2855
- if (option_given_p(opts, tmp)) {
2856
- json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2857
- } else {
2858
- json->symbolize_names = 0;
2859
- }
2860
- tmp = ID2SYM(i_freeze);
2861
- if (option_given_p(opts, tmp)) {
2862
- json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2863
- } else {
2864
- json->freeze = 0;
2865
- }
2866
- tmp = ID2SYM(i_create_additions);
2867
- if (option_given_p(opts, tmp)) {
2868
- json->create_additions = RTEST(rb_hash_aref(opts, tmp));
2869
- } else {
2870
- json->create_additions = 0;
2871
- }
2872
- if (json->symbolize_names && json->create_additions) {
2873
- rb_raise(rb_eArgError,
2874
- "options :symbolize_names and :create_additions cannot be "
2875
- " used in conjunction");
2876
- }
2877
- tmp = ID2SYM(i_create_id);
2878
- if (option_given_p(opts, tmp)) {
2879
- json->create_id = rb_hash_aref(opts, tmp);
2880
- } else {
2881
- json->create_id = rb_funcall(mJSON, i_create_id, 0);
2882
- }
2883
- tmp = ID2SYM(i_object_class);
2884
- if (option_given_p(opts, tmp)) {
2885
- json->object_class = rb_hash_aref(opts, tmp);
2886
- } else {
2887
- json->object_class = Qnil;
2888
- }
2889
- tmp = ID2SYM(i_array_class);
2890
- if (option_given_p(opts, tmp)) {
2891
- json->array_class = rb_hash_aref(opts, tmp);
2892
- } else {
2893
- json->array_class = Qnil;
2894
- }
2895
- tmp = ID2SYM(i_decimal_class);
2896
- if (option_given_p(opts, tmp)) {
2897
- json->decimal_class = rb_hash_aref(opts, tmp);
2898
- } else {
2899
- json->decimal_class = Qnil;
2900
- }
2901
- tmp = ID2SYM(i_match_string);
2902
- if (option_given_p(opts, tmp)) {
2903
- VALUE match_string = rb_hash_aref(opts, tmp);
2904
- json->match_string = RTEST(match_string) ? match_string : Qnil;
2905
- } else {
2906
- json->match_string = Qnil;
2907
- }
2908
- #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2909
- }
2910
- #endif
1821
+ VALUE source, opts;
1822
+ GET_PARSER_INIT;
1823
+
1824
+ if (json->Vsource) {
1825
+ rb_raise(rb_eTypeError, "already initialized instance");
1826
+ }
1827
+ rb_scan_args(argc, argv, "1:", &source, &opts);
1828
+ if (!NIL_P(opts)) {
1829
+ VALUE tmp = ID2SYM(i_max_nesting);
1830
+ if (option_given_p(opts, tmp)) {
1831
+ VALUE max_nesting = rb_hash_aref(opts, tmp);
1832
+ if (RTEST(max_nesting)) {
1833
+ Check_Type(max_nesting, T_FIXNUM);
1834
+ json->max_nesting = FIX2INT(max_nesting);
1835
+ } else {
1836
+ json->max_nesting = 0;
1837
+ }
1838
+ } else {
1839
+ json->max_nesting = 100;
1840
+ }
1841
+ tmp = ID2SYM(i_allow_nan);
1842
+ if (option_given_p(opts, tmp)) {
1843
+ json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1844
+ } else {
1845
+ json->allow_nan = 0;
1846
+ }
1847
+ tmp = ID2SYM(i_symbolize_names);
1848
+ if (option_given_p(opts, tmp)) {
1849
+ json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1850
+ } else {
1851
+ json->symbolize_names = 0;
1852
+ }
1853
+ tmp = ID2SYM(i_freeze);
1854
+ if (option_given_p(opts, tmp)) {
1855
+ json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1856
+ } else {
1857
+ json->freeze = 0;
1858
+ }
1859
+ tmp = ID2SYM(i_create_additions);
1860
+ if (option_given_p(opts, tmp)) {
1861
+ json->create_additions = RTEST(rb_hash_aref(opts, tmp));
1862
+ } else {
1863
+ json->create_additions = 0;
1864
+ }
1865
+ if (json->symbolize_names && json->create_additions) {
1866
+ rb_raise(rb_eArgError,
1867
+ "options :symbolize_names and :create_additions cannot be "
1868
+ " used in conjunction");
1869
+ }
1870
+ tmp = ID2SYM(i_create_id);
1871
+ if (option_given_p(opts, tmp)) {
1872
+ json->create_id = rb_hash_aref(opts, tmp);
1873
+ } else {
1874
+ json->create_id = rb_funcall(mJSON, i_create_id, 0);
1875
+ }
1876
+ tmp = ID2SYM(i_object_class);
1877
+ if (option_given_p(opts, tmp)) {
1878
+ json->object_class = rb_hash_aref(opts, tmp);
1879
+ } else {
1880
+ json->object_class = Qnil;
1881
+ }
1882
+ tmp = ID2SYM(i_array_class);
1883
+ if (option_given_p(opts, tmp)) {
1884
+ json->array_class = rb_hash_aref(opts, tmp);
1885
+ } else {
1886
+ json->array_class = Qnil;
1887
+ }
1888
+ tmp = ID2SYM(i_decimal_class);
1889
+ if (option_given_p(opts, tmp)) {
1890
+ json->decimal_class = rb_hash_aref(opts, tmp);
2911
1891
  } else {
2912
- json->max_nesting = 100;
2913
- json->allow_nan = 0;
2914
- json->create_additions = 0;
2915
- json->create_id = rb_funcall(mJSON, i_create_id, 0);
2916
- json->object_class = Qnil;
2917
- json->array_class = Qnil;
2918
- json->decimal_class = Qnil;
2919
- }
2920
- source = convert_encoding(StringValue(source));
2921
- StringValue(source);
2922
- json->len = RSTRING_LEN(source);
2923
- json->source = RSTRING_PTR(source);;
2924
- json->Vsource = source;
2925
- return self;
1892
+ json->decimal_class = Qnil;
1893
+ }
1894
+ tmp = ID2SYM(i_match_string);
1895
+ if (option_given_p(opts, tmp)) {
1896
+ VALUE match_string = rb_hash_aref(opts, tmp);
1897
+ json->match_string = RTEST(match_string) ? match_string : Qnil;
1898
+ } else {
1899
+ json->match_string = Qnil;
1900
+ }
1901
+ } else {
1902
+ json->max_nesting = 100;
1903
+ json->allow_nan = 0;
1904
+ json->create_additions = 0;
1905
+ json->create_id = Qnil;
1906
+ json->object_class = Qnil;
1907
+ json->array_class = Qnil;
1908
+ json->decimal_class = Qnil;
1909
+ }
1910
+ source = convert_encoding(StringValue(source));
1911
+ StringValue(source);
1912
+ json->len = RSTRING_LEN(source);
1913
+ json->source = RSTRING_PTR(source);;
1914
+ json->Vsource = source;
1915
+ return self;
2926
1916
  }
2927
1917
 
2928
1918
 
1919
+ #line 1920 "parser.c"
2929
1920
  enum {JSON_start = 1};
2930
1921
  enum {JSON_first_final = 10};
2931
1922
  enum {JSON_error = 0};
2932
1923
 
2933
1924
  enum {JSON_en_main = 1};
2934
1925
 
2935
- static const char MAYBE_UNUSED(_JSON_nfa_targs)[] = {
2936
- 0, 0
2937
- };
2938
-
2939
- static const char MAYBE_UNUSED(_JSON_nfa_offsets)[] = {
2940
- 0, 0, 0, 0, 0, 0, 0, 0,
2941
- 0, 0, 0, 0
2942
- };
2943
-
2944
- static const char MAYBE_UNUSED(_JSON_nfa_push_actions)[] = {
2945
- 0, 0
2946
- };
2947
-
2948
- static const char MAYBE_UNUSED(_JSON_nfa_pop_trans)[] = {
2949
- 0, 0
2950
- };
2951
-
2952
1926
 
2953
- #line 835 "parser.rl"
1927
+ #line 828 "parser.rl"
2954
1928
 
2955
1929
 
2956
1930
  /*
2957
- * call-seq: parse()
2958
- *
2959
- * Parses the current JSON text _source_ and returns the complete data
2960
- * structure as a result.
2961
- * It raises JSON::ParseError if fail to parse.
2962
- */
1931
+ * call-seq: parse()
1932
+ *
1933
+ * Parses the current JSON text _source_ and returns the complete data
1934
+ * structure as a result.
1935
+ * It raises JSON::ParserError if fail to parse.
1936
+ */
2963
1937
  static VALUE cParser_parse(VALUE self)
2964
1938
  {
2965
- char *p, *pe;
2966
- int cs = EVIL;
2967
- VALUE result = Qnil;
2968
- GET_PARSER;
1939
+ char *p, *pe;
1940
+ int cs = EVIL;
1941
+ VALUE result = Qnil;
1942
+ GET_PARSER;
2969
1943
 
2970
1944
 
1945
+ #line 1946 "parser.c"
2971
1946
  {
2972
- cs = (int)JSON_start;
1947
+ cs = JSON_start;
2973
1948
  }
2974
1949
 
2975
- #line 851 "parser.rl"
2976
-
2977
- p = json->source;
2978
- pe = p + json->len;
1950
+ #line 845 "parser.rl"
1951
+ p = json->source;
1952
+ pe = p + json->len;
2979
1953
 
1954
+ #line 1955 "parser.c"
2980
1955
  {
2981
- if ( p == pe )
1956
+ if ( p == pe )
2982
1957
  goto _test_eof;
2983
- switch ( cs )
2984
- {
2985
- case 1:
2986
- goto st_case_1;
2987
- case 0:
2988
- goto st_case_0;
2989
- case 10:
2990
- goto st_case_10;
2991
- case 2:
2992
- goto st_case_2;
2993
- case 3:
2994
- goto st_case_3;
2995
- case 4:
2996
- goto st_case_4;
2997
- case 5:
2998
- goto st_case_5;
2999
- case 6:
3000
- goto st_case_6;
3001
- case 7:
3002
- goto st_case_7;
3003
- case 8:
3004
- goto st_case_8;
3005
- case 9:
3006
- goto st_case_9;
3007
- }
3008
- goto st_out;
3009
- st1:
3010
- p+= 1;
3011
- if ( p == pe )
1958
+ switch ( cs )
1959
+ {
1960
+ st1:
1961
+ if ( ++p == pe )
3012
1962
  goto _test_eof1;
3013
- st_case_1:
3014
- switch( ( (*( p))) ) {
3015
- case 13: {
3016
- goto st1;
3017
- }
3018
- case 32: {
3019
- goto st1;
3020
- }
3021
- case 34: {
3022
- goto ctr2;
3023
- }
3024
- case 45: {
3025
- goto ctr2;
3026
- }
3027
- case 47: {
3028
- goto st6;
3029
- }
3030
- case 73: {
3031
- goto ctr2;
3032
- }
3033
- case 78: {
3034
- goto ctr2;
3035
- }
3036
- case 91: {
3037
- goto ctr2;
3038
- }
3039
- case 102: {
3040
- goto ctr2;
3041
- }
3042
- case 110: {
3043
- goto ctr2;
3044
- }
3045
- case 116: {
3046
- goto ctr2;
3047
- }
3048
- case 123: {
3049
- goto ctr2;
3050
- }
3051
- }
3052
- if ( ( (*( p))) > 10 ) {
3053
- if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
3054
- goto ctr2;
3055
- }
3056
- } else if ( ( (*( p))) >= 9 ) {
3057
- goto st1;
3058
- }
3059
- {
3060
- goto st0;
3061
- }
3062
- st_case_0:
3063
- st0:
3064
- cs = 0;
3065
- goto _out;
3066
- ctr2:
3067
- {
3068
- #line 827 "parser.rl"
3069
-
3070
- char *np = JSON_parse_value(json, p, pe, &result, 0);
3071
- if (np == NULL) { {p = p - 1; } {p+= 1; cs = 10; goto _out;} } else {p = (( np))-1;}
3072
-
3073
- }
3074
-
3075
- goto st10;
3076
- st10:
3077
- p+= 1;
3078
- if ( p == pe )
1963
+ case 1:
1964
+ switch( (*p) ) {
1965
+ case 13: goto st1;
1966
+ case 32: goto st1;
1967
+ case 34: goto tr2;
1968
+ case 45: goto tr2;
1969
+ case 47: goto st6;
1970
+ case 73: goto tr2;
1971
+ case 78: goto tr2;
1972
+ case 91: goto tr2;
1973
+ case 102: goto tr2;
1974
+ case 110: goto tr2;
1975
+ case 116: goto tr2;
1976
+ case 123: goto tr2;
1977
+ }
1978
+ if ( (*p) > 10 ) {
1979
+ if ( 48 <= (*p) && (*p) <= 57 )
1980
+ goto tr2;
1981
+ } else if ( (*p) >= 9 )
1982
+ goto st1;
1983
+ goto st0;
1984
+ st0:
1985
+ cs = 0;
1986
+ goto _out;
1987
+ tr2:
1988
+ #line 820 "parser.rl"
1989
+ {
1990
+ char *np = JSON_parse_value(json, p, pe, &result, 0);
1991
+ if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
1992
+ }
1993
+ goto st10;
1994
+ st10:
1995
+ if ( ++p == pe )
3079
1996
  goto _test_eof10;
3080
- st_case_10:
3081
- switch( ( (*( p))) ) {
3082
- case 13: {
3083
- goto st10;
3084
- }
3085
- case 32: {
3086
- goto st10;
3087
- }
3088
- case 47: {
3089
- goto st2;
3090
- }
3091
- }
3092
- if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
3093
- goto st10;
3094
- }
3095
- {
3096
- goto st0;
3097
- }
3098
- st2:
3099
- p+= 1;
3100
- if ( p == pe )
1997
+ case 10:
1998
+ #line 1999 "parser.c"
1999
+ switch( (*p) ) {
2000
+ case 13: goto st10;
2001
+ case 32: goto st10;
2002
+ case 47: goto st2;
2003
+ }
2004
+ if ( 9 <= (*p) && (*p) <= 10 )
2005
+ goto st10;
2006
+ goto st0;
2007
+ st2:
2008
+ if ( ++p == pe )
3101
2009
  goto _test_eof2;
3102
- st_case_2:
3103
- switch( ( (*( p))) ) {
3104
- case 42: {
3105
- goto st3;
3106
- }
3107
- case 47: {
3108
- goto st5;
3109
- }
3110
- }
3111
- {
3112
- goto st0;
3113
- }
3114
- st3:
3115
- p+= 1;
3116
- if ( p == pe )
2010
+ case 2:
2011
+ switch( (*p) ) {
2012
+ case 42: goto st3;
2013
+ case 47: goto st5;
2014
+ }
2015
+ goto st0;
2016
+ st3:
2017
+ if ( ++p == pe )
3117
2018
  goto _test_eof3;
3118
- st_case_3:
3119
- if ( ( (*( p))) == 42 ) {
3120
- goto st4;
3121
- }
3122
- {
3123
- goto st3;
3124
- }
3125
- st4:
3126
- p+= 1;
3127
- if ( p == pe )
2019
+ case 3:
2020
+ if ( (*p) == 42 )
2021
+ goto st4;
2022
+ goto st3;
2023
+ st4:
2024
+ if ( ++p == pe )
3128
2025
  goto _test_eof4;
3129
- st_case_4:
3130
- switch( ( (*( p))) ) {
3131
- case 42: {
3132
- goto st4;
3133
- }
3134
- case 47: {
3135
- goto st10;
3136
- }
3137
- }
3138
- {
3139
- goto st3;
3140
- }
3141
- st5:
3142
- p+= 1;
3143
- if ( p == pe )
2026
+ case 4:
2027
+ switch( (*p) ) {
2028
+ case 42: goto st4;
2029
+ case 47: goto st10;
2030
+ }
2031
+ goto st3;
2032
+ st5:
2033
+ if ( ++p == pe )
3144
2034
  goto _test_eof5;
3145
- st_case_5:
3146
- if ( ( (*( p))) == 10 ) {
3147
- goto st10;
3148
- }
3149
- {
3150
- goto st5;
3151
- }
3152
- st6:
3153
- p+= 1;
3154
- if ( p == pe )
2035
+ case 5:
2036
+ if ( (*p) == 10 )
2037
+ goto st10;
2038
+ goto st5;
2039
+ st6:
2040
+ if ( ++p == pe )
3155
2041
  goto _test_eof6;
3156
- st_case_6:
3157
- switch( ( (*( p))) ) {
3158
- case 42: {
3159
- goto st7;
3160
- }
3161
- case 47: {
3162
- goto st9;
3163
- }
3164
- }
3165
- {
3166
- goto st0;
3167
- }
3168
- st7:
3169
- p+= 1;
3170
- if ( p == pe )
2042
+ case 6:
2043
+ switch( (*p) ) {
2044
+ case 42: goto st7;
2045
+ case 47: goto st9;
2046
+ }
2047
+ goto st0;
2048
+ st7:
2049
+ if ( ++p == pe )
3171
2050
  goto _test_eof7;
3172
- st_case_7:
3173
- if ( ( (*( p))) == 42 ) {
3174
- goto st8;
3175
- }
3176
- {
3177
- goto st7;
3178
- }
3179
- st8:
3180
- p+= 1;
3181
- if ( p == pe )
2051
+ case 7:
2052
+ if ( (*p) == 42 )
2053
+ goto st8;
2054
+ goto st7;
2055
+ st8:
2056
+ if ( ++p == pe )
3182
2057
  goto _test_eof8;
3183
- st_case_8:
3184
- switch( ( (*( p))) ) {
3185
- case 42: {
3186
- goto st8;
3187
- }
3188
- case 47: {
3189
- goto st1;
3190
- }
3191
- }
3192
- {
3193
- goto st7;
3194
- }
3195
- st9:
3196
- p+= 1;
3197
- if ( p == pe )
2058
+ case 8:
2059
+ switch( (*p) ) {
2060
+ case 42: goto st8;
2061
+ case 47: goto st1;
2062
+ }
2063
+ goto st7;
2064
+ st9:
2065
+ if ( ++p == pe )
3198
2066
  goto _test_eof9;
3199
- st_case_9:
3200
- if ( ( (*( p))) == 10 ) {
3201
- goto st1;
3202
- }
3203
- {
3204
- goto st9;
3205
- }
3206
- st_out:
3207
- _test_eof1: cs = 1; goto _test_eof;
3208
- _test_eof10: cs = 10; goto _test_eof;
3209
- _test_eof2: cs = 2; goto _test_eof;
3210
- _test_eof3: cs = 3; goto _test_eof;
3211
- _test_eof4: cs = 4; goto _test_eof;
3212
- _test_eof5: cs = 5; goto _test_eof;
3213
- _test_eof6: cs = 6; goto _test_eof;
3214
- _test_eof7: cs = 7; goto _test_eof;
3215
- _test_eof8: cs = 8; goto _test_eof;
3216
- _test_eof9: cs = 9; goto _test_eof;
3217
-
3218
- _test_eof: {}
3219
- _out: {}
3220
- }
3221
-
3222
- #line 854 "parser.rl"
3223
-
3224
-
3225
- if (cs >= JSON_first_final && p == pe) {
3226
- return result;
3227
- } else {
3228
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
3229
- return Qnil;
2067
+ case 9:
2068
+ if ( (*p) == 10 )
2069
+ goto st1;
2070
+ goto st9;
3230
2071
  }
2072
+ _test_eof1: cs = 1; goto _test_eof;
2073
+ _test_eof10: cs = 10; goto _test_eof;
2074
+ _test_eof2: cs = 2; goto _test_eof;
2075
+ _test_eof3: cs = 3; goto _test_eof;
2076
+ _test_eof4: cs = 4; goto _test_eof;
2077
+ _test_eof5: cs = 5; goto _test_eof;
2078
+ _test_eof6: cs = 6; goto _test_eof;
2079
+ _test_eof7: cs = 7; goto _test_eof;
2080
+ _test_eof8: cs = 8; goto _test_eof;
2081
+ _test_eof9: cs = 9; goto _test_eof;
2082
+
2083
+ _test_eof: {}
2084
+ _out: {}
2085
+ }
2086
+
2087
+ #line 848 "parser.rl"
2088
+
2089
+ if (cs >= JSON_first_final && p == pe) {
2090
+ return result;
2091
+ } else {
2092
+ rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
2093
+ return Qnil;
2094
+ }
3231
2095
  }
3232
2096
 
3233
2097
  static void JSON_mark(void *ptr)
3234
2098
  {
3235
- JSON_Parser *json = ptr;
3236
- rb_gc_mark_maybe(json->Vsource);
3237
- rb_gc_mark_maybe(json->create_id);
3238
- rb_gc_mark_maybe(json->object_class);
3239
- rb_gc_mark_maybe(json->array_class);
3240
- rb_gc_mark_maybe(json->decimal_class);
3241
- rb_gc_mark_maybe(json->match_string);
2099
+ JSON_Parser *json = ptr;
2100
+ rb_gc_mark_maybe(json->Vsource);
2101
+ rb_gc_mark_maybe(json->create_id);
2102
+ rb_gc_mark_maybe(json->object_class);
2103
+ rb_gc_mark_maybe(json->array_class);
2104
+ rb_gc_mark_maybe(json->decimal_class);
2105
+ rb_gc_mark_maybe(json->match_string);
3242
2106
  }
3243
2107
 
3244
2108
  static void JSON_free(void *ptr)
3245
2109
  {
3246
- JSON_Parser *json = ptr;
3247
- fbuffer_free(json->fbuffer);
3248
- ruby_xfree(json);
2110
+ JSON_Parser *json = ptr;
2111
+ fbuffer_free(json->fbuffer);
2112
+ ruby_xfree(json);
3249
2113
  }
3250
2114
 
3251
2115
  static size_t JSON_memsize(const void *ptr)
3252
2116
  {
3253
- const JSON_Parser *json = ptr;
3254
- return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
2117
+ const JSON_Parser *json = ptr;
2118
+ return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
3255
2119
  }
3256
2120
 
3257
2121
  #ifdef NEW_TYPEDDATA_WRAPPER
3258
2122
  static const rb_data_type_t JSON_Parser_type = {
3259
- "JSON/Parser",
3260
- {JSON_mark, JSON_free, JSON_memsize,},
3261
- #ifdef RUBY_TYPED_FREE_IMMEDIATELY
3262
- 0, 0,
3263
- RUBY_TYPED_FREE_IMMEDIATELY,
3264
- #endif
2123
+ "JSON/Parser",
2124
+ {JSON_mark, JSON_free, JSON_memsize,},
2125
+ #ifdef RUBY_TYPED_FREE_IMMEDIATELY
2126
+ 0, 0,
2127
+ RUBY_TYPED_FREE_IMMEDIATELY,
2128
+ #endif
3265
2129
  };
3266
2130
  #endif
3267
2131
 
3268
2132
  static VALUE cJSON_parser_s_allocate(VALUE klass)
3269
2133
  {
3270
- JSON_Parser *json;
3271
- VALUE obj = TypedData_Make_Struct(klass, JSON_Parser, &JSON_Parser_type, json);
3272
- json->fbuffer = fbuffer_alloc(0);
3273
- return obj;
2134
+ JSON_Parser *json;
2135
+ VALUE obj = TypedData_Make_Struct(klass, JSON_Parser, &JSON_Parser_type, json);
2136
+ json->fbuffer = fbuffer_alloc(0);
2137
+ return obj;
3274
2138
  }
3275
2139
 
3276
2140
  /*
3277
- * call-seq: source()
3278
- *
3279
- * Returns a copy of the current _source_ string, that was used to construct
3280
- * this Parser.
3281
- */
2141
+ * call-seq: source()
2142
+ *
2143
+ * Returns a copy of the current _source_ string, that was used to construct
2144
+ * this Parser.
2145
+ */
3282
2146
  static VALUE cParser_source(VALUE self)
3283
2147
  {
3284
- GET_PARSER;
3285
- return rb_str_dup(json->Vsource);
2148
+ GET_PARSER;
2149
+ return rb_str_dup(json->Vsource);
3286
2150
  }
3287
2151
 
3288
2152
  void Init_parser(void)
3289
2153
  {
3290
- #ifdef HAVE_RB_EXT_RACTOR_SAFE
3291
- rb_ext_ractor_safe(true);
3292
- #endif
3293
-
3294
- #undef rb_intern
3295
- rb_require("json/common");
3296
- mJSON = rb_define_module("JSON");
3297
- mExt = rb_define_module_under(mJSON, "Ext");
3298
- cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
3299
- eParserError = rb_path2class("JSON::ParserError");
3300
- eNestingError = rb_path2class("JSON::NestingError");
3301
- rb_gc_register_mark_object(eParserError);
3302
- rb_gc_register_mark_object(eNestingError);
3303
- rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
3304
- rb_define_method(cParser, "initialize", cParser_initialize, -1);
3305
- rb_define_method(cParser, "parse", cParser_parse, 0);
3306
- rb_define_method(cParser, "source", cParser_source, 0);
3307
-
3308
- CNaN = rb_const_get(mJSON, rb_intern("NaN"));
3309
- rb_gc_register_mark_object(CNaN);
3310
-
3311
- CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
3312
- rb_gc_register_mark_object(CInfinity);
3313
-
3314
- CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
3315
- rb_gc_register_mark_object(CMinusInfinity);
3316
-
3317
- i_json_creatable_p = rb_intern("json_creatable?");
3318
- i_json_create = rb_intern("json_create");
3319
- i_create_id = rb_intern("create_id");
3320
- i_create_additions = rb_intern("create_additions");
3321
- i_chr = rb_intern("chr");
3322
- i_max_nesting = rb_intern("max_nesting");
3323
- i_allow_nan = rb_intern("allow_nan");
3324
- i_symbolize_names = rb_intern("symbolize_names");
3325
- i_object_class = rb_intern("object_class");
3326
- i_array_class = rb_intern("array_class");
3327
- i_decimal_class = rb_intern("decimal_class");
3328
- i_match = rb_intern("match");
3329
- i_match_string = rb_intern("match_string");
3330
- i_key_p = rb_intern("key?");
3331
- i_deep_const_get = rb_intern("deep_const_get");
3332
- i_aset = rb_intern("[]=");
3333
- i_aref = rb_intern("[]");
3334
- i_leftshift = rb_intern("<<");
3335
- i_new = rb_intern("new");
3336
- i_try_convert = rb_intern("try_convert");
3337
- i_freeze = rb_intern("freeze");
3338
- i_uminus = rb_intern("-@");
2154
+ #ifdef HAVE_RB_EXT_RACTOR_SAFE
2155
+ rb_ext_ractor_safe(true);
2156
+ #endif
2157
+
2158
+ #undef rb_intern
2159
+ rb_require("json/common");
2160
+ mJSON = rb_define_module("JSON");
2161
+ mExt = rb_define_module_under(mJSON, "Ext");
2162
+ cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
2163
+ eParserError = rb_path2class("JSON::ParserError");
2164
+ eNestingError = rb_path2class("JSON::NestingError");
2165
+ rb_gc_register_mark_object(eParserError);
2166
+ rb_gc_register_mark_object(eNestingError);
2167
+ rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
2168
+ rb_define_method(cParser, "initialize", cParser_initialize, -1);
2169
+ rb_define_method(cParser, "parse", cParser_parse, 0);
2170
+ rb_define_method(cParser, "source", cParser_source, 0);
2171
+
2172
+ CNaN = rb_const_get(mJSON, rb_intern("NaN"));
2173
+ rb_gc_register_mark_object(CNaN);
2174
+
2175
+ CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
2176
+ rb_gc_register_mark_object(CInfinity);
2177
+
2178
+ CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
2179
+ rb_gc_register_mark_object(CMinusInfinity);
2180
+
2181
+ i_json_creatable_p = rb_intern("json_creatable?");
2182
+ i_json_create = rb_intern("json_create");
2183
+ i_create_id = rb_intern("create_id");
2184
+ i_create_additions = rb_intern("create_additions");
2185
+ i_chr = rb_intern("chr");
2186
+ i_max_nesting = rb_intern("max_nesting");
2187
+ i_allow_nan = rb_intern("allow_nan");
2188
+ i_symbolize_names = rb_intern("symbolize_names");
2189
+ i_object_class = rb_intern("object_class");
2190
+ i_array_class = rb_intern("array_class");
2191
+ i_decimal_class = rb_intern("decimal_class");
2192
+ i_match = rb_intern("match");
2193
+ i_match_string = rb_intern("match_string");
2194
+ i_key_p = rb_intern("key?");
2195
+ i_deep_const_get = rb_intern("deep_const_get");
2196
+ i_aset = rb_intern("[]=");
2197
+ i_aref = rb_intern("[]");
2198
+ i_leftshift = rb_intern("<<");
2199
+ i_new = rb_intern("new");
2200
+ i_try_convert = rb_intern("try_convert");
2201
+ i_freeze = rb_intern("freeze");
2202
+ i_uminus = rb_intern("-@");
3339
2203
  }
3340
2204
 
3341
2205
  /*
3342
- * Local variables:
3343
- * mode: c
3344
- * c-file-style: ruby
3345
- * indent-tabs-mode: nil
3346
- * End:
3347
- */
2206
+ * Local variables:
2207
+ * mode: c
2208
+ * c-file-style: ruby
2209
+ * indent-tabs-mode: nil
2210
+ * End:
2211
+ */