json 2.6.2 → 2.7.2

Sign up to get free protection for your applications and to get access to all the features.
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
+ */