json 2.5.1 → 2.6.0

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