json 2.6.3 → 2.11.3

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