json 2.5.1 → 2.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGES.md +5 -5
- data/README.md +3 -3
- data/VERSION +1 -1
- data/ext/json/ext/generator/generator.c +1 -11
- data/ext/json/ext/parser/extconf.rb +1 -0
- data/ext/json/ext/parser/parser.c +2972 -1813
- data/ext/json/ext/parser/parser.h +5 -1
- data/ext/json/ext/parser/parser.rl +66 -28
- data/json.gemspec +2 -8
- data/lib/json/pure/parser.rb +1 -1
- data/lib/json/version.rb +1 -1
- data/lib/json.rb +1 -1
- metadata +6 -87
- data/Gemfile +0 -14
- data/lib/json/ext/.keep +0 -0
- data/tests/fixtures/fail10.json +0 -1
- data/tests/fixtures/fail11.json +0 -1
- data/tests/fixtures/fail12.json +0 -1
- data/tests/fixtures/fail13.json +0 -1
- data/tests/fixtures/fail14.json +0 -1
- data/tests/fixtures/fail18.json +0 -1
- data/tests/fixtures/fail19.json +0 -1
- data/tests/fixtures/fail2.json +0 -1
- data/tests/fixtures/fail20.json +0 -1
- data/tests/fixtures/fail21.json +0 -1
- data/tests/fixtures/fail22.json +0 -1
- data/tests/fixtures/fail23.json +0 -1
- data/tests/fixtures/fail24.json +0 -1
- data/tests/fixtures/fail25.json +0 -1
- data/tests/fixtures/fail27.json +0 -2
- data/tests/fixtures/fail28.json +0 -2
- data/tests/fixtures/fail29.json +0 -1
- data/tests/fixtures/fail3.json +0 -1
- data/tests/fixtures/fail30.json +0 -1
- data/tests/fixtures/fail31.json +0 -1
- data/tests/fixtures/fail32.json +0 -1
- data/tests/fixtures/fail4.json +0 -1
- data/tests/fixtures/fail5.json +0 -1
- data/tests/fixtures/fail6.json +0 -1
- data/tests/fixtures/fail7.json +0 -1
- data/tests/fixtures/fail8.json +0 -1
- data/tests/fixtures/fail9.json +0 -1
- data/tests/fixtures/obsolete_fail1.json +0 -1
- data/tests/fixtures/pass1.json +0 -56
- data/tests/fixtures/pass15.json +0 -1
- data/tests/fixtures/pass16.json +0 -1
- data/tests/fixtures/pass17.json +0 -1
- data/tests/fixtures/pass2.json +0 -1
- data/tests/fixtures/pass26.json +0 -1
- data/tests/fixtures/pass3.json +0 -6
- data/tests/json_addition_test.rb +0 -199
- data/tests/json_common_interface_test.rb +0 -169
- data/tests/json_encoding_test.rb +0 -107
- data/tests/json_ext_parser_test.rb +0 -15
- data/tests/json_fixtures_test.rb +0 -40
- data/tests/json_generator_test.rb +0 -399
- data/tests/json_generic_object_test.rb +0 -82
- data/tests/json_parser_test.rb +0 -497
- data/tests/json_string_matching_test.rb +0 -38
- data/tests/lib/core_assertions.rb +0 -763
- data/tests/lib/envutil.rb +0 -365
- data/tests/lib/find_executable.rb +0 -22
- data/tests/lib/helper.rb +0 -4
- data/tests/ractor_test.rb +0 -30
- 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
|
-
|
13
|
-
|
12
|
+
va_list args;
|
13
|
+
VALUE mesg;
|
14
14
|
|
15
|
-
|
16
|
-
|
17
|
-
|
15
|
+
va_start(args, fmt);
|
16
|
+
mesg = rb_enc_vsprintf(enc, fmt, args);
|
17
|
+
va_end(args);
|
18
18
|
|
19
|
-
|
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
|
-
|
32
|
-
|
33
|
-
|
34
|
-
|
35
|
-
|
36
|
-
|
37
|
-
|
38
|
-
|
39
|
-
|
40
|
-
|
41
|
-
|
42
|
-
|
43
|
-
|
44
|
-
|
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
|
-
|
50
|
-
|
51
|
-
|
52
|
-
|
53
|
-
|
54
|
-
|
55
|
-
|
56
|
-
|
57
|
-
|
58
|
-
|
59
|
-
|
60
|
-
|
61
|
-
|
62
|
-
|
63
|
-
|
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
|
-
|
69
|
-
|
70
|
-
|
71
|
-
|
72
|
-
|
73
|
-
|
74
|
-
|
75
|
-
|
76
|
-
|
77
|
-
|
78
|
-
|
79
|
-
|
80
|
-
|
81
|
-
|
82
|
-
|
83
|
-
|
84
|
-
|
85
|
-
|
86
|
-
|
87
|
-
|
88
|
-
|
89
|
-
|
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
|
-
|
97
|
-
|
98
|
-
|
99
|
-
|
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
|
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
|
-
|
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
|
-
|
120
|
-
|
121
|
-
|
137
|
+
int cs = EVIL;
|
138
|
+
VALUE last_name = Qnil;
|
139
|
+
VALUE object_class = json->object_class;
|
122
140
|
|
123
|
-
|
124
|
-
|
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
|
-
|
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
|
-
|
149
|
+
cs = (int)JSON_object_start;
|
133
150
|
}
|
134
151
|
|
135
|
-
#line
|
152
|
+
#line 182 "parser.rl"
|
153
|
+
|
136
154
|
|
137
|
-
#line 139 "parser.c"
|
138
155
|
{
|
139
|
-
|
156
|
+
if ( p == pe )
|
140
157
|
goto _test_eof;
|
141
|
-
|
142
|
-
|
143
|
-
case 1:
|
144
|
-
|
145
|
-
|
146
|
-
|
147
|
-
|
148
|
-
|
149
|
-
|
150
|
-
|
151
|
-
|
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
|
-
|
154
|
-
|
155
|
-
|
156
|
-
|
157
|
-
|
158
|
-
|
159
|
-
|
160
|
-
|
161
|
-
|
162
|
-
|
163
|
-
|
164
|
-
|
165
|
-
|
166
|
-
|
167
|
-
|
168
|
-
|
169
|
-
|
170
|
-
|
171
|
-
|
172
|
-
|
173
|
-
|
174
|
-
|
175
|
-
|
176
|
-
|
177
|
-
|
178
|
-
|
179
|
-
|
180
|
-
|
181
|
-
|
182
|
-
|
183
|
-
|
184
|
-
|
185
|
-
|
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
|
-
|
188
|
-
|
189
|
-
|
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
|
-
|
192
|
-
|
193
|
-
|
194
|
-
|
195
|
-
|
196
|
-
|
197
|
-
|
198
|
-
|
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
|
-
|
201
|
-
|
202
|
-
|
203
|
-
|
204
|
-
|
205
|
-
|
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
|
-
|
208
|
-
|
209
|
-
|
210
|
-
|
211
|
-
|
212
|
-
|
213
|
-
|
214
|
-
|
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
|
-
|
217
|
-
|
218
|
-
|
219
|
-
|
220
|
-
|
221
|
-
|
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
|
-
|
224
|
-
|
225
|
-
|
226
|
-
|
227
|
-
|
228
|
-
|
229
|
-
|
230
|
-
|
231
|
-
|
232
|
-
|
233
|
-
|
234
|
-
|
235
|
-
|
236
|
-
|
237
|
-
|
238
|
-
|
239
|
-
|
240
|
-
|
241
|
-
|
242
|
-
|
243
|
-
|
244
|
-
|
245
|
-
|
246
|
-
|
247
|
-
|
248
|
-
|
249
|
-
|
250
|
-
|
251
|
-
|
252
|
-
|
253
|
-
|
254
|
-
|
255
|
-
|
256
|
-
|
257
|
-
|
258
|
-
|
259
|
-
|
260
|
-
|
261
|
-
|
262
|
-
|
263
|
-
|
264
|
-
|
265
|
-
|
266
|
-
|
267
|
-
|
268
|
-
|
269
|
-
|
270
|
-
|
271
|
-
|
272
|
-
|
273
|
-
|
274
|
-
|
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
|
-
|
277
|
-
|
278
|
-
|
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
|
-
|
281
|
-
|
282
|
-
|
283
|
-
|
284
|
-
|
285
|
-
|
286
|
-
|
287
|
-
|
288
|
-
|
289
|
-
|
290
|
-
|
291
|
-
|
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
|
-
|
294
|
-
|
295
|
-
|
296
|
-
|
297
|
-
|
298
|
-
|
299
|
-
|
300
|
-
|
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
|
-
|
303
|
-
|
304
|
-
|
305
|
-
|
306
|
-
|
307
|
-
|
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
|
-
|
310
|
-
|
311
|
-
|
312
|
-
|
313
|
-
|
314
|
-
|
315
|
-
|
316
|
-
|
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
|
-
|
319
|
-
|
320
|
-
|
321
|
-
|
322
|
-
|
323
|
-
|
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
|
-
|
326
|
-
|
327
|
-
|
328
|
-
|
329
|
-
|
330
|
-
|
331
|
-
|
332
|
-
|
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
|
-
|
335
|
-
|
336
|
-
|
337
|
-
|
338
|
-
|
339
|
-
|
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
|
-
|
342
|
-
|
343
|
-
|
344
|
-
|
345
|
-
|
346
|
-
|
347
|
-
|
348
|
-
|
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
|
-
|
351
|
-
|
352
|
-
|
353
|
-
|
354
|
-
|
355
|
-
|
356
|
-
|
357
|
-
|
358
|
-
|
359
|
-
|
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
|
-
|
362
|
-
|
363
|
-
|
364
|
-
|
365
|
-
|
594
|
+
st_case_27:
|
595
|
+
{
|
596
|
+
goto st0;
|
597
|
+
}
|
598
|
+
st19:
|
599
|
+
p+= 1;
|
600
|
+
if ( p == pe )
|
366
601
|
goto _test_eof19;
|
367
|
-
|
368
|
-
|
369
|
-
|
370
|
-
|
371
|
-
|
372
|
-
|
373
|
-
|
374
|
-
|
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
|
-
|
377
|
-
|
378
|
-
|
379
|
-
|
380
|
-
|
381
|
-
|
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
|
-
|
384
|
-
|
385
|
-
|
386
|
-
|
387
|
-
|
388
|
-
|
389
|
-
|
390
|
-
|
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
|
-
|
393
|
-
|
394
|
-
|
395
|
-
|
396
|
-
|
397
|
-
|
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
|
-
|
400
|
-
|
401
|
-
|
402
|
-
|
403
|
-
|
404
|
-
|
405
|
-
|
406
|
-
|
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
|
-
|
409
|
-
|
410
|
-
|
411
|
-
|
412
|
-
|
413
|
-
|
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
|
-
|
416
|
-
|
417
|
-
|
418
|
-
|
419
|
-
|
420
|
-
|
421
|
-
|
422
|
-
|
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
|
-
|
425
|
-
|
426
|
-
|
427
|
-
|
428
|
-
|
429
|
-
|
430
|
-
|
431
|
-
|
432
|
-
|
433
|
-
|
434
|
-
|
435
|
-
|
436
|
-
|
437
|
-
|
438
|
-
|
439
|
-
|
440
|
-
|
441
|
-
|
442
|
-
|
443
|
-
|
444
|
-
|
445
|
-
|
446
|
-
|
447
|
-
|
448
|
-
|
449
|
-
|
450
|
-
|
451
|
-
|
452
|
-
|
453
|
-
|
454
|
-
|
455
|
-
|
456
|
-
|
457
|
-
|
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
|
-
|
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
|
-
|
795
|
+
int cs = EVIL;
|
499
796
|
|
500
797
|
|
501
|
-
#line 503 "parser.c"
|
502
798
|
{
|
503
|
-
|
799
|
+
cs = (int)JSON_value_start;
|
504
800
|
}
|
505
801
|
|
506
|
-
#line
|
802
|
+
#line 290 "parser.rl"
|
803
|
+
|
507
804
|
|
508
|
-
#line 510 "parser.c"
|
509
805
|
{
|
510
|
-
|
806
|
+
if ( p == pe )
|
511
807
|
goto _test_eof;
|
512
|
-
|
513
|
-
|
514
|
-
|
515
|
-
|
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
|
-
|
518
|
-
|
519
|
-
|
520
|
-
|
521
|
-
|
522
|
-
|
523
|
-
|
524
|
-
|
525
|
-
|
526
|
-
|
527
|
-
|
528
|
-
|
529
|
-
|
530
|
-
|
531
|
-
|
532
|
-
|
533
|
-
|
534
|
-
|
535
|
-
|
536
|
-
|
537
|
-
|
538
|
-
|
539
|
-
|
540
|
-
|
541
|
-
|
542
|
-
|
543
|
-
|
544
|
-
|
545
|
-
|
546
|
-
|
547
|
-
|
548
|
-
|
549
|
-
|
550
|
-
|
551
|
-
|
552
|
-
|
553
|
-
|
554
|
-
|
555
|
-
|
556
|
-
|
557
|
-
|
558
|
-
|
559
|
-
|
560
|
-
|
561
|
-
|
562
|
-
|
563
|
-
|
564
|
-
|
565
|
-
|
566
|
-
|
567
|
-
|
568
|
-
|
569
|
-
|
570
|
-
|
571
|
-
|
572
|
-
|
573
|
-
|
574
|
-
|
575
|
-
|
576
|
-
|
577
|
-
|
578
|
-
|
579
|
-
|
580
|
-
|
581
|
-
|
582
|
-
|
583
|
-
|
584
|
-
|
585
|
-
|
586
|
-
|
587
|
-
|
588
|
-
|
589
|
-
|
590
|
-
|
591
|
-
|
592
|
-
|
593
|
-
|
594
|
-
|
595
|
-
|
596
|
-
|
597
|
-
|
598
|
-
|
599
|
-
|
600
|
-
|
601
|
-
|
602
|
-
|
603
|
-
|
604
|
-
|
605
|
-
|
606
|
-
|
607
|
-
|
608
|
-
|
609
|
-
|
610
|
-
|
611
|
-
|
612
|
-
|
613
|
-
|
614
|
-
|
615
|
-
|
616
|
-
|
617
|
-
|
618
|
-
|
619
|
-
|
620
|
-
|
621
|
-
|
622
|
-
|
623
|
-
|
624
|
-
|
625
|
-
|
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
|
-
|
637
|
-
|
638
|
-
|
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
|
-
|
641
|
-
|
642
|
-
|
643
|
-
|
644
|
-
|
645
|
-
|
646
|
-
|
647
|
-
|
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
|
-
|
650
|
-
|
651
|
-
|
652
|
-
|
653
|
-
|
654
|
-
|
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
|
-
|
657
|
-
|
658
|
-
|
659
|
-
|
660
|
-
|
661
|
-
|
662
|
-
|
663
|
-
|
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
|
-
|
666
|
-
|
667
|
-
|
668
|
-
|
669
|
-
|
670
|
-
|
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
|
-
|
673
|
-
|
674
|
-
|
675
|
-
|
676
|
-
|
677
|
-
|
678
|
-
|
679
|
-
|
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
|
-
|
682
|
-
|
683
|
-
|
684
|
-
|
685
|
-
|
686
|
-
|
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
|
-
|
689
|
-
|
690
|
-
|
691
|
-
|
692
|
-
|
693
|
-
|
694
|
-
|
695
|
-
|
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
|
-
|
698
|
-
|
699
|
-
|
700
|
-
|
701
|
-
|
702
|
-
|
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
|
-
|
705
|
-
|
706
|
-
|
707
|
-
|
708
|
-
|
709
|
-
|
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
|
-
|
712
|
-
|
713
|
-
|
714
|
-
|
715
|
-
|
716
|
-
|
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
|
-
|
719
|
-
|
720
|
-
|
721
|
-
|
722
|
-
|
723
|
-
|
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
|
-
|
726
|
-
|
727
|
-
|
728
|
-
|
729
|
-
|
730
|
-
|
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
|
-
|
733
|
-
|
734
|
-
|
735
|
-
|
736
|
-
|
737
|
-
|
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
|
-
|
740
|
-
|
741
|
-
|
742
|
-
|
743
|
-
|
744
|
-
|
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
|
-
|
747
|
-
|
748
|
-
|
749
|
-
|
750
|
-
|
751
|
-
|
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
|
-
|
754
|
-
|
755
|
-
|
756
|
-
|
757
|
-
|
758
|
-
|
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
|
-
|
761
|
-
|
762
|
-
|
763
|
-
|
764
|
-
|
765
|
-
|
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
|
-
|
768
|
-
|
769
|
-
|
770
|
-
|
771
|
-
|
772
|
-
|
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
|
-
|
775
|
-
|
776
|
-
|
777
|
-
|
778
|
-
|
779
|
-
|
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
|
-
|
782
|
-
|
783
|
-
|
784
|
-
|
785
|
-
|
786
|
-
|
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
|
-
|
789
|
-
|
790
|
-
|
791
|
-
|
792
|
-
|
793
|
-
|
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
|
-
|
796
|
-
|
797
|
-
|
798
|
-
|
799
|
-
|
800
|
-
|
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
|
-
|
803
|
-
|
804
|
-
|
805
|
-
|
806
|
-
|
807
|
-
|
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
|
-
|
810
|
-
|
811
|
-
|
812
|
-
|
813
|
-
|
814
|
-
|
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
|
-
|
817
|
-
|
818
|
-
|
819
|
-
|
820
|
-
|
821
|
-
|
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
|
-
|
824
|
-
|
825
|
-
|
826
|
-
|
827
|
-
|
828
|
-
|
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
|
-
|
831
|
-
|
832
|
-
|
833
|
-
|
834
|
-
|
835
|
-
|
836
|
-
|
837
|
-
|
838
|
-
|
839
|
-
|
840
|
-
|
841
|
-
|
842
|
-
|
843
|
-
|
844
|
-
|
845
|
-
|
846
|
-
|
847
|
-
|
848
|
-
|
849
|
-
|
850
|
-
|
851
|
-
|
852
|
-
|
853
|
-
|
854
|
-
|
855
|
-
|
856
|
-
|
857
|
-
|
858
|
-
|
859
|
-
|
860
|
-
|
861
|
-
|
862
|
-
|
863
|
-
|
864
|
-
|
865
|
-
|
866
|
-
|
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
|
-
|
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
|
-
|
1454
|
+
int cs = EVIL;
|
897
1455
|
|
898
1456
|
|
899
|
-
#line 901 "parser.c"
|
900
1457
|
{
|
901
|
-
|
1458
|
+
cs = (int)JSON_integer_start;
|
902
1459
|
}
|
903
1460
|
|
904
|
-
#line
|
905
|
-
|
1461
|
+
#line 318 "parser.rl"
|
1462
|
+
|
1463
|
+
json->memo = p;
|
906
1464
|
|
907
|
-
#line 909 "parser.c"
|
908
1465
|
{
|
909
|
-
|
1466
|
+
if ( p == pe )
|
910
1467
|
goto _test_eof;
|
911
|
-
|
912
|
-
|
913
|
-
case 1:
|
914
|
-
|
915
|
-
|
916
|
-
|
917
|
-
|
918
|
-
|
919
|
-
|
920
|
-
|
921
|
-
|
922
|
-
|
923
|
-
|
924
|
-
|
925
|
-
|
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
|
-
|
928
|
-
|
929
|
-
|
930
|
-
|
931
|
-
|
932
|
-
|
933
|
-
|
934
|
-
|
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
|
-
|
937
|
-
|
938
|
-
|
939
|
-
|
940
|
-
|
941
|
-
|
942
|
-
|
943
|
-
|
944
|
-
|
945
|
-
|
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
|
-
|
948
|
-
|
949
|
-
|
950
|
-
|
951
|
-
|
1538
|
+
st_case_4:
|
1539
|
+
{
|
1540
|
+
goto st0;
|
1541
|
+
}
|
1542
|
+
st5:
|
1543
|
+
p+= 1;
|
1544
|
+
if ( p == pe )
|
952
1545
|
goto _test_eof5;
|
953
|
-
|
954
|
-
|
955
|
-
|
956
|
-
|
957
|
-
|
958
|
-
|
959
|
-
|
960
|
-
|
961
|
-
|
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
|
-
|
964
|
-
|
1559
|
+
_test_eof: {}
|
1560
|
+
_out: {}
|
965
1561
|
}
|
966
1562
|
|
967
|
-
#line
|
968
|
-
|
969
|
-
|
970
|
-
|
971
|
-
|
972
|
-
|
973
|
-
|
974
|
-
|
975
|
-
|
976
|
-
|
977
|
-
|
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
|
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
|
-
|
1608
|
+
int cs = EVIL;
|
996
1609
|
|
997
1610
|
|
998
|
-
#line 1013 "parser.c"
|
999
1611
|
{
|
1000
|
-
|
1612
|
+
cs = (int)JSON_float_start;
|
1001
1613
|
}
|
1002
1614
|
|
1003
|
-
#line
|
1004
|
-
|
1615
|
+
#line 352 "parser.rl"
|
1616
|
+
|
1617
|
+
json->memo = p;
|
1005
1618
|
|
1006
|
-
#line 1021 "parser.c"
|
1007
1619
|
{
|
1008
|
-
|
1620
|
+
if ( p == pe )
|
1009
1621
|
goto _test_eof;
|
1010
|
-
|
1011
|
-
|
1012
|
-
case 1:
|
1013
|
-
|
1014
|
-
|
1015
|
-
|
1016
|
-
|
1017
|
-
|
1018
|
-
|
1019
|
-
|
1020
|
-
|
1021
|
-
|
1022
|
-
|
1023
|
-
|
1024
|
-
|
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
|
-
|
1027
|
-
|
1028
|
-
|
1029
|
-
|
1030
|
-
|
1031
|
-
|
1032
|
-
|
1033
|
-
|
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
|
-
|
1036
|
-
|
1037
|
-
|
1038
|
-
|
1039
|
-
|
1040
|
-
|
1041
|
-
|
1042
|
-
|
1043
|
-
|
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
|
-
|
1046
|
-
|
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
|
-
|
1061
|
-
|
1062
|
-
|
1063
|
-
|
1064
|
-
|
1065
|
-
|
1066
|
-
|
1067
|
-
|
1068
|
-
|
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
|
-
|
1071
|
-
|
1072
|
-
|
1073
|
-
|
1074
|
-
|
1744
|
+
st_case_9:
|
1745
|
+
{
|
1746
|
+
goto st0;
|
1747
|
+
}
|
1748
|
+
st5:
|
1749
|
+
p+= 1;
|
1750
|
+
if ( p == pe )
|
1075
1751
|
goto _test_eof5;
|
1076
|
-
|
1077
|
-
|
1078
|
-
|
1079
|
-
|
1080
|
-
|
1081
|
-
|
1082
|
-
|
1083
|
-
|
1084
|
-
|
1085
|
-
|
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
|
-
|
1088
|
-
|
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
|
-
|
1103
|
-
|
1104
|
-
|
1105
|
-
|
1106
|
-
|
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
|
-
|
1109
|
-
|
1110
|
-
|
1111
|
-
|
1112
|
-
|
1113
|
-
|
1114
|
-
|
1115
|
-
|
1116
|
-
|
1117
|
-
|
1118
|
-
|
1119
|
-
|
1120
|
-
|
1121
|
-
|
1122
|
-
|
1123
|
-
|
1124
|
-
|
1125
|
-
|
1126
|
-
|
1127
|
-
|
1128
|
-
|
1129
|
-
|
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
|
-
|
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
|
-
|
1197
|
-
|
1920
|
+
int cs = EVIL;
|
1921
|
+
VALUE array_class = json->array_class;
|
1198
1922
|
|
1199
|
-
|
1200
|
-
|
1201
|
-
|
1202
|
-
|
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
|
-
|
1930
|
+
cs = (int)JSON_array_start;
|
1208
1931
|
}
|
1209
1932
|
|
1210
|
-
#line
|
1933
|
+
#line 445 "parser.rl"
|
1934
|
+
|
1211
1935
|
|
1212
|
-
#line 1202 "parser.c"
|
1213
1936
|
{
|
1214
|
-
|
1937
|
+
if ( p == pe )
|
1215
1938
|
goto _test_eof;
|
1216
|
-
|
1217
|
-
|
1218
|
-
case 1:
|
1219
|
-
|
1220
|
-
|
1221
|
-
|
1222
|
-
|
1223
|
-
|
1224
|
-
|
1225
|
-
|
1226
|
-
|
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
|
-
|
1229
|
-
|
1230
|
-
|
1231
|
-
|
1232
|
-
|
1233
|
-
|
1234
|
-
|
1235
|
-
|
1236
|
-
|
1237
|
-
|
1238
|
-
|
1239
|
-
|
1240
|
-
|
1241
|
-
|
1242
|
-
|
1243
|
-
|
1244
|
-
|
1245
|
-
|
1246
|
-
|
1247
|
-
|
1248
|
-
|
1249
|
-
|
1250
|
-
|
1251
|
-
|
1252
|
-
|
1253
|
-
|
1254
|
-
|
1255
|
-
|
1256
|
-
|
1257
|
-
|
1258
|
-
|
1259
|
-
|
1260
|
-
|
1261
|
-
|
1262
|
-
|
1263
|
-
|
1264
|
-
|
1265
|
-
|
1266
|
-
|
1267
|
-
|
1268
|
-
|
1269
|
-
|
1270
|
-
|
1271
|
-
|
1272
|
-
|
1273
|
-
|
1274
|
-
|
1275
|
-
|
1276
|
-
|
1277
|
-
|
1278
|
-
|
1279
|
-
|
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
|
-
|
1282
|
-
|
1283
|
-
|
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
|
-
|
1286
|
-
|
1287
|
-
|
1288
|
-
|
1289
|
-
|
1290
|
-
|
1291
|
-
|
1292
|
-
|
1293
|
-
|
1294
|
-
|
1295
|
-
|
1296
|
-
|
1297
|
-
|
1298
|
-
|
1299
|
-
|
1300
|
-
|
1301
|
-
|
1302
|
-
|
1303
|
-
|
1304
|
-
|
1305
|
-
|
1306
|
-
|
1307
|
-
|
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
|
-
|
1310
|
-
|
1311
|
-
|
1312
|
-
|
1313
|
-
|
1314
|
-
|
1315
|
-
|
1316
|
-
|
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
|
-
|
1319
|
-
|
1320
|
-
|
1321
|
-
|
1322
|
-
|
1323
|
-
|
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
|
-
|
1326
|
-
|
1327
|
-
|
1328
|
-
|
1329
|
-
|
1330
|
-
|
1331
|
-
|
1332
|
-
|
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
|
-
|
1335
|
-
|
1336
|
-
|
1337
|
-
|
1338
|
-
|
1339
|
-
|
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
|
-
|
1342
|
-
|
1343
|
-
|
1344
|
-
|
1345
|
-
|
1346
|
-
|
1347
|
-
|
1348
|
-
|
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
|
-
|
1351
|
-
|
1352
|
-
|
1353
|
-
|
1354
|
-
|
1355
|
-
|
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
|
-
|
1358
|
-
|
1359
|
-
|
1360
|
-
|
1361
|
-
|
1362
|
-
|
1363
|
-
|
1364
|
-
|
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
|
-
|
1367
|
-
|
1368
|
-
|
1369
|
-
|
1370
|
-
|
1371
|
-
|
1372
|
-
|
1373
|
-
|
1374
|
-
|
1375
|
-
|
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
|
-
|
1378
|
-
|
1379
|
-
|
1380
|
-
|
1381
|
-
|
2265
|
+
st_case_17:
|
2266
|
+
{
|
2267
|
+
goto st0;
|
2268
|
+
}
|
2269
|
+
st13:
|
2270
|
+
p+= 1;
|
2271
|
+
if ( p == pe )
|
1382
2272
|
goto _test_eof13;
|
1383
|
-
|
1384
|
-
|
1385
|
-
|
1386
|
-
|
1387
|
-
|
1388
|
-
|
1389
|
-
|
1390
|
-
|
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
|
-
|
1393
|
-
|
1394
|
-
|
1395
|
-
|
1396
|
-
|
1397
|
-
|
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
|
-
|
1400
|
-
|
1401
|
-
|
1402
|
-
|
1403
|
-
|
1404
|
-
|
1405
|
-
|
1406
|
-
|
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
|
-
|
1409
|
-
|
1410
|
-
|
1411
|
-
|
1412
|
-
|
1413
|
-
|
1414
|
-
|
1415
|
-
|
1416
|
-
|
1417
|
-
|
1418
|
-
|
1419
|
-
|
1420
|
-
|
1421
|
-
|
1422
|
-
|
1423
|
-
|
1424
|
-
|
1425
|
-
|
1426
|
-
|
1427
|
-
|
1428
|
-
|
1429
|
-
|
1430
|
-
|
1431
|
-
|
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
|
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
|
-
|
1447
|
-
|
1448
|
-
|
1449
|
-
|
1450
|
-
|
1451
|
-
|
1452
|
-
|
1453
|
-
|
1454
|
-
|
1455
|
-
|
1456
|
-
|
1457
|
-
|
1458
|
-
|
1459
|
-
|
1460
|
-
|
1461
|
-
|
1462
|
-
|
1463
|
-
|
1464
|
-
|
1465
|
-
|
1466
|
-
|
1467
|
-
|
1468
|
-
|
1469
|
-
|
1470
|
-
|
1471
|
-
|
1472
|
-
|
1473
|
-
|
1474
|
-
|
1475
|
-
|
1476
|
-
|
1477
|
-
|
1478
|
-
|
1479
|
-
|
1480
|
-
|
1481
|
-
|
1482
|
-
|
1483
|
-
|
1484
|
-
|
1485
|
-
|
1486
|
-
|
1487
|
-
|
1488
|
-
|
1489
|
-
|
1490
|
-
|
1491
|
-
|
1492
|
-
|
1493
|
-
|
1494
|
-
|
1495
|
-
|
1496
|
-
|
1497
|
-
|
1498
|
-
|
1499
|
-
|
1500
|
-
|
1501
|
-
|
1502
|
-
|
1503
|
-
|
1504
|
-
|
1505
|
-
|
1506
|
-
|
1507
|
-
|
1508
|
-
|
1509
|
-
|
1510
|
-
|
1511
|
-
|
1512
|
-
|
1513
|
-
|
1514
|
-
|
1515
|
-
|
1516
|
-
|
1517
|
-
|
1518
|
-
|
1519
|
-
|
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
|
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
|
-
|
1538
|
-
|
1539
|
-
|
1540
|
-
|
1541
|
-
|
1542
|
-
|
1543
|
-
|
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
|
-
|
1549
|
-
|
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
|
-
|
2541
|
+
cs = (int)JSON_string_start;
|
1556
2542
|
}
|
1557
2543
|
|
1558
|
-
#line
|
1559
|
-
|
2544
|
+
#line 632 "parser.rl"
|
2545
|
+
|
2546
|
+
json->memo = p;
|
1560
2547
|
|
1561
|
-
#line 1551 "parser.c"
|
1562
2548
|
{
|
1563
|
-
|
2549
|
+
if ( p == pe )
|
1564
2550
|
goto _test_eof;
|
1565
|
-
|
1566
|
-
|
1567
|
-
case 1:
|
1568
|
-
|
1569
|
-
|
1570
|
-
|
1571
|
-
|
1572
|
-
|
1573
|
-
|
1574
|
-
|
1575
|
-
|
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
|
-
|
1578
|
-
|
1579
|
-
|
1580
|
-
|
1581
|
-
|
1582
|
-
|
1583
|
-
|
1584
|
-
|
1585
|
-
|
1586
|
-
|
1587
|
-
|
1588
|
-
|
1589
|
-
|
1590
|
-
|
1591
|
-
|
1592
|
-
|
1593
|
-
|
1594
|
-
|
1595
|
-
|
1596
|
-
|
1597
|
-
|
1598
|
-
|
1599
|
-
|
1600
|
-
|
1601
|
-
|
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
|
-
|
1604
|
-
|
1605
|
-
|
1606
|
-
|
1607
|
-
|
2625
|
+
st_case_8:
|
2626
|
+
{
|
2627
|
+
goto st0;
|
2628
|
+
}
|
2629
|
+
st3:
|
2630
|
+
p+= 1;
|
2631
|
+
if ( p == pe )
|
1608
2632
|
goto _test_eof3;
|
1609
|
-
|
1610
|
-
|
1611
|
-
|
1612
|
-
|
1613
|
-
|
1614
|
-
|
1615
|
-
|
1616
|
-
|
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
|
-
|
1619
|
-
|
1620
|
-
|
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
|
-
|
1623
|
-
|
1624
|
-
goto
|
1625
|
-
|
1626
|
-
|
1627
|
-
|
1628
|
-
|
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
|
-
|
1632
|
-
|
1633
|
-
|
1634
|
-
|
1635
|
-
|
1636
|
-
if (
|
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
|
-
|
1639
|
-
|
1640
|
-
|
1641
|
-
|
1642
|
-
|
2677
|
+
}
|
2678
|
+
{
|
2679
|
+
goto st0;
|
2680
|
+
}
|
2681
|
+
st6:
|
2682
|
+
p+= 1;
|
2683
|
+
if ( p == pe )
|
1643
2684
|
goto _test_eof6;
|
1644
|
-
|
1645
|
-
|
1646
|
-
|
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
|
-
|
1649
|
-
|
1650
|
-
goto
|
1651
|
-
|
1652
|
-
|
1653
|
-
|
1654
|
-
|
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
|
-
|
1658
|
-
|
1659
|
-
|
1660
|
-
|
1661
|
-
|
1662
|
-
if (
|
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
|
-
|
1665
|
-
|
1666
|
-
|
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
|
-
|
1722
|
-
|
1723
|
-
|
1724
|
-
|
1725
|
-
|
1726
|
-
|
1727
|
-
|
1728
|
-
|
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
|
-
|
1736
|
-
|
1737
|
-
|
1738
|
-
|
1739
|
-
|
1740
|
-
|
1741
|
-
|
1742
|
-
|
1743
|
-
|
1744
|
-
#endif
|
1745
|
-
|
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
|
-
|
1750
|
-
|
1751
|
-
|
1752
|
-
|
1753
|
-
|
1754
|
-
|
1755
|
-
|
1756
|
-
|
1757
|
-
|
1758
|
-
|
1759
|
-
|
1760
|
-
|
1761
|
-
|
1762
|
-
|
1763
|
-
|
1764
|
-
|
1765
|
-
|
1766
|
-
|
1767
|
-
|
1768
|
-
|
1769
|
-
|
1770
|
-
|
1771
|
-
|
1772
|
-
|
1773
|
-
|
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
|
-
|
1778
|
-
|
1779
|
-
|
1780
|
-
|
1781
|
-
|
1782
|
-
|
1783
|
-
#ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
|
1784
|
-
|
1785
|
-
#else
|
1786
|
-
|
1787
|
-
#endif
|
1788
|
-
|
1789
|
-
#ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
|
1790
|
-
|
1791
|
-
|
1792
|
-
|
1793
|
-
|
1794
|
-
#endif
|
1795
|
-
|
1796
|
-
|
1797
|
-
|
1798
|
-
|
1799
|
-
|
1800
|
-
|
1801
|
-
|
1802
|
-
|
1803
|
-
|
1804
|
-
|
1805
|
-
|
1806
|
-
|
1807
|
-
|
1808
|
-
|
1809
|
-
|
1810
|
-
|
1811
|
-
|
1812
|
-
|
1813
|
-
|
1814
|
-
|
1815
|
-
|
1816
|
-
|
1817
|
-
|
1818
|
-
|
1819
|
-
|
1820
|
-
|
1821
|
-
|
1822
|
-
|
1823
|
-
|
1824
|
-
|
1825
|
-
|
1826
|
-
|
1827
|
-
|
1828
|
-
|
1829
|
-
|
1830
|
-
|
1831
|
-
|
1832
|
-
|
1833
|
-
|
1834
|
-
|
1835
|
-
|
1836
|
-
|
1837
|
-
|
1838
|
-
|
1839
|
-
|
1840
|
-
|
1841
|
-
|
1842
|
-
|
1843
|
-
|
1844
|
-
|
1845
|
-
|
1846
|
-
|
1847
|
-
|
1848
|
-
|
1849
|
-
|
1850
|
-
|
1851
|
-
|
1852
|
-
|
1853
|
-
|
1854
|
-
|
1855
|
-
|
1856
|
-
|
1857
|
-
|
1858
|
-
|
1859
|
-
|
1860
|
-
|
1861
|
-
|
1862
|
-
|
1863
|
-
|
1864
|
-
|
1865
|
-
|
1866
|
-
|
1867
|
-
#ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
|
1868
|
-
|
1869
|
-
#endif
|
1870
|
-
|
1871
|
-
|
1872
|
-
|
1873
|
-
|
1874
|
-
|
1875
|
-
|
1876
|
-
|
1877
|
-
|
1878
|
-
|
1879
|
-
|
1880
|
-
|
1881
|
-
|
1882
|
-
|
1883
|
-
|
1884
|
-
|
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
|
-
|
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
|
-
|
1901
|
-
|
1902
|
-
|
1903
|
-
|
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
|
-
|
1908
|
-
|
1909
|
-
|
1910
|
-
|
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
|
-
|
2963
|
+
cs = (int)JSON_start;
|
1916
2964
|
}
|
1917
2965
|
|
1918
|
-
#line
|
1919
|
-
|
1920
|
-
|
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
|
-
|
2972
|
+
if ( p == pe )
|
1925
2973
|
goto _test_eof;
|
1926
|
-
|
1927
|
-
|
1928
|
-
|
1929
|
-
|
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
|
-
|
1932
|
-
|
1933
|
-
|
1934
|
-
|
1935
|
-
|
1936
|
-
|
1937
|
-
|
1938
|
-
|
1939
|
-
|
1940
|
-
|
1941
|
-
|
1942
|
-
|
1943
|
-
|
1944
|
-
|
1945
|
-
|
1946
|
-
|
1947
|
-
|
1948
|
-
|
1949
|
-
|
1950
|
-
|
1951
|
-
|
1952
|
-
|
1953
|
-
|
1954
|
-
|
1955
|
-
|
1956
|
-
|
1957
|
-
|
1958
|
-
|
1959
|
-
|
1960
|
-
|
1961
|
-
|
1962
|
-
|
1963
|
-
|
1964
|
-
|
1965
|
-
|
1966
|
-
|
1967
|
-
|
1968
|
-
|
1969
|
-
|
1970
|
-
|
1971
|
-
|
1972
|
-
|
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
|
-
|
1975
|
-
|
1976
|
-
|
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
|
-
|
1979
|
-
|
1980
|
-
|
1981
|
-
|
1982
|
-
|
1983
|
-
|
1984
|
-
|
1985
|
-
|
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
|
-
|
1988
|
-
|
1989
|
-
|
1990
|
-
|
1991
|
-
|
1992
|
-
|
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
|
-
|
1995
|
-
|
1996
|
-
|
1997
|
-
|
1998
|
-
|
1999
|
-
|
2000
|
-
|
2001
|
-
|
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
|
-
|
2004
|
-
|
2005
|
-
|
2006
|
-
|
2007
|
-
|
2008
|
-
|
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
|
-
|
2011
|
-
|
2012
|
-
|
2013
|
-
|
2014
|
-
|
2015
|
-
|
2016
|
-
|
2017
|
-
|
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
|
-
|
2020
|
-
|
2021
|
-
|
2022
|
-
|
2023
|
-
|
2024
|
-
|
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
|
-
|
2027
|
-
|
2028
|
-
|
2029
|
-
|
2030
|
-
|
2031
|
-
|
2032
|
-
|
2033
|
-
|
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
|
-
|
2036
|
-
|
2037
|
-
|
2038
|
-
|
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
|
-
|
2068
|
-
|
2069
|
-
|
2070
|
-
|
2071
|
-
|
2072
|
-
|
2073
|
-
|
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
|
-
|
2079
|
-
|
2080
|
-
|
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
|
-
|
2086
|
-
|
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
|
-
|
2092
|
-
|
2093
|
-
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
|
2094
|
-
|
2095
|
-
|
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
|
-
|
2103
|
-
|
2104
|
-
|
2105
|
-
|
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
|
-
|
2110
|
-
|
2111
|
-
|
2112
|
-
|
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
|
-
|
2117
|
-
|
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
|
-
|
2124
|
-
#endif
|
2125
|
-
|
2126
|
-
#undef rb_intern
|
2127
|
-
|
2128
|
-
|
2129
|
-
|
2130
|
-
|
2131
|
-
|
2132
|
-
|
2133
|
-
|
2134
|
-
|
2135
|
-
|
2136
|
-
|
2137
|
-
|
2138
|
-
|
2139
|
-
|
2140
|
-
|
2141
|
-
|
2142
|
-
|
2143
|
-
|
2144
|
-
|
2145
|
-
|
2146
|
-
|
2147
|
-
|
2148
|
-
|
2149
|
-
|
2150
|
-
|
2151
|
-
|
2152
|
-
|
2153
|
-
|
2154
|
-
|
2155
|
-
|
2156
|
-
|
2157
|
-
|
2158
|
-
|
2159
|
-
|
2160
|
-
|
2161
|
-
|
2162
|
-
|
2163
|
-
|
2164
|
-
|
2165
|
-
|
2166
|
-
|
2167
|
-
|
2168
|
-
|
2169
|
-
|
2170
|
-
|
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
|
-
|
2175
|
-
|
2176
|
-
|
2177
|
-
|
2178
|
-
|
2179
|
-
|
3333
|
+
* Local variables:
|
3334
|
+
* mode: c
|
3335
|
+
* c-file-style: ruby
|
3336
|
+
* indent-tabs-mode: nil
|
3337
|
+
* End:
|
3338
|
+
*/
|