json 2.5.1 → 2.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (66) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES.md +5 -5
  3. data/README.md +3 -3
  4. data/VERSION +1 -1
  5. data/ext/json/ext/generator/generator.c +1 -11
  6. data/ext/json/ext/parser/extconf.rb +1 -0
  7. data/ext/json/ext/parser/parser.c +2972 -1813
  8. data/ext/json/ext/parser/parser.h +5 -1
  9. data/ext/json/ext/parser/parser.rl +66 -28
  10. data/json.gemspec +2 -8
  11. data/lib/json/pure/parser.rb +1 -1
  12. data/lib/json/version.rb +1 -1
  13. data/lib/json.rb +1 -1
  14. metadata +6 -87
  15. data/Gemfile +0 -14
  16. data/lib/json/ext/.keep +0 -0
  17. data/tests/fixtures/fail10.json +0 -1
  18. data/tests/fixtures/fail11.json +0 -1
  19. data/tests/fixtures/fail12.json +0 -1
  20. data/tests/fixtures/fail13.json +0 -1
  21. data/tests/fixtures/fail14.json +0 -1
  22. data/tests/fixtures/fail18.json +0 -1
  23. data/tests/fixtures/fail19.json +0 -1
  24. data/tests/fixtures/fail2.json +0 -1
  25. data/tests/fixtures/fail20.json +0 -1
  26. data/tests/fixtures/fail21.json +0 -1
  27. data/tests/fixtures/fail22.json +0 -1
  28. data/tests/fixtures/fail23.json +0 -1
  29. data/tests/fixtures/fail24.json +0 -1
  30. data/tests/fixtures/fail25.json +0 -1
  31. data/tests/fixtures/fail27.json +0 -2
  32. data/tests/fixtures/fail28.json +0 -2
  33. data/tests/fixtures/fail29.json +0 -1
  34. data/tests/fixtures/fail3.json +0 -1
  35. data/tests/fixtures/fail30.json +0 -1
  36. data/tests/fixtures/fail31.json +0 -1
  37. data/tests/fixtures/fail32.json +0 -1
  38. data/tests/fixtures/fail4.json +0 -1
  39. data/tests/fixtures/fail5.json +0 -1
  40. data/tests/fixtures/fail6.json +0 -1
  41. data/tests/fixtures/fail7.json +0 -1
  42. data/tests/fixtures/fail8.json +0 -1
  43. data/tests/fixtures/fail9.json +0 -1
  44. data/tests/fixtures/obsolete_fail1.json +0 -1
  45. data/tests/fixtures/pass1.json +0 -56
  46. data/tests/fixtures/pass15.json +0 -1
  47. data/tests/fixtures/pass16.json +0 -1
  48. data/tests/fixtures/pass17.json +0 -1
  49. data/tests/fixtures/pass2.json +0 -1
  50. data/tests/fixtures/pass26.json +0 -1
  51. data/tests/fixtures/pass3.json +0 -6
  52. data/tests/json_addition_test.rb +0 -199
  53. data/tests/json_common_interface_test.rb +0 -169
  54. data/tests/json_encoding_test.rb +0 -107
  55. data/tests/json_ext_parser_test.rb +0 -15
  56. data/tests/json_fixtures_test.rb +0 -40
  57. data/tests/json_generator_test.rb +0 -399
  58. data/tests/json_generic_object_test.rb +0 -82
  59. data/tests/json_parser_test.rb +0 -497
  60. data/tests/json_string_matching_test.rb +0 -38
  61. data/tests/lib/core_assertions.rb +0 -763
  62. data/tests/lib/envutil.rb +0 -365
  63. data/tests/lib/find_executable.rb +0 -22
  64. data/tests/lib/helper.rb +0 -4
  65. data/tests/ractor_test.rb +0 -30
  66. data/tests/test_helper.rb +0 -17
@@ -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,2152 +28,3311 @@ 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
- #line 126 "parser.rl"
102
+ #line 125 "parser.rl"
103
103
 
104
104
 
105
105
 
106
- #line 108 "parser.c"
107
106
  enum {JSON_object_start = 1};
108
107
  enum {JSON_object_first_final = 27};
109
108
  enum {JSON_object_error = 0};
110
109
 
111
110
  enum {JSON_object_en_main = 1};
112
111
 
112
+ static const char MAYBE_UNUSED(_JSON_object_nfa_targs)[] = {
113
+ 0, 0
114
+ };
113
115
 
114
- #line 168 "parser.rl"
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
+
132
+ #line 167 "parser.rl"
115
133
 
116
134
 
117
135
  static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
118
136
  {
119
- int cs = EVIL;
120
- VALUE last_name = Qnil;
121
- VALUE object_class = json->object_class;
137
+ int cs = EVIL;
138
+ VALUE last_name = Qnil;
139
+ VALUE object_class = json->object_class;
122
140
 
123
- if (json->max_nesting && current_nesting > json->max_nesting) {
124
- rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
125
- }
141
+ if (json->max_nesting && current_nesting > json->max_nesting) {
142
+ rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
143
+ }
126
144
 
127
- *result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
145
+ *result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
128
146
 
129
147
 
130
- #line 132 "parser.c"
131
148
  {
132
- cs = JSON_object_start;
149
+ cs = (int)JSON_object_start;
133
150
  }
134
151
 
135
- #line 183 "parser.rl"
152
+ #line 182 "parser.rl"
153
+
136
154
 
137
- #line 139 "parser.c"
138
155
  {
139
- if ( p == pe )
156
+ if ( p == pe )
140
157
  goto _test_eof;
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 )
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 )
152
232
  goto _test_eof2;
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 150 "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 )
176
- goto _test_eof3;
177
- case 3:
178
- #line 180 "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 )
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
+
186
269
  goto st3;
187
- goto st0;
188
- st4:
189
- if ( ++p == pe )
270
+ st3:
271
+ p+= 1;
272
+ if ( p == pe )
273
+ 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 )
190
298
  goto _test_eof4;
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 )
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 )
199
314
  goto _test_eof5;
200
- case 5:
201
- if ( (*p) == 42 )
202
- goto st6;
203
- goto st5;
204
- st6:
205
- if ( ++p == pe )
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 )
206
325
  goto _test_eof6;
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 )
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 )
215
341
  goto _test_eof7;
216
- case 7:
217
- if ( (*p) == 10 )
218
- goto st3;
219
- goto st7;
220
- st8:
221
- if ( ++p == pe )
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 )
222
352
  goto _test_eof8;
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 134 "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 )
264
- goto _test_eof9;
265
- case 9:
266
- #line 268 "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 )
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
+
275
422
  goto st9;
276
- goto st0;
277
- st10:
278
- if ( ++p == pe )
423
+ st9:
424
+ p+= 1;
425
+ if ( p == pe )
426
+ 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 )
279
454
  goto _test_eof10;
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 )
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 )
292
479
  goto _test_eof11;
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 )
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 )
301
495
  goto _test_eof12;
302
- case 12:
303
- if ( (*p) == 42 )
304
- goto st13;
305
- goto st12;
306
- st13:
307
- if ( ++p == pe )
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 )
308
506
  goto _test_eof13;
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 )
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 )
317
522
  goto _test_eof14;
318
- case 14:
319
- if ( (*p) == 10 )
320
- goto st10;
321
- goto st14;
322
- st15:
323
- if ( ++p == pe )
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 )
324
533
  goto _test_eof15;
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 )
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 )
333
549
  goto _test_eof16;
334
- case 16:
335
- if ( (*p) == 42 )
336
- goto st17;
337
- goto st16;
338
- st17:
339
- if ( ++p == pe )
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 )
340
560
  goto _test_eof17;
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 )
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 )
349
576
  goto _test_eof18;
350
- case 18:
351
- if ( (*p) == 10 )
352
- goto st9;
353
- goto st18;
354
- tr4:
355
- #line 158 "parser.rl"
356
- { p--; {p++; cs = 27; goto _out;} }
357
- goto st27;
358
- st27:
359
- if ( ++p == pe )
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 )
360
593
  goto _test_eof27;
361
- case 27:
362
- #line 364 "parser.c"
363
- goto st0;
364
- st19:
365
- if ( ++p == pe )
594
+ st_case_27:
595
+ {
596
+ goto st0;
597
+ }
598
+ st19:
599
+ p+= 1;
600
+ if ( p == pe )
366
601
  goto _test_eof19;
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 )
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 )
375
617
  goto _test_eof20;
376
- case 20:
377
- if ( (*p) == 42 )
378
- goto st21;
379
- goto st20;
380
- st21:
381
- if ( ++p == pe )
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 )
382
628
  goto _test_eof21;
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 )
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 )
391
644
  goto _test_eof22;
392
- case 22:
393
- if ( (*p) == 10 )
394
- goto st8;
395
- goto st22;
396
- st23:
397
- if ( ++p == pe )
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 )
398
655
  goto _test_eof23;
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 )
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 )
407
671
  goto _test_eof24;
408
- case 24:
409
- if ( (*p) == 42 )
410
- goto st25;
411
- goto st24;
412
- st25:
413
- if ( ++p == pe )
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 )
414
682
  goto _test_eof25;
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 )
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 )
423
698
  goto _test_eof26;
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: {}
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;
458
759
  }
459
-
460
- #line 184 "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
- }
481
760
  }
482
761
 
483
762
 
484
763
 
485
- #line 487 "parser.c"
486
764
  enum {JSON_value_start = 1};
487
765
  enum {JSON_value_first_final = 29};
488
766
  enum {JSON_value_error = 0};
489
767
 
490
768
  enum {JSON_value_en_main = 1};
491
769
 
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
+ };
492
788
 
493
- #line 284 "parser.rl"
789
+
790
+ #line 283 "parser.rl"
494
791
 
495
792
 
496
793
  static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
497
794
  {
498
- int cs = EVIL;
795
+ int cs = EVIL;
499
796
 
500
797
 
501
- #line 503 "parser.c"
502
798
  {
503
- cs = JSON_value_start;
799
+ cs = (int)JSON_value_start;
504
800
  }
505
801
 
506
- #line 291 "parser.rl"
802
+ #line 290 "parser.rl"
803
+
507
804
 
508
- #line 510 "parser.c"
509
805
  {
510
- if ( p == pe )
806
+ if ( p == pe )
511
807
  goto _test_eof;
512
- switch ( cs )
513
- {
514
- st1:
515
- if ( ++p == pe )
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 )
516
875
  goto _test_eof1;
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 236 "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 241 "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, "%u: unexpected token at '%s'", __LINE__, 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 259 "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 265 "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 229 "parser.rl"
586
- {
587
- if (json->allow_nan) {
588
- *result = CInfinity;
589
- } else {
590
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p - 8);
591
- }
592
- }
593
- goto st29;
594
- tr27:
595
- #line 222 "parser.rl"
596
- {
597
- if (json->allow_nan) {
598
- *result = CNaN;
599
- } else {
600
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p - 2);
601
- }
602
- }
603
- goto st29;
604
- tr31:
605
- #line 216 "parser.rl"
606
- {
607
- *result = Qfalse;
608
- }
609
- goto st29;
610
- tr34:
611
- #line 213 "parser.rl"
612
- {
613
- *result = Qnil;
614
- }
615
- goto st29;
616
- tr37:
617
- #line 219 "parser.rl"
618
- {
619
- *result = Qtrue;
620
- }
621
- goto st29;
622
- st29:
623
- if ( ++p == pe )
624
- goto _test_eof29;
625
- case 29:
626
- #line 271 "parser.rl"
627
- { p--; {p++; cs = 29; goto _out;} }
628
- #line 630 "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 )
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
+
635
985
  goto st29;
636
- goto st0;
637
- st2:
638
- if ( ++p == pe )
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 )
1037
+ 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 )
639
1062
  goto _test_eof2;
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 )
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 )
648
1078
  goto _test_eof3;
649
- case 3:
650
- if ( (*p) == 42 )
651
- goto st4;
652
- goto st3;
653
- st4:
654
- if ( ++p == pe )
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 )
655
1089
  goto _test_eof4;
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 )
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 )
664
1105
  goto _test_eof5;
665
- case 5:
666
- if ( (*p) == 10 )
667
- goto st29;
668
- goto st5;
669
- st6:
670
- if ( ++p == pe )
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 )
671
1116
  goto _test_eof6;
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 )
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 )
680
1132
  goto _test_eof7;
681
- case 7:
682
- if ( (*p) == 42 )
683
- goto st8;
684
- goto st7;
685
- st8:
686
- if ( ++p == pe )
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 )
687
1143
  goto _test_eof8;
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 )
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 )
696
1159
  goto _test_eof9;
697
- case 9:
698
- if ( (*p) == 10 )
699
- goto st1;
700
- goto st9;
701
- st10:
702
- if ( ++p == pe )
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 )
703
1170
  goto _test_eof10;
704
- case 10:
705
- if ( (*p) == 110 )
706
- goto st11;
707
- goto st0;
708
- st11:
709
- if ( ++p == pe )
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 )
710
1181
  goto _test_eof11;
711
- case 11:
712
- if ( (*p) == 102 )
713
- goto st12;
714
- goto st0;
715
- st12:
716
- if ( ++p == pe )
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 )
717
1192
  goto _test_eof12;
718
- case 12:
719
- if ( (*p) == 105 )
720
- goto st13;
721
- goto st0;
722
- st13:
723
- if ( ++p == pe )
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 )
724
1203
  goto _test_eof13;
725
- case 13:
726
- if ( (*p) == 110 )
727
- goto st14;
728
- goto st0;
729
- st14:
730
- if ( ++p == pe )
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 )
731
1214
  goto _test_eof14;
732
- case 14:
733
- if ( (*p) == 105 )
734
- goto st15;
735
- goto st0;
736
- st15:
737
- if ( ++p == pe )
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 )
738
1225
  goto _test_eof15;
739
- case 15:
740
- if ( (*p) == 116 )
741
- goto st16;
742
- goto st0;
743
- st16:
744
- if ( ++p == pe )
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 )
745
1236
  goto _test_eof16;
746
- case 16:
747
- if ( (*p) == 121 )
748
- goto tr25;
749
- goto st0;
750
- st17:
751
- if ( ++p == pe )
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 )
752
1247
  goto _test_eof17;
753
- case 17:
754
- if ( (*p) == 97 )
755
- goto st18;
756
- goto st0;
757
- st18:
758
- if ( ++p == pe )
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 )
759
1258
  goto _test_eof18;
760
- case 18:
761
- if ( (*p) == 78 )
762
- goto tr27;
763
- goto st0;
764
- st19:
765
- if ( ++p == pe )
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 )
766
1269
  goto _test_eof19;
767
- case 19:
768
- if ( (*p) == 97 )
769
- goto st20;
770
- goto st0;
771
- st20:
772
- if ( ++p == pe )
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 )
773
1280
  goto _test_eof20;
774
- case 20:
775
- if ( (*p) == 108 )
776
- goto st21;
777
- goto st0;
778
- st21:
779
- if ( ++p == pe )
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 )
780
1291
  goto _test_eof21;
781
- case 21:
782
- if ( (*p) == 115 )
783
- goto st22;
784
- goto st0;
785
- st22:
786
- if ( ++p == pe )
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 )
787
1302
  goto _test_eof22;
788
- case 22:
789
- if ( (*p) == 101 )
790
- goto tr31;
791
- goto st0;
792
- st23:
793
- if ( ++p == pe )
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 )
794
1313
  goto _test_eof23;
795
- case 23:
796
- if ( (*p) == 117 )
797
- goto st24;
798
- goto st0;
799
- st24:
800
- if ( ++p == pe )
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 )
801
1324
  goto _test_eof24;
802
- case 24:
803
- if ( (*p) == 108 )
804
- goto st25;
805
- goto st0;
806
- st25:
807
- if ( ++p == pe )
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 )
808
1335
  goto _test_eof25;
809
- case 25:
810
- if ( (*p) == 108 )
811
- goto tr34;
812
- goto st0;
813
- st26:
814
- if ( ++p == pe )
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 )
815
1346
  goto _test_eof26;
816
- case 26:
817
- if ( (*p) == 114 )
818
- goto st27;
819
- goto st0;
820
- st27:
821
- if ( ++p == pe )
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 )
822
1357
  goto _test_eof27;
823
- case 27:
824
- if ( (*p) == 117 )
825
- goto st28;
826
- goto st0;
827
- st28:
828
- if ( ++p == pe )
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 )
829
1368
  goto _test_eof28;
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: {}
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;
867
1422
  }
868
-
869
- #line 292 "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
- }
880
1423
  }
881
1424
 
882
1425
 
883
- #line 885 "parser.c"
884
1426
  enum {JSON_integer_start = 1};
885
1427
  enum {JSON_integer_first_final = 3};
886
1428
  enum {JSON_integer_error = 0};
887
1429
 
888
1430
  enum {JSON_integer_en_main = 1};
889
1431
 
1432
+ static const char MAYBE_UNUSED(_JSON_integer_nfa_targs)[] = {
1433
+ 0, 0
1434
+ };
890
1435
 
891
- #line 312 "parser.rl"
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
+
1449
+ #line 311 "parser.rl"
892
1450
 
893
1451
 
894
1452
  static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
895
1453
  {
896
- int cs = EVIL;
1454
+ int cs = EVIL;
897
1455
 
898
1456
 
899
- #line 901 "parser.c"
900
1457
  {
901
- cs = JSON_integer_start;
1458
+ cs = (int)JSON_integer_start;
902
1459
  }
903
1460
 
904
- #line 319 "parser.rl"
905
- json->memo = p;
1461
+ #line 318 "parser.rl"
1462
+
1463
+ json->memo = p;
906
1464
 
907
- #line 909 "parser.c"
908
1465
  {
909
- if ( p == pe )
1466
+ if ( p == pe )
910
1467
  goto _test_eof;
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 )
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 )
926
1506
  goto _test_eof2;
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 )
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 )
935
1520
  goto _test_eof3;
936
- case 3:
937
- if ( 48 <= (*p) && (*p) <= 57 )
938
- goto st0;
939
- goto tr4;
940
- tr4:
941
- #line 309 "parser.rl"
942
- { p--; {p++; cs = 4; goto _out;} }
943
- goto st4;
944
- st4:
945
- if ( ++p == pe )
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 )
946
1537
  goto _test_eof4;
947
- case 4:
948
- #line 950 "parser.c"
949
- goto st0;
950
- st5:
951
- if ( ++p == pe )
1538
+ st_case_4:
1539
+ {
1540
+ goto st0;
1541
+ }
1542
+ st5:
1543
+ p+= 1;
1544
+ if ( p == pe )
952
1545
  goto _test_eof5;
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;
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;
962
1558
 
963
- _test_eof: {}
964
- _out: {}
1559
+ _test_eof: {}
1560
+ _out: {}
965
1561
  }
966
1562
 
967
- #line 321 "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
- }
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;
1575
+ }
979
1576
  }
980
1577
 
981
1578
 
982
- #line 984 "parser.c"
983
1579
  enum {JSON_float_start = 1};
984
1580
  enum {JSON_float_first_final = 8};
985
1581
  enum {JSON_float_error = 0};
986
1582
 
987
1583
  enum {JSON_float_en_main = 1};
988
1584
 
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
+
989
1602
 
990
- #line 346 "parser.rl"
1603
+ #line 345 "parser.rl"
991
1604
 
992
1605
 
993
1606
  static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
994
1607
  {
995
- int cs = EVIL;
1608
+ int cs = EVIL;
996
1609
 
997
1610
 
998
- #line 1013 "parser.c"
999
1611
  {
1000
- cs = JSON_float_start;
1612
+ cs = (int)JSON_float_start;
1001
1613
  }
1002
1614
 
1003
- #line 366 "parser.rl"
1004
- json->memo = p;
1615
+ #line 352 "parser.rl"
1616
+
1617
+ json->memo = p;
1005
1618
 
1006
- #line 1021 "parser.c"
1007
1619
  {
1008
- if ( p == pe )
1620
+ if ( p == pe )
1009
1621
  goto _test_eof;
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 )
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 )
1025
1670
  goto _test_eof2;
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 )
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 )
1034
1684
  goto _test_eof3;
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 )
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 )
1044
1703
  goto _test_eof4;
1045
- case 4:
1046
- if ( 48 <= (*p) && (*p) <= 57 )
1047
- goto st8;
1048
- goto st0;
1049
- st8:
1050
- if ( ++p == pe )
1051
- goto _test_eof8;
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 )
1704
+ st_case_4:
1705
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1059
1706
  goto st8;
1060
- } else if ( (*p) >= 45 )
1061
- goto st0;
1062
- goto tr9;
1063
- tr9:
1064
- #line 340 "parser.rl"
1065
- { p--; {p++; cs = 9; goto _out;} }
1066
- goto st9;
1067
- st9:
1068
- if ( ++p == pe )
1707
+ }
1708
+ {
1709
+ goto st0;
1710
+ }
1711
+ st8:
1712
+ p+= 1;
1713
+ if ( p == pe )
1714
+ 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 )
1069
1743
  goto _test_eof9;
1070
- case 9:
1071
- #line 1086 "parser.c"
1072
- goto st0;
1073
- st5:
1074
- if ( ++p == pe )
1744
+ st_case_9:
1745
+ {
1746
+ goto st0;
1747
+ }
1748
+ st5:
1749
+ p+= 1;
1750
+ if ( p == pe )
1075
1751
  goto _test_eof5;
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 )
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 )
1086
1770
  goto _test_eof6;
1087
- case 6:
1088
- if ( 48 <= (*p) && (*p) <= 57 )
1089
- goto st10;
1090
- goto st0;
1091
- st10:
1092
- if ( ++p == pe )
1093
- goto _test_eof10;
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 )
1771
+ st_case_6:
1772
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
1101
1773
  goto st10;
1102
- } else if ( (*p) >= 45 )
1103
- goto st0;
1104
- goto tr9;
1105
- st7:
1106
- if ( ++p == pe )
1774
+ }
1775
+ {
1776
+ goto st0;
1777
+ }
1778
+ st10:
1779
+ p+= 1;
1780
+ if ( p == pe )
1781
+ 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 )
1107
1804
  goto _test_eof7;
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: {}
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;
1130
1885
  }
1131
-
1132
- #line 368 "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
- }
1179
1886
  }
1180
1887
 
1181
1888
 
1182
1889
 
1183
- #line 1173 "parser.c"
1184
1890
  enum {JSON_array_start = 1};
1185
1891
  enum {JSON_array_first_final = 17};
1186
1892
  enum {JSON_array_error = 0};
1187
1893
 
1188
1894
  enum {JSON_array_en_main = 1};
1189
1895
 
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
+ };
1190
1913
 
1191
- #line 421 "parser.rl"
1914
+
1915
+ #line 432 "parser.rl"
1192
1916
 
1193
1917
 
1194
1918
  static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
1195
1919
  {
1196
- int cs = EVIL;
1197
- VALUE array_class = json->array_class;
1920
+ int cs = EVIL;
1921
+ VALUE array_class = json->array_class;
1198
1922
 
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);
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);
1203
1927
 
1204
1928
 
1205
- #line 1195 "parser.c"
1206
1929
  {
1207
- cs = JSON_array_start;
1930
+ cs = (int)JSON_array_start;
1208
1931
  }
1209
1932
 
1210
- #line 434 "parser.rl"
1933
+ #line 445 "parser.rl"
1934
+
1211
1935
 
1212
- #line 1202 "parser.c"
1213
1936
  {
1214
- if ( p == pe )
1937
+ if ( p == pe )
1215
1938
  goto _test_eof;
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 )
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 )
1227
1993
  goto _test_eof2;
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 398 "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 )
1269
- goto _test_eof3;
1270
- case 3:
1271
- #line 1261 "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 )
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
+
1280
2065
  goto st3;
1281
- goto st0;
1282
- st4:
1283
- if ( ++p == pe )
2066
+ st3:
2067
+ p+= 1;
2068
+ if ( p == pe )
2069
+ 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 )
1284
2097
  goto _test_eof4;
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 )
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 )
1308
2150
  goto _test_eof5;
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 )
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 )
1317
2166
  goto _test_eof6;
1318
- case 6:
1319
- if ( (*p) == 42 )
1320
- goto st7;
1321
- goto st6;
1322
- st7:
1323
- if ( ++p == pe )
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 )
1324
2177
  goto _test_eof7;
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 )
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 )
1333
2193
  goto _test_eof8;
1334
- case 8:
1335
- if ( (*p) == 10 )
1336
- goto st4;
1337
- goto st8;
1338
- st9:
1339
- if ( ++p == pe )
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 )
1340
2204
  goto _test_eof9;
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 )
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 )
1349
2220
  goto _test_eof10;
1350
- case 10:
1351
- if ( (*p) == 42 )
1352
- goto st11;
1353
- goto st10;
1354
- st11:
1355
- if ( ++p == pe )
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 )
1356
2231
  goto _test_eof11;
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 )
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 )
1365
2247
  goto _test_eof12;
1366
- case 12:
1367
- if ( (*p) == 10 )
1368
- goto st3;
1369
- goto st12;
1370
- tr4:
1371
- #line 413 "parser.rl"
1372
- { p--; {p++; cs = 17; goto _out;} }
1373
- goto st17;
1374
- st17:
1375
- if ( ++p == pe )
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 )
1376
2264
  goto _test_eof17;
1377
- case 17:
1378
- #line 1368 "parser.c"
1379
- goto st0;
1380
- st13:
1381
- if ( ++p == pe )
2265
+ st_case_17:
2266
+ {
2267
+ goto st0;
2268
+ }
2269
+ st13:
2270
+ p+= 1;
2271
+ if ( p == pe )
1382
2272
  goto _test_eof13;
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 )
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 )
1391
2288
  goto _test_eof14;
1392
- case 14:
1393
- if ( (*p) == 42 )
1394
- goto st15;
1395
- goto st14;
1396
- st15:
1397
- if ( ++p == pe )
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 )
1398
2299
  goto _test_eof15;
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 )
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 )
1407
2315
  goto _test_eof16;
1408
- case 16:
1409
- if ( (*p) == 10 )
1410
- goto st2;
1411
- goto st16;
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: {}
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;
1432
2353
  }
1433
-
1434
- #line 435 "parser.rl"
1435
-
1436
- if(cs >= JSON_array_first_final) {
1437
- return p + 1;
1438
- } else {
1439
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
1440
- return NULL;
1441
- }
1442
2354
  }
1443
2355
 
1444
- static VALUE json_string_unescape(VALUE result, char *string, char *stringEnd)
2356
+ static const size_t MAX_STACK_BUFFER_SIZE = 128;
2357
+ static VALUE json_string_unescape(char *string, char *stringEnd, int intern, int symbolize)
1445
2358
  {
1446
- char *p = string, *pe = string, *unescape;
1447
- int unescape_len;
1448
- char buf[4];
1449
-
1450
- while (pe < stringEnd) {
1451
- if (*pe == '\\') {
1452
- unescape = (char *) "?";
1453
- unescape_len = 1;
1454
- if (pe > p) rb_str_buf_cat(result, p, pe - p);
1455
- switch (*++pe) {
1456
- case 'n':
1457
- unescape = (char *) "\n";
1458
- break;
1459
- case 'r':
1460
- unescape = (char *) "\r";
1461
- break;
1462
- case 't':
1463
- unescape = (char *) "\t";
1464
- break;
1465
- case '"':
1466
- unescape = (char *) "\"";
1467
- break;
1468
- case '\\':
1469
- unescape = (char *) "\\";
1470
- break;
1471
- case 'b':
1472
- unescape = (char *) "\b";
1473
- break;
1474
- case 'f':
1475
- unescape = (char *) "\f";
1476
- break;
1477
- case 'u':
1478
- if (pe > stringEnd - 4) {
1479
- rb_enc_raise(
1480
- EXC_ENCODING eParserError,
1481
- "%u: incomplete unicode character escape sequence at '%s'", __LINE__, p
1482
- );
1483
- } else {
1484
- UTF32 ch = unescape_unicode((unsigned char *) ++pe);
1485
- pe += 3;
1486
- if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
1487
- pe++;
1488
- if (pe > stringEnd - 6) {
1489
- rb_enc_raise(
1490
- EXC_ENCODING eParserError,
1491
- "%u: incomplete surrogate pair at '%s'", __LINE__, p
1492
- );
1493
- }
1494
- if (pe[0] == '\\' && pe[1] == 'u') {
1495
- UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
1496
- ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
1497
- | (sur & 0x3FF));
1498
- pe += 5;
1499
- } else {
1500
- unescape = (char *) "?";
1501
- break;
1502
- }
1503
- }
1504
- unescape_len = convert_UTF32_to_UTF8(buf, ch);
1505
- unescape = buf;
1506
- }
1507
- break;
1508
- default:
1509
- p = pe;
1510
- continue;
1511
- }
1512
- rb_str_buf_cat(result, unescape, unescape_len);
1513
- p = ++pe;
1514
- } else {
1515
- pe++;
1516
- }
1517
- }
1518
- rb_str_buf_cat(result, p, pe - p);
1519
- return result;
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];
2364
+
2365
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2366
+ bufferStart = buffer = ALLOC_N(char, bufferSize);
2367
+ } else {
2368
+ bufferStart = buffer = ALLOCA_N(char, bufferSize);
2369
+ }
2370
+
2371
+ while (pe < stringEnd) {
2372
+ if (*pe == '\\') {
2373
+ unescape = (char *) "?";
2374
+ unescape_len = 1;
2375
+ if (pe > p) {
2376
+ MEMCPY(buffer, p, char, pe - p);
2377
+ buffer += pe - p;
2378
+ }
2379
+ switch (*++pe) {
2380
+ case 'n':
2381
+ unescape = (char *) "\n";
2382
+ break;
2383
+ case 'r':
2384
+ unescape = (char *) "\r";
2385
+ break;
2386
+ case 't':
2387
+ unescape = (char *) "\t";
2388
+ break;
2389
+ case '"':
2390
+ unescape = (char *) "\"";
2391
+ break;
2392
+ case '\\':
2393
+ unescape = (char *) "\\";
2394
+ break;
2395
+ case 'b':
2396
+ unescape = (char *) "\b";
2397
+ break;
2398
+ case 'f':
2399
+ unescape = (char *) "\f";
2400
+ break;
2401
+ case 'u':
2402
+ if (pe > stringEnd - 4) {
2403
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2404
+ free(bufferStart);
2405
+ }
2406
+ rb_enc_raise(
2407
+ EXC_ENCODING eParserError,
2408
+ "%u: incomplete unicode character escape sequence at '%s'", __LINE__, p
2409
+ );
2410
+ } else {
2411
+ UTF32 ch = unescape_unicode((unsigned char *) ++pe);
2412
+ pe += 3;
2413
+ if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
2414
+ pe++;
2415
+ if (pe > stringEnd - 6) {
2416
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2417
+ free(bufferStart);
2418
+ }
2419
+ rb_enc_raise(
2420
+ EXC_ENCODING eParserError,
2421
+ "%u: incomplete surrogate pair at '%s'", __LINE__, p
2422
+ );
2423
+ }
2424
+ if (pe[0] == '\\' && pe[1] == 'u') {
2425
+ UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
2426
+ ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
2427
+ | (sur & 0x3FF));
2428
+ pe += 5;
2429
+ } else {
2430
+ unescape = (char *) "?";
2431
+ break;
2432
+ }
2433
+ }
2434
+ unescape_len = convert_UTF32_to_UTF8(buf, ch);
2435
+ unescape = buf;
2436
+ }
2437
+ break;
2438
+ default:
2439
+ p = pe;
2440
+ continue;
2441
+ }
2442
+ MEMCPY(buffer, unescape, char, unescape_len);
2443
+ buffer += unescape_len;
2444
+ p = ++pe;
2445
+ } else {
2446
+ pe++;
2447
+ }
2448
+ }
2449
+
2450
+ if (pe > p) {
2451
+ MEMCPY(buffer, p, char, pe - p);
2452
+ buffer += pe - p;
2453
+ }
2454
+
2455
+ # ifdef HAVE_RB_ENC_INTERNED_STR
2456
+ if (intern) {
2457
+ result = rb_enc_interned_str(bufferStart, (long)(buffer - bufferStart), rb_utf8_encoding());
2458
+ } else {
2459
+ result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
2460
+ }
2461
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2462
+ free(bufferStart);
2463
+ }
2464
+ # else
2465
+ result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
2466
+
2467
+ if (bufferSize > MAX_STACK_BUFFER_SIZE) {
2468
+ free(bufferStart);
2469
+ }
2470
+
2471
+ if (intern) {
2472
+ # if STR_UMINUS_DEDUPE_FROZEN
2473
+ // Starting from MRI 2.8 it is preferable to freeze the string
2474
+ // before deduplication so that it can be interned directly
2475
+ // otherwise it would be duplicated first which is wasteful.
2476
+ result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
2477
+ # elif STR_UMINUS_DEDUPE
2478
+ // MRI 2.5 and older do not deduplicate strings that are already
2479
+ // frozen.
2480
+ result = rb_funcall(result, i_uminus, 0);
2481
+ # else
2482
+ result = rb_str_freeze(result);
2483
+ # endif
2484
+ }
2485
+ # endif
2486
+
2487
+ if (symbolize) {
2488
+ result = rb_str_intern(result);
2489
+ }
2490
+
2491
+ return result;
1520
2492
  }
1521
2493
 
1522
2494
 
1523
- #line 1513 "parser.c"
1524
2495
  enum {JSON_string_start = 1};
1525
2496
  enum {JSON_string_first_final = 8};
1526
2497
  enum {JSON_string_error = 0};
1527
2498
 
1528
2499
  enum {JSON_string_en_main = 1};
1529
2500
 
2501
+ static const char MAYBE_UNUSED(_JSON_string_nfa_targs)[] = {
2502
+ 0, 0
2503
+ };
2504
+
2505
+ static const char MAYBE_UNUSED(_JSON_string_nfa_offsets)[] = {
2506
+ 0, 0, 0, 0, 0, 0, 0, 0,
2507
+ 0, 0
2508
+ };
2509
+
2510
+ static const char MAYBE_UNUSED(_JSON_string_nfa_push_actions)[] = {
2511
+ 0, 0
2512
+ };
2513
+
2514
+ static const char MAYBE_UNUSED(_JSON_string_nfa_pop_trans)[] = {
2515
+ 0, 0
2516
+ };
2517
+
1530
2518
 
1531
- #line 542 "parser.rl"
2519
+ #line 612 "parser.rl"
1532
2520
 
1533
2521
 
1534
2522
  static int
1535
2523
  match_i(VALUE regexp, VALUE klass, VALUE memo)
1536
2524
  {
1537
- if (regexp == Qundef) return ST_STOP;
1538
- if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
1539
- RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
1540
- rb_ary_push(memo, klass);
1541
- return ST_STOP;
1542
- }
1543
- return ST_CONTINUE;
2525
+ if (regexp == Qundef) return ST_STOP;
2526
+ if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
2527
+ RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
2528
+ rb_ary_push(memo, klass);
2529
+ return ST_STOP;
2530
+ }
2531
+ return ST_CONTINUE;
1544
2532
  }
1545
2533
 
1546
2534
  static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
1547
2535
  {
1548
- int cs = EVIL;
1549
- VALUE match_string;
2536
+ int cs = EVIL;
2537
+ VALUE match_string;
1550
2538
 
1551
- *result = rb_str_buf_new(0);
1552
2539
 
1553
- #line 1543 "parser.c"
1554
2540
  {
1555
- cs = JSON_string_start;
2541
+ cs = (int)JSON_string_start;
1556
2542
  }
1557
2543
 
1558
- #line 563 "parser.rl"
1559
- json->memo = p;
2544
+ #line 632 "parser.rl"
2545
+
2546
+ json->memo = p;
1560
2547
 
1561
- #line 1551 "parser.c"
1562
2548
  {
1563
- if ( p == pe )
2549
+ if ( p == pe )
1564
2550
  goto _test_eof;
1565
- switch ( cs )
1566
- {
1567
- case 1:
1568
- if ( (*p) == 34 )
1569
- goto st2;
1570
- goto st0;
1571
- st0:
1572
- cs = 0;
1573
- goto _out;
1574
- st2:
1575
- if ( ++p == pe )
2551
+ switch ( cs )
2552
+ {
2553
+ case 1:
2554
+ goto st_case_1;
2555
+ case 0:
2556
+ goto st_case_0;
2557
+ case 2:
2558
+ goto st_case_2;
2559
+ case 8:
2560
+ goto st_case_8;
2561
+ case 3:
2562
+ goto st_case_3;
2563
+ case 4:
2564
+ goto st_case_4;
2565
+ case 5:
2566
+ goto st_case_5;
2567
+ case 6:
2568
+ goto st_case_6;
2569
+ case 7:
2570
+ goto st_case_7;
2571
+ }
2572
+ goto st_out;
2573
+ st_case_1:
2574
+ if ( ( (*( p))) == 34 ) {
2575
+ goto st2;
2576
+ }
2577
+ {
2578
+ goto st0;
2579
+ }
2580
+ st_case_0:
2581
+ st0:
2582
+ cs = 0;
2583
+ goto _out;
2584
+ st2:
2585
+ p+= 1;
2586
+ if ( p == pe )
1576
2587
  goto _test_eof2;
1577
- case 2:
1578
- switch( (*p) ) {
1579
- case 34: goto tr2;
1580
- case 92: goto st3;
1581
- }
1582
- if ( 0 <= (signed char)(*p) && (*p) <= 31 )
1583
- goto st0;
1584
- goto st2;
1585
- tr2:
1586
- #line 528 "parser.rl"
1587
- {
1588
- *result = json_string_unescape(*result, json->memo + 1, p);
1589
- if (NIL_P(*result)) {
1590
- p--;
1591
- {p++; cs = 8; goto _out;}
1592
- } else {
1593
- FORCE_UTF8(*result);
1594
- {p = (( p + 1))-1;}
1595
- }
1596
- }
1597
- #line 539 "parser.rl"
1598
- { p--; {p++; cs = 8; goto _out;} }
1599
- goto st8;
1600
- st8:
1601
- if ( ++p == pe )
2588
+ st_case_2:
2589
+ switch( ( (*( p))) ) {
2590
+ case 34: {
2591
+ goto ctr2;
2592
+ }
2593
+ case 92: {
2594
+ goto st3;
2595
+ }
2596
+ }
2597
+ if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
2598
+ goto st0;
2599
+ }
2600
+ {
2601
+ goto st2;
2602
+ }
2603
+ ctr2:
2604
+ {
2605
+ #line 599 "parser.rl"
2606
+
2607
+ *result = json_string_unescape(json->memo + 1, p, json->parsing_name || json-> freeze, json->parsing_name && json->symbolize_names);
2608
+ if (NIL_P(*result)) {
2609
+ {p = p - 1; }
2610
+ {p+= 1; cs = 8; goto _out;}
2611
+ } else {
2612
+ {p = (( p + 1))-1;}
2613
+
2614
+ }
2615
+ }
2616
+ {
2617
+ #line 609 "parser.rl"
2618
+ {p = p - 1; } {p+= 1; cs = 8; goto _out;} }
2619
+
2620
+ goto st8;
2621
+ st8:
2622
+ p+= 1;
2623
+ if ( p == pe )
1602
2624
  goto _test_eof8;
1603
- case 8:
1604
- #line 1594 "parser.c"
1605
- goto st0;
1606
- st3:
1607
- if ( ++p == pe )
2625
+ st_case_8:
2626
+ {
2627
+ goto st0;
2628
+ }
2629
+ st3:
2630
+ p+= 1;
2631
+ if ( p == pe )
1608
2632
  goto _test_eof3;
1609
- case 3:
1610
- if ( (*p) == 117 )
1611
- goto st4;
1612
- if ( 0 <= (signed char)(*p) && (*p) <= 31 )
1613
- goto st0;
1614
- goto st2;
1615
- st4:
1616
- if ( ++p == pe )
2633
+ st_case_3:
2634
+ if ( ( (*( p))) == 117 ) {
2635
+ goto st4;
2636
+ }
2637
+ if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
2638
+ goto st0;
2639
+ }
2640
+ {
2641
+ goto st2;
2642
+ }
2643
+ st4:
2644
+ p+= 1;
2645
+ if ( p == pe )
1617
2646
  goto _test_eof4;
1618
- case 4:
1619
- if ( (*p) < 65 ) {
1620
- if ( 48 <= (*p) && (*p) <= 57 )
2647
+ st_case_4:
2648
+ if ( ( (*( p))) < 65 ) {
2649
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2650
+ goto st5;
2651
+ }
2652
+ } else if ( ( (*( p))) > 70 ) {
2653
+ if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2654
+ goto st5;
2655
+ }
2656
+ } else {
1621
2657
  goto st5;
1622
- } else if ( (*p) > 70 ) {
1623
- if ( 97 <= (*p) && (*p) <= 102 )
1624
- goto st5;
1625
- } else
1626
- goto st5;
1627
- goto st0;
1628
- st5:
1629
- if ( ++p == pe )
2658
+ }
2659
+ {
2660
+ goto st0;
2661
+ }
2662
+ st5:
2663
+ p+= 1;
2664
+ if ( p == pe )
1630
2665
  goto _test_eof5;
1631
- case 5:
1632
- if ( (*p) < 65 ) {
1633
- if ( 48 <= (*p) && (*p) <= 57 )
1634
- goto st6;
1635
- } else if ( (*p) > 70 ) {
1636
- if ( 97 <= (*p) && (*p) <= 102 )
2666
+ st_case_5:
2667
+ if ( ( (*( p))) < 65 ) {
2668
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2669
+ goto st6;
2670
+ }
2671
+ } else if ( ( (*( p))) > 70 ) {
2672
+ if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2673
+ goto st6;
2674
+ }
2675
+ } else {
1637
2676
  goto st6;
1638
- } else
1639
- goto st6;
1640
- goto st0;
1641
- st6:
1642
- if ( ++p == pe )
2677
+ }
2678
+ {
2679
+ goto st0;
2680
+ }
2681
+ st6:
2682
+ p+= 1;
2683
+ if ( p == pe )
1643
2684
  goto _test_eof6;
1644
- case 6:
1645
- if ( (*p) < 65 ) {
1646
- if ( 48 <= (*p) && (*p) <= 57 )
2685
+ st_case_6:
2686
+ if ( ( (*( p))) < 65 ) {
2687
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2688
+ goto st7;
2689
+ }
2690
+ } else if ( ( (*( p))) > 70 ) {
2691
+ if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2692
+ goto st7;
2693
+ }
2694
+ } else {
1647
2695
  goto st7;
1648
- } else if ( (*p) > 70 ) {
1649
- if ( 97 <= (*p) && (*p) <= 102 )
1650
- goto st7;
1651
- } else
1652
- goto st7;
1653
- goto st0;
1654
- st7:
1655
- if ( ++p == pe )
2696
+ }
2697
+ {
2698
+ goto st0;
2699
+ }
2700
+ st7:
2701
+ p+= 1;
2702
+ if ( p == pe )
1656
2703
  goto _test_eof7;
1657
- case 7:
1658
- if ( (*p) < 65 ) {
1659
- if ( 48 <= (*p) && (*p) <= 57 )
1660
- goto st2;
1661
- } else if ( (*p) > 70 ) {
1662
- if ( 97 <= (*p) && (*p) <= 102 )
2704
+ st_case_7:
2705
+ if ( ( (*( p))) < 65 ) {
2706
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
2707
+ goto st2;
2708
+ }
2709
+ } else if ( ( (*( p))) > 70 ) {
2710
+ if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
2711
+ goto st2;
2712
+ }
2713
+ } else {
1663
2714
  goto st2;
1664
- } else
1665
- goto st2;
1666
- goto st0;
2715
+ }
2716
+ {
2717
+ goto st0;
2718
+ }
2719
+ st_out:
2720
+ _test_eof2: cs = 2; goto _test_eof;
2721
+ _test_eof8: cs = 8; goto _test_eof;
2722
+ _test_eof3: cs = 3; goto _test_eof;
2723
+ _test_eof4: cs = 4; goto _test_eof;
2724
+ _test_eof5: cs = 5; goto _test_eof;
2725
+ _test_eof6: cs = 6; goto _test_eof;
2726
+ _test_eof7: cs = 7; goto _test_eof;
2727
+
2728
+ _test_eof: {}
2729
+ _out: {}
2730
+ }
2731
+
2732
+ #line 634 "parser.rl"
2733
+
2734
+
2735
+ if (json->create_additions && RTEST(match_string = json->match_string)) {
2736
+ VALUE klass;
2737
+ VALUE memo = rb_ary_new2(2);
2738
+ rb_ary_push(memo, *result);
2739
+ rb_hash_foreach(match_string, match_i, memo);
2740
+ klass = rb_ary_entry(memo, 1);
2741
+ if (RTEST(klass)) {
2742
+ *result = rb_funcall(klass, i_json_create, 1, *result);
2743
+ }
2744
+ }
2745
+
2746
+ if (cs >= JSON_string_first_final) {
2747
+ return p + 1;
2748
+ } else {
2749
+ return NULL;
1667
2750
  }
1668
- _test_eof2: cs = 2; goto _test_eof;
1669
- _test_eof8: cs = 8; goto _test_eof;
1670
- _test_eof3: cs = 3; goto _test_eof;
1671
- _test_eof4: cs = 4; goto _test_eof;
1672
- _test_eof5: cs = 5; goto _test_eof;
1673
- _test_eof6: cs = 6; goto _test_eof;
1674
- _test_eof7: cs = 7; goto _test_eof;
1675
-
1676
- _test_eof: {}
1677
- _out: {}
1678
- }
1679
-
1680
- #line 565 "parser.rl"
1681
-
1682
- if (json->create_additions && RTEST(match_string = json->match_string)) {
1683
- VALUE klass;
1684
- VALUE memo = rb_ary_new2(2);
1685
- rb_ary_push(memo, *result);
1686
- rb_hash_foreach(match_string, match_i, memo);
1687
- klass = rb_ary_entry(memo, 1);
1688
- if (RTEST(klass)) {
1689
- *result = rb_funcall(klass, i_json_create, 1, *result);
1690
- }
1691
- }
1692
-
1693
- if (json->symbolize_names && json->parsing_name) {
1694
- *result = rb_str_intern(*result);
1695
- } else if (RB_TYPE_P(*result, T_STRING)) {
1696
- # if STR_UMINUS_DEDUPE_FROZEN
1697
- if (json->freeze) {
1698
- // Starting from MRI 2.8 it is preferable to freeze the string
1699
- // before deduplication so that it can be interned directly
1700
- // otherwise it would be duplicated first which is wasteful.
1701
- *result = rb_funcall(rb_str_freeze(*result), i_uminus, 0);
1702
- }
1703
- # elif STR_UMINUS_DEDUPE
1704
- if (json->freeze) {
1705
- // MRI 2.5 and older do not deduplicate strings that are already
1706
- // frozen.
1707
- *result = rb_funcall(*result, i_uminus, 0);
1708
- }
1709
- # else
1710
- rb_str_resize(*result, RSTRING_LEN(*result));
1711
- # endif
1712
- }
1713
- if (cs >= JSON_string_first_final) {
1714
- return p + 1;
1715
- } else {
1716
- return NULL;
1717
- }
1718
2751
  }
1719
2752
 
1720
2753
  /*
1721
- * Document-class: JSON::Ext::Parser
1722
- *
1723
- * This is the JSON parser implemented as a C extension. It can be configured
1724
- * to be used by setting
1725
- *
1726
- * JSON.parser = JSON::Ext::Parser
1727
- *
1728
- * with the method parser= in JSON.
1729
- *
1730
- */
2754
+ * Document-class: JSON::Ext::Parser
2755
+ *
2756
+ * This is the JSON parser implemented as a C extension. It can be configured
2757
+ * to be used by setting
2758
+ *
2759
+ * JSON.parser = JSON::Ext::Parser
2760
+ *
2761
+ * with the method parser= in JSON.
2762
+ *
2763
+ */
1731
2764
 
1732
2765
  static VALUE convert_encoding(VALUE source)
1733
2766
  {
1734
- #ifdef HAVE_RUBY_ENCODING_H
1735
- rb_encoding *enc = rb_enc_get(source);
1736
- if (enc == rb_ascii8bit_encoding()) {
1737
- if (OBJ_FROZEN(source)) {
1738
- source = rb_str_dup(source);
1739
- }
1740
- FORCE_UTF8(source);
1741
- } else {
1742
- source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
1743
- }
1744
- #endif
1745
- return source;
2767
+ #ifdef HAVE_RUBY_ENCODING_H
2768
+ rb_encoding *enc = rb_enc_get(source);
2769
+ if (enc == rb_ascii8bit_encoding()) {
2770
+ if (OBJ_FROZEN(source)) {
2771
+ source = rb_str_dup(source);
2772
+ }
2773
+ FORCE_UTF8(source);
2774
+ } else {
2775
+ source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
2776
+ }
2777
+ #endif
2778
+ return source;
1746
2779
  }
1747
2780
 
1748
2781
  /*
1749
- * call-seq: new(source, opts => {})
1750
- *
1751
- * Creates a new JSON::Ext::Parser instance for the string _source_.
1752
- *
1753
- * Creates a new JSON::Ext::Parser instance for the string _source_.
1754
- *
1755
- * It will be configured by the _opts_ hash. _opts_ can have the following
1756
- * keys:
1757
- *
1758
- * _opts_ can have the following keys:
1759
- * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
1760
- * structures. Disable depth checking with :max_nesting => false|nil|0, it
1761
- * defaults to 100.
1762
- * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
1763
- * defiance of RFC 4627 to be parsed by the Parser. This option defaults to
1764
- * false.
1765
- * * *symbolize_names*: If set to true, returns symbols for the names
1766
- * (keys) in a JSON object. Otherwise strings are returned, which is
1767
- * also the default. It's not possible to use this option in
1768
- * conjunction with the *create_additions* option.
1769
- * * *create_additions*: If set to false, the Parser doesn't create
1770
- * additions even if a matching class and create_id was found. This option
1771
- * defaults to false.
1772
- * * *object_class*: Defaults to Hash
1773
- * * *array_class*: Defaults to Array
1774
- */
2782
+ * call-seq: new(source, opts => {})
2783
+ *
2784
+ * Creates a new JSON::Ext::Parser instance for the string _source_.
2785
+ *
2786
+ * Creates a new JSON::Ext::Parser instance for the string _source_.
2787
+ *
2788
+ * It will be configured by the _opts_ hash. _opts_ can have the following
2789
+ * keys:
2790
+ *
2791
+ * _opts_ can have the following keys:
2792
+ * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
2793
+ * structures. Disable depth checking with :max_nesting => false|nil|0, it
2794
+ * defaults to 100.
2795
+ * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
2796
+ * defiance of RFC 4627 to be parsed by the Parser. This option defaults to
2797
+ * false.
2798
+ * * *symbolize_names*: If set to true, returns symbols for the names
2799
+ * (keys) in a JSON object. Otherwise strings are returned, which is
2800
+ * also the default. It's not possible to use this option in
2801
+ * conjunction with the *create_additions* option.
2802
+ * * *create_additions*: If set to false, the Parser doesn't create
2803
+ * additions even if a matching class and create_id was found. This option
2804
+ * defaults to false.
2805
+ * * *object_class*: Defaults to Hash
2806
+ * * *array_class*: Defaults to Array
2807
+ */
1775
2808
  static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
1776
2809
  {
1777
- VALUE source, opts;
1778
- GET_PARSER_INIT;
1779
-
1780
- if (json->Vsource) {
1781
- rb_raise(rb_eTypeError, "already initialized instance");
1782
- }
1783
- #ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
1784
- rb_scan_args(argc, argv, "1:", &source, &opts);
1785
- #else
1786
- rb_scan_args(argc, argv, "11", &source, &opts);
1787
- #endif
1788
- if (!NIL_P(opts)) {
1789
- #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
1790
- opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
1791
- if (NIL_P(opts)) {
1792
- rb_raise(rb_eArgError, "opts needs to be like a hash");
1793
- } else {
1794
- #endif
1795
- VALUE tmp = ID2SYM(i_max_nesting);
1796
- if (option_given_p(opts, tmp)) {
1797
- VALUE max_nesting = rb_hash_aref(opts, tmp);
1798
- if (RTEST(max_nesting)) {
1799
- Check_Type(max_nesting, T_FIXNUM);
1800
- json->max_nesting = FIX2INT(max_nesting);
1801
- } else {
1802
- json->max_nesting = 0;
1803
- }
1804
- } else {
1805
- json->max_nesting = 100;
1806
- }
1807
- tmp = ID2SYM(i_allow_nan);
1808
- if (option_given_p(opts, tmp)) {
1809
- json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1810
- } else {
1811
- json->allow_nan = 0;
1812
- }
1813
- tmp = ID2SYM(i_symbolize_names);
1814
- if (option_given_p(opts, tmp)) {
1815
- json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1816
- } else {
1817
- json->symbolize_names = 0;
1818
- }
1819
- tmp = ID2SYM(i_freeze);
1820
- if (option_given_p(opts, tmp)) {
1821
- json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1822
- } else {
1823
- json->freeze = 0;
1824
- }
1825
- tmp = ID2SYM(i_create_additions);
1826
- if (option_given_p(opts, tmp)) {
1827
- json->create_additions = RTEST(rb_hash_aref(opts, tmp));
1828
- } else {
1829
- json->create_additions = 0;
1830
- }
1831
- if (json->symbolize_names && json->create_additions) {
1832
- rb_raise(rb_eArgError,
1833
- "options :symbolize_names and :create_additions cannot be "
1834
- " used in conjunction");
1835
- }
1836
- tmp = ID2SYM(i_create_id);
1837
- if (option_given_p(opts, tmp)) {
1838
- json->create_id = rb_hash_aref(opts, tmp);
1839
- } else {
1840
- json->create_id = rb_funcall(mJSON, i_create_id, 0);
1841
- }
1842
- tmp = ID2SYM(i_object_class);
1843
- if (option_given_p(opts, tmp)) {
1844
- json->object_class = rb_hash_aref(opts, tmp);
1845
- } else {
1846
- json->object_class = Qnil;
1847
- }
1848
- tmp = ID2SYM(i_array_class);
1849
- if (option_given_p(opts, tmp)) {
1850
- json->array_class = rb_hash_aref(opts, tmp);
1851
- } else {
1852
- json->array_class = Qnil;
1853
- }
1854
- tmp = ID2SYM(i_decimal_class);
1855
- if (option_given_p(opts, tmp)) {
1856
- json->decimal_class = rb_hash_aref(opts, tmp);
1857
- } else {
1858
- json->decimal_class = Qnil;
1859
- }
1860
- tmp = ID2SYM(i_match_string);
1861
- if (option_given_p(opts, tmp)) {
1862
- VALUE match_string = rb_hash_aref(opts, tmp);
1863
- json->match_string = RTEST(match_string) ? match_string : Qnil;
1864
- } else {
1865
- json->match_string = Qnil;
1866
- }
1867
- #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
1868
- }
1869
- #endif
1870
- } else {
1871
- json->max_nesting = 100;
1872
- json->allow_nan = 0;
1873
- json->create_additions = 0;
1874
- json->create_id = rb_funcall(mJSON, i_create_id, 0);
1875
- json->object_class = Qnil;
1876
- json->array_class = Qnil;
1877
- json->decimal_class = Qnil;
1878
- }
1879
- source = convert_encoding(StringValue(source));
1880
- StringValue(source);
1881
- json->len = RSTRING_LEN(source);
1882
- json->source = RSTRING_PTR(source);;
1883
- json->Vsource = source;
1884
- return self;
2810
+ VALUE source, opts;
2811
+ GET_PARSER_INIT;
2812
+
2813
+ if (json->Vsource) {
2814
+ rb_raise(rb_eTypeError, "already initialized instance");
2815
+ }
2816
+ #ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2817
+ rb_scan_args(argc, argv, "1:", &source, &opts);
2818
+ #else
2819
+ rb_scan_args(argc, argv, "11", &source, &opts);
2820
+ #endif
2821
+ if (!NIL_P(opts)) {
2822
+ #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2823
+ opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
2824
+ if (NIL_P(opts)) {
2825
+ rb_raise(rb_eArgError, "opts needs to be like a hash");
2826
+ } else {
2827
+ #endif
2828
+ VALUE tmp = ID2SYM(i_max_nesting);
2829
+ if (option_given_p(opts, tmp)) {
2830
+ VALUE max_nesting = rb_hash_aref(opts, tmp);
2831
+ if (RTEST(max_nesting)) {
2832
+ Check_Type(max_nesting, T_FIXNUM);
2833
+ json->max_nesting = FIX2INT(max_nesting);
2834
+ } else {
2835
+ json->max_nesting = 0;
2836
+ }
2837
+ } else {
2838
+ json->max_nesting = 100;
2839
+ }
2840
+ tmp = ID2SYM(i_allow_nan);
2841
+ if (option_given_p(opts, tmp)) {
2842
+ json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2843
+ } else {
2844
+ json->allow_nan = 0;
2845
+ }
2846
+ tmp = ID2SYM(i_symbolize_names);
2847
+ if (option_given_p(opts, tmp)) {
2848
+ json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2849
+ } else {
2850
+ json->symbolize_names = 0;
2851
+ }
2852
+ tmp = ID2SYM(i_freeze);
2853
+ if (option_given_p(opts, tmp)) {
2854
+ json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
2855
+ } else {
2856
+ json->freeze = 0;
2857
+ }
2858
+ tmp = ID2SYM(i_create_additions);
2859
+ if (option_given_p(opts, tmp)) {
2860
+ json->create_additions = RTEST(rb_hash_aref(opts, tmp));
2861
+ } else {
2862
+ json->create_additions = 0;
2863
+ }
2864
+ if (json->symbolize_names && json->create_additions) {
2865
+ rb_raise(rb_eArgError,
2866
+ "options :symbolize_names and :create_additions cannot be "
2867
+ " used in conjunction");
2868
+ }
2869
+ tmp = ID2SYM(i_create_id);
2870
+ if (option_given_p(opts, tmp)) {
2871
+ json->create_id = rb_hash_aref(opts, tmp);
2872
+ } else {
2873
+ json->create_id = rb_funcall(mJSON, i_create_id, 0);
2874
+ }
2875
+ tmp = ID2SYM(i_object_class);
2876
+ if (option_given_p(opts, tmp)) {
2877
+ json->object_class = rb_hash_aref(opts, tmp);
2878
+ } else {
2879
+ json->object_class = Qnil;
2880
+ }
2881
+ tmp = ID2SYM(i_array_class);
2882
+ if (option_given_p(opts, tmp)) {
2883
+ json->array_class = rb_hash_aref(opts, tmp);
2884
+ } else {
2885
+ json->array_class = Qnil;
2886
+ }
2887
+ tmp = ID2SYM(i_decimal_class);
2888
+ if (option_given_p(opts, tmp)) {
2889
+ json->decimal_class = rb_hash_aref(opts, tmp);
2890
+ } else {
2891
+ json->decimal_class = Qnil;
2892
+ }
2893
+ tmp = ID2SYM(i_match_string);
2894
+ if (option_given_p(opts, tmp)) {
2895
+ VALUE match_string = rb_hash_aref(opts, tmp);
2896
+ json->match_string = RTEST(match_string) ? match_string : Qnil;
2897
+ } else {
2898
+ json->match_string = Qnil;
2899
+ }
2900
+ #ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
2901
+ }
2902
+ #endif
2903
+ } else {
2904
+ json->max_nesting = 100;
2905
+ json->allow_nan = 0;
2906
+ json->create_additions = 0;
2907
+ json->create_id = rb_funcall(mJSON, i_create_id, 0);
2908
+ json->object_class = Qnil;
2909
+ json->array_class = Qnil;
2910
+ json->decimal_class = Qnil;
2911
+ }
2912
+ source = convert_encoding(StringValue(source));
2913
+ StringValue(source);
2914
+ json->len = RSTRING_LEN(source);
2915
+ json->source = RSTRING_PTR(source);;
2916
+ json->Vsource = source;
2917
+ return self;
1885
2918
  }
1886
2919
 
1887
2920
 
1888
- #line 1878 "parser.c"
1889
2921
  enum {JSON_start = 1};
1890
2922
  enum {JSON_first_final = 10};
1891
2923
  enum {JSON_error = 0};
1892
2924
 
1893
2925
  enum {JSON_en_main = 1};
1894
2926
 
2927
+ static const char MAYBE_UNUSED(_JSON_nfa_targs)[] = {
2928
+ 0, 0
2929
+ };
1895
2930
 
1896
- #line 786 "parser.rl"
2931
+ static const char MAYBE_UNUSED(_JSON_nfa_offsets)[] = {
2932
+ 0, 0, 0, 0, 0, 0, 0, 0,
2933
+ 0, 0, 0, 0
2934
+ };
2935
+
2936
+ static const char MAYBE_UNUSED(_JSON_nfa_push_actions)[] = {
2937
+ 0, 0
2938
+ };
2939
+
2940
+ static const char MAYBE_UNUSED(_JSON_nfa_pop_trans)[] = {
2941
+ 0, 0
2942
+ };
2943
+
2944
+
2945
+ #line 835 "parser.rl"
1897
2946
 
1898
2947
 
1899
2948
  /*
1900
- * call-seq: parse()
1901
- *
1902
- * Parses the current JSON text _source_ and returns the complete data
1903
- * structure as a result.
1904
- */
2949
+ * call-seq: parse()
2950
+ *
2951
+ * Parses the current JSON text _source_ and returns the complete data
2952
+ * structure as a result.
2953
+ */
1905
2954
  static VALUE cParser_parse(VALUE self)
1906
2955
  {
1907
- char *p, *pe;
1908
- int cs = EVIL;
1909
- VALUE result = Qnil;
1910
- GET_PARSER;
2956
+ char *p, *pe;
2957
+ int cs = EVIL;
2958
+ VALUE result = Qnil;
2959
+ GET_PARSER;
1911
2960
 
1912
2961
 
1913
- #line 1903 "parser.c"
1914
2962
  {
1915
- cs = JSON_start;
2963
+ cs = (int)JSON_start;
1916
2964
  }
1917
2965
 
1918
- #line 802 "parser.rl"
1919
- p = json->source;
1920
- pe = p + json->len;
2966
+ #line 851 "parser.rl"
2967
+
2968
+ p = json->source;
2969
+ pe = p + json->len;
1921
2970
 
1922
- #line 1912 "parser.c"
1923
2971
  {
1924
- if ( p == pe )
2972
+ if ( p == pe )
1925
2973
  goto _test_eof;
1926
- switch ( cs )
1927
- {
1928
- st1:
1929
- if ( ++p == pe )
2974
+ switch ( cs )
2975
+ {
2976
+ case 1:
2977
+ goto st_case_1;
2978
+ case 0:
2979
+ goto st_case_0;
2980
+ case 10:
2981
+ goto st_case_10;
2982
+ case 2:
2983
+ goto st_case_2;
2984
+ case 3:
2985
+ goto st_case_3;
2986
+ case 4:
2987
+ goto st_case_4;
2988
+ case 5:
2989
+ goto st_case_5;
2990
+ case 6:
2991
+ goto st_case_6;
2992
+ case 7:
2993
+ goto st_case_7;
2994
+ case 8:
2995
+ goto st_case_8;
2996
+ case 9:
2997
+ goto st_case_9;
2998
+ }
2999
+ goto st_out;
3000
+ st1:
3001
+ p+= 1;
3002
+ if ( p == pe )
1930
3003
  goto _test_eof1;
1931
- case 1:
1932
- switch( (*p) ) {
1933
- case 13: goto st1;
1934
- case 32: goto st1;
1935
- case 34: goto tr2;
1936
- case 45: goto tr2;
1937
- case 47: goto st6;
1938
- case 73: goto tr2;
1939
- case 78: goto tr2;
1940
- case 91: goto tr2;
1941
- case 102: goto tr2;
1942
- case 110: goto tr2;
1943
- case 116: goto tr2;
1944
- case 123: goto tr2;
1945
- }
1946
- if ( (*p) > 10 ) {
1947
- if ( 48 <= (*p) && (*p) <= 57 )
1948
- goto tr2;
1949
- } else if ( (*p) >= 9 )
1950
- goto st1;
1951
- goto st0;
1952
- st0:
1953
- cs = 0;
1954
- goto _out;
1955
- tr2:
1956
- #line 778 "parser.rl"
1957
- {
1958
- char *np = JSON_parse_value(json, p, pe, &result, 0);
1959
- if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
1960
- }
1961
- goto st10;
1962
- st10:
1963
- if ( ++p == pe )
1964
- goto _test_eof10;
1965
- case 10:
1966
- #line 1956 "parser.c"
1967
- switch( (*p) ) {
1968
- case 13: goto st10;
1969
- case 32: goto st10;
1970
- case 47: goto st2;
1971
- }
1972
- if ( 9 <= (*p) && (*p) <= 10 )
3004
+ st_case_1:
3005
+ switch( ( (*( p))) ) {
3006
+ case 13: {
3007
+ goto st1;
3008
+ }
3009
+ case 32: {
3010
+ goto st1;
3011
+ }
3012
+ case 34: {
3013
+ goto ctr2;
3014
+ }
3015
+ case 45: {
3016
+ goto ctr2;
3017
+ }
3018
+ case 47: {
3019
+ goto st6;
3020
+ }
3021
+ case 73: {
3022
+ goto ctr2;
3023
+ }
3024
+ case 78: {
3025
+ goto ctr2;
3026
+ }
3027
+ case 91: {
3028
+ goto ctr2;
3029
+ }
3030
+ case 102: {
3031
+ goto ctr2;
3032
+ }
3033
+ case 110: {
3034
+ goto ctr2;
3035
+ }
3036
+ case 116: {
3037
+ goto ctr2;
3038
+ }
3039
+ case 123: {
3040
+ goto ctr2;
3041
+ }
3042
+ }
3043
+ if ( ( (*( p))) > 10 ) {
3044
+ if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
3045
+ goto ctr2;
3046
+ }
3047
+ } else if ( ( (*( p))) >= 9 ) {
3048
+ goto st1;
3049
+ }
3050
+ {
3051
+ goto st0;
3052
+ }
3053
+ st_case_0:
3054
+ st0:
3055
+ cs = 0;
3056
+ goto _out;
3057
+ ctr2:
3058
+ {
3059
+ #line 827 "parser.rl"
3060
+
3061
+ char *np = JSON_parse_value(json, p, pe, &result, 0);
3062
+ if (np == NULL) { {p = p - 1; } {p+= 1; cs = 10; goto _out;} } else {p = (( np))-1;}
3063
+
3064
+ }
3065
+
1973
3066
  goto st10;
1974
- goto st0;
1975
- st2:
1976
- if ( ++p == pe )
3067
+ st10:
3068
+ p+= 1;
3069
+ if ( p == pe )
3070
+ goto _test_eof10;
3071
+ st_case_10:
3072
+ switch( ( (*( p))) ) {
3073
+ case 13: {
3074
+ goto st10;
3075
+ }
3076
+ case 32: {
3077
+ goto st10;
3078
+ }
3079
+ case 47: {
3080
+ goto st2;
3081
+ }
3082
+ }
3083
+ if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
3084
+ goto st10;
3085
+ }
3086
+ {
3087
+ goto st0;
3088
+ }
3089
+ st2:
3090
+ p+= 1;
3091
+ if ( p == pe )
1977
3092
  goto _test_eof2;
1978
- case 2:
1979
- switch( (*p) ) {
1980
- case 42: goto st3;
1981
- case 47: goto st5;
1982
- }
1983
- goto st0;
1984
- st3:
1985
- if ( ++p == pe )
3093
+ st_case_2:
3094
+ switch( ( (*( p))) ) {
3095
+ case 42: {
3096
+ goto st3;
3097
+ }
3098
+ case 47: {
3099
+ goto st5;
3100
+ }
3101
+ }
3102
+ {
3103
+ goto st0;
3104
+ }
3105
+ st3:
3106
+ p+= 1;
3107
+ if ( p == pe )
1986
3108
  goto _test_eof3;
1987
- case 3:
1988
- if ( (*p) == 42 )
1989
- goto st4;
1990
- goto st3;
1991
- st4:
1992
- if ( ++p == pe )
3109
+ st_case_3:
3110
+ if ( ( (*( p))) == 42 ) {
3111
+ goto st4;
3112
+ }
3113
+ {
3114
+ goto st3;
3115
+ }
3116
+ st4:
3117
+ p+= 1;
3118
+ if ( p == pe )
1993
3119
  goto _test_eof4;
1994
- case 4:
1995
- switch( (*p) ) {
1996
- case 42: goto st4;
1997
- case 47: goto st10;
1998
- }
1999
- goto st3;
2000
- st5:
2001
- if ( ++p == pe )
3120
+ st_case_4:
3121
+ switch( ( (*( p))) ) {
3122
+ case 42: {
3123
+ goto st4;
3124
+ }
3125
+ case 47: {
3126
+ goto st10;
3127
+ }
3128
+ }
3129
+ {
3130
+ goto st3;
3131
+ }
3132
+ st5:
3133
+ p+= 1;
3134
+ if ( p == pe )
2002
3135
  goto _test_eof5;
2003
- case 5:
2004
- if ( (*p) == 10 )
2005
- goto st10;
2006
- goto st5;
2007
- st6:
2008
- if ( ++p == pe )
3136
+ st_case_5:
3137
+ if ( ( (*( p))) == 10 ) {
3138
+ goto st10;
3139
+ }
3140
+ {
3141
+ goto st5;
3142
+ }
3143
+ st6:
3144
+ p+= 1;
3145
+ if ( p == pe )
2009
3146
  goto _test_eof6;
2010
- case 6:
2011
- switch( (*p) ) {
2012
- case 42: goto st7;
2013
- case 47: goto st9;
2014
- }
2015
- goto st0;
2016
- st7:
2017
- if ( ++p == pe )
3147
+ st_case_6:
3148
+ switch( ( (*( p))) ) {
3149
+ case 42: {
3150
+ goto st7;
3151
+ }
3152
+ case 47: {
3153
+ goto st9;
3154
+ }
3155
+ }
3156
+ {
3157
+ goto st0;
3158
+ }
3159
+ st7:
3160
+ p+= 1;
3161
+ if ( p == pe )
2018
3162
  goto _test_eof7;
2019
- case 7:
2020
- if ( (*p) == 42 )
2021
- goto st8;
2022
- goto st7;
2023
- st8:
2024
- if ( ++p == pe )
3163
+ st_case_7:
3164
+ if ( ( (*( p))) == 42 ) {
3165
+ goto st8;
3166
+ }
3167
+ {
3168
+ goto st7;
3169
+ }
3170
+ st8:
3171
+ p+= 1;
3172
+ if ( p == pe )
2025
3173
  goto _test_eof8;
2026
- case 8:
2027
- switch( (*p) ) {
2028
- case 42: goto st8;
2029
- case 47: goto st1;
2030
- }
2031
- goto st7;
2032
- st9:
2033
- if ( ++p == pe )
3174
+ st_case_8:
3175
+ switch( ( (*( p))) ) {
3176
+ case 42: {
3177
+ goto st8;
3178
+ }
3179
+ case 47: {
3180
+ goto st1;
3181
+ }
3182
+ }
3183
+ {
3184
+ goto st7;
3185
+ }
3186
+ st9:
3187
+ p+= 1;
3188
+ if ( p == pe )
2034
3189
  goto _test_eof9;
2035
- case 9:
2036
- if ( (*p) == 10 )
2037
- goto st1;
2038
- goto st9;
3190
+ st_case_9:
3191
+ if ( ( (*( p))) == 10 ) {
3192
+ goto st1;
3193
+ }
3194
+ {
3195
+ goto st9;
3196
+ }
3197
+ st_out:
3198
+ _test_eof1: cs = 1; goto _test_eof;
3199
+ _test_eof10: cs = 10; goto _test_eof;
3200
+ _test_eof2: cs = 2; goto _test_eof;
3201
+ _test_eof3: cs = 3; goto _test_eof;
3202
+ _test_eof4: cs = 4; goto _test_eof;
3203
+ _test_eof5: cs = 5; goto _test_eof;
3204
+ _test_eof6: cs = 6; goto _test_eof;
3205
+ _test_eof7: cs = 7; goto _test_eof;
3206
+ _test_eof8: cs = 8; goto _test_eof;
3207
+ _test_eof9: cs = 9; goto _test_eof;
3208
+
3209
+ _test_eof: {}
3210
+ _out: {}
3211
+ }
3212
+
3213
+ #line 854 "parser.rl"
3214
+
3215
+
3216
+ if (cs >= JSON_first_final && p == pe) {
3217
+ return result;
3218
+ } else {
3219
+ rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
3220
+ return Qnil;
2039
3221
  }
2040
- _test_eof1: cs = 1; goto _test_eof;
2041
- _test_eof10: cs = 10; goto _test_eof;
2042
- _test_eof2: cs = 2; goto _test_eof;
2043
- _test_eof3: cs = 3; goto _test_eof;
2044
- _test_eof4: cs = 4; goto _test_eof;
2045
- _test_eof5: cs = 5; goto _test_eof;
2046
- _test_eof6: cs = 6; goto _test_eof;
2047
- _test_eof7: cs = 7; goto _test_eof;
2048
- _test_eof8: cs = 8; goto _test_eof;
2049
- _test_eof9: cs = 9; goto _test_eof;
2050
-
2051
- _test_eof: {}
2052
- _out: {}
2053
- }
2054
-
2055
- #line 805 "parser.rl"
2056
-
2057
- if (cs >= JSON_first_final && p == pe) {
2058
- return result;
2059
- } else {
2060
- rb_enc_raise(EXC_ENCODING eParserError, "%u: unexpected token at '%s'", __LINE__, p);
2061
- return Qnil;
2062
- }
2063
3222
  }
2064
3223
 
2065
3224
  static void JSON_mark(void *ptr)
2066
3225
  {
2067
- JSON_Parser *json = ptr;
2068
- rb_gc_mark_maybe(json->Vsource);
2069
- rb_gc_mark_maybe(json->create_id);
2070
- rb_gc_mark_maybe(json->object_class);
2071
- rb_gc_mark_maybe(json->array_class);
2072
- rb_gc_mark_maybe(json->decimal_class);
2073
- rb_gc_mark_maybe(json->match_string);
3226
+ JSON_Parser *json = ptr;
3227
+ rb_gc_mark_maybe(json->Vsource);
3228
+ rb_gc_mark_maybe(json->create_id);
3229
+ rb_gc_mark_maybe(json->object_class);
3230
+ rb_gc_mark_maybe(json->array_class);
3231
+ rb_gc_mark_maybe(json->decimal_class);
3232
+ rb_gc_mark_maybe(json->match_string);
2074
3233
  }
2075
3234
 
2076
3235
  static void JSON_free(void *ptr)
2077
3236
  {
2078
- JSON_Parser *json = ptr;
2079
- fbuffer_free(json->fbuffer);
2080
- ruby_xfree(json);
3237
+ JSON_Parser *json = ptr;
3238
+ fbuffer_free(json->fbuffer);
3239
+ ruby_xfree(json);
2081
3240
  }
2082
3241
 
2083
3242
  static size_t JSON_memsize(const void *ptr)
2084
3243
  {
2085
- const JSON_Parser *json = ptr;
2086
- return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
3244
+ const JSON_Parser *json = ptr;
3245
+ return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
2087
3246
  }
2088
3247
 
2089
3248
  #ifdef NEW_TYPEDDATA_WRAPPER
2090
3249
  static const rb_data_type_t JSON_Parser_type = {
2091
- "JSON/Parser",
2092
- {JSON_mark, JSON_free, JSON_memsize,},
2093
- #ifdef RUBY_TYPED_FREE_IMMEDIATELY
2094
- 0, 0,
2095
- RUBY_TYPED_FREE_IMMEDIATELY,
2096
- #endif
3250
+ "JSON/Parser",
3251
+ {JSON_mark, JSON_free, JSON_memsize,},
3252
+ #ifdef RUBY_TYPED_FREE_IMMEDIATELY
3253
+ 0, 0,
3254
+ RUBY_TYPED_FREE_IMMEDIATELY,
3255
+ #endif
2097
3256
  };
2098
3257
  #endif
2099
3258
 
2100
3259
  static VALUE cJSON_parser_s_allocate(VALUE klass)
2101
3260
  {
2102
- JSON_Parser *json;
2103
- VALUE obj = TypedData_Make_Struct(klass, JSON_Parser, &JSON_Parser_type, json);
2104
- json->fbuffer = fbuffer_alloc(0);
2105
- return obj;
3261
+ JSON_Parser *json;
3262
+ VALUE obj = TypedData_Make_Struct(klass, JSON_Parser, &JSON_Parser_type, json);
3263
+ json->fbuffer = fbuffer_alloc(0);
3264
+ return obj;
2106
3265
  }
2107
3266
 
2108
3267
  /*
2109
- * call-seq: source()
2110
- *
2111
- * Returns a copy of the current _source_ string, that was used to construct
2112
- * this Parser.
2113
- */
3268
+ * call-seq: source()
3269
+ *
3270
+ * Returns a copy of the current _source_ string, that was used to construct
3271
+ * this Parser.
3272
+ */
2114
3273
  static VALUE cParser_source(VALUE self)
2115
3274
  {
2116
- GET_PARSER;
2117
- return rb_str_dup(json->Vsource);
3275
+ GET_PARSER;
3276
+ return rb_str_dup(json->Vsource);
2118
3277
  }
2119
3278
 
2120
3279
  void Init_parser(void)
2121
3280
  {
2122
- #ifdef HAVE_RB_EXT_RACTOR_SAFE
2123
- rb_ext_ractor_safe(true);
2124
- #endif
2125
-
2126
- #undef rb_intern
2127
- rb_require("json/common");
2128
- mJSON = rb_define_module("JSON");
2129
- mExt = rb_define_module_under(mJSON, "Ext");
2130
- cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
2131
- eParserError = rb_path2class("JSON::ParserError");
2132
- eNestingError = rb_path2class("JSON::NestingError");
2133
- rb_gc_register_mark_object(eParserError);
2134
- rb_gc_register_mark_object(eNestingError);
2135
- rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
2136
- rb_define_method(cParser, "initialize", cParser_initialize, -1);
2137
- rb_define_method(cParser, "parse", cParser_parse, 0);
2138
- rb_define_method(cParser, "source", cParser_source, 0);
2139
-
2140
- CNaN = rb_const_get(mJSON, rb_intern("NaN"));
2141
- rb_gc_register_mark_object(CNaN);
2142
-
2143
- CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
2144
- rb_gc_register_mark_object(CInfinity);
2145
-
2146
- CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
2147
- rb_gc_register_mark_object(CMinusInfinity);
2148
-
2149
- i_json_creatable_p = rb_intern("json_creatable?");
2150
- i_json_create = rb_intern("json_create");
2151
- i_create_id = rb_intern("create_id");
2152
- i_create_additions = rb_intern("create_additions");
2153
- i_chr = rb_intern("chr");
2154
- i_max_nesting = rb_intern("max_nesting");
2155
- i_allow_nan = rb_intern("allow_nan");
2156
- i_symbolize_names = rb_intern("symbolize_names");
2157
- i_object_class = rb_intern("object_class");
2158
- i_array_class = rb_intern("array_class");
2159
- i_decimal_class = rb_intern("decimal_class");
2160
- i_match = rb_intern("match");
2161
- i_match_string = rb_intern("match_string");
2162
- i_key_p = rb_intern("key?");
2163
- i_deep_const_get = rb_intern("deep_const_get");
2164
- i_aset = rb_intern("[]=");
2165
- i_aref = rb_intern("[]");
2166
- i_leftshift = rb_intern("<<");
2167
- i_new = rb_intern("new");
2168
- i_try_convert = rb_intern("try_convert");
2169
- i_freeze = rb_intern("freeze");
2170
- i_uminus = rb_intern("-@");
3281
+ #ifdef HAVE_RB_EXT_RACTOR_SAFE
3282
+ rb_ext_ractor_safe(true);
3283
+ #endif
3284
+
3285
+ #undef rb_intern
3286
+ rb_require("json/common");
3287
+ mJSON = rb_define_module("JSON");
3288
+ mExt = rb_define_module_under(mJSON, "Ext");
3289
+ cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
3290
+ eParserError = rb_path2class("JSON::ParserError");
3291
+ eNestingError = rb_path2class("JSON::NestingError");
3292
+ rb_gc_register_mark_object(eParserError);
3293
+ rb_gc_register_mark_object(eNestingError);
3294
+ rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
3295
+ rb_define_method(cParser, "initialize", cParser_initialize, -1);
3296
+ rb_define_method(cParser, "parse", cParser_parse, 0);
3297
+ rb_define_method(cParser, "source", cParser_source, 0);
3298
+
3299
+ CNaN = rb_const_get(mJSON, rb_intern("NaN"));
3300
+ rb_gc_register_mark_object(CNaN);
3301
+
3302
+ CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
3303
+ rb_gc_register_mark_object(CInfinity);
3304
+
3305
+ CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
3306
+ rb_gc_register_mark_object(CMinusInfinity);
3307
+
3308
+ i_json_creatable_p = rb_intern("json_creatable?");
3309
+ i_json_create = rb_intern("json_create");
3310
+ i_create_id = rb_intern("create_id");
3311
+ i_create_additions = rb_intern("create_additions");
3312
+ i_chr = rb_intern("chr");
3313
+ i_max_nesting = rb_intern("max_nesting");
3314
+ i_allow_nan = rb_intern("allow_nan");
3315
+ i_symbolize_names = rb_intern("symbolize_names");
3316
+ i_object_class = rb_intern("object_class");
3317
+ i_array_class = rb_intern("array_class");
3318
+ i_decimal_class = rb_intern("decimal_class");
3319
+ i_match = rb_intern("match");
3320
+ i_match_string = rb_intern("match_string");
3321
+ i_key_p = rb_intern("key?");
3322
+ i_deep_const_get = rb_intern("deep_const_get");
3323
+ i_aset = rb_intern("[]=");
3324
+ i_aref = rb_intern("[]");
3325
+ i_leftshift = rb_intern("<<");
3326
+ i_new = rb_intern("new");
3327
+ i_try_convert = rb_intern("try_convert");
3328
+ i_freeze = rb_intern("freeze");
3329
+ i_uminus = rb_intern("-@");
2171
3330
  }
2172
3331
 
2173
3332
  /*
2174
- * Local variables:
2175
- * mode: c
2176
- * c-file-style: ruby
2177
- * indent-tabs-mode: nil
2178
- * End:
2179
- */
3333
+ * Local variables:
3334
+ * mode: c
3335
+ * c-file-style: ruby
3336
+ * indent-tabs-mode: nil
3337
+ * End:
3338
+ */