Ruby 2.0.0p353(2013-11-22revision43784)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

parser.c
Go to the documentation of this file.
1
2 #line 1 "parser.rl"
3 #include "../fbuffer/fbuffer.h"
4 #include "parser.h"
5
6 /* unicode */
7
8 static const char digit_values[256] = {
9 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
10 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
11 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
12 -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
13 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
14 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
15 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
16 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
17 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
18 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
19 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
20 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
21 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
22 -1, -1, -1, -1, -1, -1, -1
23 };
24
25 static UTF32 unescape_unicode(const unsigned char *p)
26 {
27 char b;
28 UTF32 result = 0;
29 b = digit_values[p[0]];
30 if (b < 0) return UNI_REPLACEMENT_CHAR;
31 result = (result << 4) | b;
32 b = digit_values[p[1]];
33 result = (result << 4) | b;
34 if (b < 0) return UNI_REPLACEMENT_CHAR;
35 b = digit_values[p[2]];
36 result = (result << 4) | b;
37 if (b < 0) return UNI_REPLACEMENT_CHAR;
38 b = digit_values[p[3]];
39 result = (result << 4) | b;
40 if (b < 0) return UNI_REPLACEMENT_CHAR;
41 return result;
42 }
43
44 static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
45 {
46 int len = 1;
47 if (ch <= 0x7F) {
48 buf[0] = (char) ch;
49 } else if (ch <= 0x07FF) {
50 buf[0] = (char) ((ch >> 6) | 0xC0);
51 buf[1] = (char) ((ch & 0x3F) | 0x80);
52 len++;
53 } else if (ch <= 0xFFFF) {
54 buf[0] = (char) ((ch >> 12) | 0xE0);
55 buf[1] = (char) (((ch >> 6) & 0x3F) | 0x80);
56 buf[2] = (char) ((ch & 0x3F) | 0x80);
57 len += 2;
58 } else if (ch <= 0x1fffff) {
59 buf[0] =(char) ((ch >> 18) | 0xF0);
60 buf[1] =(char) (((ch >> 12) & 0x3F) | 0x80);
61 buf[2] =(char) (((ch >> 6) & 0x3F) | 0x80);
62 buf[3] =(char) ((ch & 0x3F) | 0x80);
63 len += 3;
64 } else {
65 buf[0] = '?';
66 }
67 return len;
68 }
69
70 #ifdef HAVE_RUBY_ENCODING_H
71 static VALUE CEncoding_ASCII_8BIT, CEncoding_UTF_8, CEncoding_UTF_16BE,
72 CEncoding_UTF_16LE, CEncoding_UTF_32BE, CEncoding_UTF_32LE;
73 static ID i_encoding, i_encode;
74 #else
75 static ID i_iconv;
76 #endif
77
78 static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
79 static VALUE CNaN, CInfinity, CMinusInfinity;
80
81 static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
82 i_chr, i_max_nesting, i_allow_nan, i_symbolize_names, i_quirks_mode,
83 i_object_class, i_array_class, i_key_p, i_deep_const_get, i_match,
84 i_match_string, i_aset, i_aref, i_leftshift;
85
86
87 #line 110 "parser.rl"
88
89
90
91 #line 92 "parser.c"
92 static const int JSON_object_start = 1;
93 static const int JSON_object_first_final = 27;
94 static const int JSON_object_error = 0;
95
96 static const int JSON_object_en_main = 1;
97
98
99 #line 151 "parser.rl"
100
101
102 static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result)
103 {
104 int cs = EVIL;
105 VALUE last_name = Qnil;
106 VALUE object_class = json->object_class;
107
108 if (json->max_nesting && json->current_nesting > json->max_nesting) {
109 rb_raise(eNestingError, "nesting of %d is too deep", json->current_nesting);
110 }
111
112 *result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
113
114
115 #line 116 "parser.c"
116 {
117 cs = JSON_object_start;
118 }
119
120 #line 166 "parser.rl"
121
122 #line 123 "parser.c"
123 {
124 if ( p == pe )
125 goto _test_eof;
126 switch ( cs )
127 {
128 case 1:
129 if ( (*p) == 123 )
130 goto st2;
131 goto st0;
132 st0:
133 cs = 0;
134 goto _out;
135 st2:
136 if ( ++p == pe )
137 goto _test_eof2;
138 case 2:
139 switch( (*p) ) {
140 case 13: goto st2;
141 case 32: goto st2;
142 case 34: goto tr2;
143 case 47: goto st23;
144 case 125: goto tr4;
145 }
146 if ( 9 <= (*p) && (*p) <= 10 )
147 goto st2;
148 goto st0;
149 tr2:
150 #line 133 "parser.rl"
151 {
152 char *np;
153 json->parsing_name = 1;
154 np = JSON_parse_string(json, p, pe, &last_name);
155 json->parsing_name = 0;
156 if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
157 }
158 goto st3;
159 st3:
160 if ( ++p == pe )
161 goto _test_eof3;
162 case 3:
163 #line 164 "parser.c"
164 switch( (*p) ) {
165 case 13: goto st3;
166 case 32: goto st3;
167 case 47: goto st4;
168 case 58: goto st8;
169 }
170 if ( 9 <= (*p) && (*p) <= 10 )
171 goto st3;
172 goto st0;
173 st4:
174 if ( ++p == pe )
175 goto _test_eof4;
176 case 4:
177 switch( (*p) ) {
178 case 42: goto st5;
179 case 47: goto st7;
180 }
181 goto st0;
182 st5:
183 if ( ++p == pe )
184 goto _test_eof5;
185 case 5:
186 if ( (*p) == 42 )
187 goto st6;
188 goto st5;
189 st6:
190 if ( ++p == pe )
191 goto _test_eof6;
192 case 6:
193 switch( (*p) ) {
194 case 42: goto st6;
195 case 47: goto st3;
196 }
197 goto st5;
198 st7:
199 if ( ++p == pe )
200 goto _test_eof7;
201 case 7:
202 if ( (*p) == 10 )
203 goto st3;
204 goto st7;
205 st8:
206 if ( ++p == pe )
207 goto _test_eof8;
208 case 8:
209 switch( (*p) ) {
210 case 13: goto st8;
211 case 32: goto st8;
212 case 34: goto tr11;
213 case 45: goto tr11;
214 case 47: goto st19;
215 case 73: goto tr11;
216 case 78: goto tr11;
217 case 91: goto tr11;
218 case 102: goto tr11;
219 case 110: goto tr11;
220 case 116: goto tr11;
221 case 123: goto tr11;
222 }
223 if ( (*p) > 10 ) {
224 if ( 48 <= (*p) && (*p) <= 57 )
225 goto tr11;
226 } else if ( (*p) >= 9 )
227 goto st8;
228 goto st0;
229 tr11:
230 #line 118 "parser.rl"
231 {
232 VALUE v = Qnil;
233 char *np = JSON_parse_value(json, p, pe, &v);
234 if (np == NULL) {
235 p--; {p++; cs = 9; goto _out;}
236 } else {
237 if (NIL_P(json->object_class)) {
238 rb_hash_aset(*result, last_name, v);
239 } else {
240 rb_funcall(*result, i_aset, 2, last_name, v);
241 }
242 {p = (( np))-1;}
243 }
244 }
245 goto st9;
246 st9:
247 if ( ++p == pe )
248 goto _test_eof9;
249 case 9:
250 #line 251 "parser.c"
251 switch( (*p) ) {
252 case 13: goto st9;
253 case 32: goto st9;
254 case 44: goto st10;
255 case 47: goto st15;
256 case 125: goto tr4;
257 }
258 if ( 9 <= (*p) && (*p) <= 10 )
259 goto st9;
260 goto st0;
261 st10:
262 if ( ++p == pe )
263 goto _test_eof10;
264 case 10:
265 switch( (*p) ) {
266 case 13: goto st10;
267 case 32: goto st10;
268 case 34: goto tr2;
269 case 47: goto st11;
270 }
271 if ( 9 <= (*p) && (*p) <= 10 )
272 goto st10;
273 goto st0;
274 st11:
275 if ( ++p == pe )
276 goto _test_eof11;
277 case 11:
278 switch( (*p) ) {
279 case 42: goto st12;
280 case 47: goto st14;
281 }
282 goto st0;
283 st12:
284 if ( ++p == pe )
285 goto _test_eof12;
286 case 12:
287 if ( (*p) == 42 )
288 goto st13;
289 goto st12;
290 st13:
291 if ( ++p == pe )
292 goto _test_eof13;
293 case 13:
294 switch( (*p) ) {
295 case 42: goto st13;
296 case 47: goto st10;
297 }
298 goto st12;
299 st14:
300 if ( ++p == pe )
301 goto _test_eof14;
302 case 14:
303 if ( (*p) == 10 )
304 goto st10;
305 goto st14;
306 st15:
307 if ( ++p == pe )
308 goto _test_eof15;
309 case 15:
310 switch( (*p) ) {
311 case 42: goto st16;
312 case 47: goto st18;
313 }
314 goto st0;
315 st16:
316 if ( ++p == pe )
317 goto _test_eof16;
318 case 16:
319 if ( (*p) == 42 )
320 goto st17;
321 goto st16;
322 st17:
323 if ( ++p == pe )
324 goto _test_eof17;
325 case 17:
326 switch( (*p) ) {
327 case 42: goto st17;
328 case 47: goto st9;
329 }
330 goto st16;
331 st18:
332 if ( ++p == pe )
333 goto _test_eof18;
334 case 18:
335 if ( (*p) == 10 )
336 goto st9;
337 goto st18;
338 tr4:
339 #line 141 "parser.rl"
340 { p--; {p++; cs = 27; goto _out;} }
341 goto st27;
342 st27:
343 if ( ++p == pe )
344 goto _test_eof27;
345 case 27:
346 #line 347 "parser.c"
347 goto st0;
348 st19:
349 if ( ++p == pe )
350 goto _test_eof19;
351 case 19:
352 switch( (*p) ) {
353 case 42: goto st20;
354 case 47: goto st22;
355 }
356 goto st0;
357 st20:
358 if ( ++p == pe )
359 goto _test_eof20;
360 case 20:
361 if ( (*p) == 42 )
362 goto st21;
363 goto st20;
364 st21:
365 if ( ++p == pe )
366 goto _test_eof21;
367 case 21:
368 switch( (*p) ) {
369 case 42: goto st21;
370 case 47: goto st8;
371 }
372 goto st20;
373 st22:
374 if ( ++p == pe )
375 goto _test_eof22;
376 case 22:
377 if ( (*p) == 10 )
378 goto st8;
379 goto st22;
380 st23:
381 if ( ++p == pe )
382 goto _test_eof23;
383 case 23:
384 switch( (*p) ) {
385 case 42: goto st24;
386 case 47: goto st26;
387 }
388 goto st0;
389 st24:
390 if ( ++p == pe )
391 goto _test_eof24;
392 case 24:
393 if ( (*p) == 42 )
394 goto st25;
395 goto st24;
396 st25:
397 if ( ++p == pe )
398 goto _test_eof25;
399 case 25:
400 switch( (*p) ) {
401 case 42: goto st25;
402 case 47: goto st2;
403 }
404 goto st24;
405 st26:
406 if ( ++p == pe )
407 goto _test_eof26;
408 case 26:
409 if ( (*p) == 10 )
410 goto st2;
411 goto st26;
412 }
413 _test_eof2: cs = 2; goto _test_eof;
414 _test_eof3: cs = 3; goto _test_eof;
415 _test_eof4: cs = 4; goto _test_eof;
416 _test_eof5: cs = 5; goto _test_eof;
417 _test_eof6: cs = 6; goto _test_eof;
418 _test_eof7: cs = 7; goto _test_eof;
419 _test_eof8: cs = 8; goto _test_eof;
420 _test_eof9: cs = 9; goto _test_eof;
421 _test_eof10: cs = 10; goto _test_eof;
422 _test_eof11: cs = 11; goto _test_eof;
423 _test_eof12: cs = 12; goto _test_eof;
424 _test_eof13: cs = 13; goto _test_eof;
425 _test_eof14: cs = 14; goto _test_eof;
426 _test_eof15: cs = 15; goto _test_eof;
427 _test_eof16: cs = 16; goto _test_eof;
428 _test_eof17: cs = 17; goto _test_eof;
429 _test_eof18: cs = 18; goto _test_eof;
430 _test_eof27: cs = 27; goto _test_eof;
431 _test_eof19: cs = 19; goto _test_eof;
432 _test_eof20: cs = 20; goto _test_eof;
433 _test_eof21: cs = 21; goto _test_eof;
434 _test_eof22: cs = 22; goto _test_eof;
435 _test_eof23: cs = 23; goto _test_eof;
436 _test_eof24: cs = 24; goto _test_eof;
437 _test_eof25: cs = 25; goto _test_eof;
438 _test_eof26: cs = 26; goto _test_eof;
439
440 _test_eof: {}
441 _out: {}
442 }
443
444 #line 167 "parser.rl"
445
446 if (cs >= JSON_object_first_final) {
447 if (json->create_additions) {
448 VALUE klassname;
449 if (NIL_P(json->object_class)) {
450 klassname = rb_hash_aref(*result, json->create_id);
451 } else {
452 klassname = rb_funcall(*result, i_aref, 1, json->create_id);
453 }
454 if (!NIL_P(klassname)) {
455 VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
456 if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
457 *result = rb_funcall(klass, i_json_create, 1, *result);
458 }
459 }
460 }
461 return p + 1;
462 } else {
463 return NULL;
464 }
465 }
466
467
468
469 #line 470 "parser.c"
470 static const int JSON_value_start = 1;
471 static const int JSON_value_first_final = 21;
472 static const int JSON_value_error = 0;
473
474 static const int JSON_value_en_main = 1;
475
476
477 #line 271 "parser.rl"
478
479
480 static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result)
481 {
482 int cs = EVIL;
483
484
485 #line 486 "parser.c"
486 {
487 cs = JSON_value_start;
488 }
489
490 #line 278 "parser.rl"
491
492 #line 493 "parser.c"
493 {
494 if ( p == pe )
495 goto _test_eof;
496 switch ( cs )
497 {
498 case 1:
499 switch( (*p) ) {
500 case 34: goto tr0;
501 case 45: goto tr2;
502 case 73: goto st2;
503 case 78: goto st9;
504 case 91: goto tr5;
505 case 102: goto st11;
506 case 110: goto st15;
507 case 116: goto st18;
508 case 123: goto tr9;
509 }
510 if ( 48 <= (*p) && (*p) <= 57 )
511 goto tr2;
512 goto st0;
513 st0:
514 cs = 0;
515 goto _out;
516 tr0:
517 #line 219 "parser.rl"
518 {
519 char *np = JSON_parse_string(json, p, pe, result);
520 if (np == NULL) { p--; {p++; cs = 21; goto _out;} } else {p = (( np))-1;}
521 }
522 goto st21;
523 tr2:
524 #line 224 "parser.rl"
525 {
526 char *np;
527 if(pe > p + 9 - json->quirks_mode && !strncmp(MinusInfinity, p, 9)) {
528 if (json->allow_nan) {
529 *result = CMinusInfinity;
530 {p = (( p + 10))-1;}
531 p--; {p++; cs = 21; goto _out;}
532 } else {
533 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p);
534 }
535 }
536 np = JSON_parse_float(json, p, pe, result);
537 if (np != NULL) {p = (( np))-1;}
538 np = JSON_parse_integer(json, p, pe, result);
539 if (np != NULL) {p = (( np))-1;}
540 p--; {p++; cs = 21; goto _out;}
541 }
542 goto st21;
543 tr5:
544 #line 242 "parser.rl"
545 {
546 char *np;
547 json->current_nesting++;
548 np = JSON_parse_array(json, p, pe, result);
549 json->current_nesting--;
550 if (np == NULL) { p--; {p++; cs = 21; goto _out;} } else {p = (( np))-1;}
551 }
552 goto st21;
553 tr9:
554 #line 250 "parser.rl"
555 {
556 char *np;
557 json->current_nesting++;
558 np = JSON_parse_object(json, p, pe, result);
559 json->current_nesting--;
560 if (np == NULL) { p--; {p++; cs = 21; goto _out;} } else {p = (( np))-1;}
561 }
562 goto st21;
563 tr16:
564 #line 212 "parser.rl"
565 {
566 if (json->allow_nan) {
567 *result = CInfinity;
568 } else {
569 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p - 8);
570 }
571 }
572 goto st21;
573 tr18:
574 #line 205 "parser.rl"
575 {
576 if (json->allow_nan) {
577 *result = CNaN;
578 } else {
579 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p - 2);
580 }
581 }
582 goto st21;
583 tr22:
584 #line 199 "parser.rl"
585 {
586 *result = Qfalse;
587 }
588 goto st21;
589 tr25:
590 #line 196 "parser.rl"
591 {
592 *result = Qnil;
593 }
594 goto st21;
595 tr28:
596 #line 202 "parser.rl"
597 {
598 *result = Qtrue;
599 }
600 goto st21;
601 st21:
602 if ( ++p == pe )
603 goto _test_eof21;
604 case 21:
605 #line 258 "parser.rl"
606 { p--; {p++; cs = 21; goto _out;} }
607 #line 608 "parser.c"
608 goto st0;
609 st2:
610 if ( ++p == pe )
611 goto _test_eof2;
612 case 2:
613 if ( (*p) == 110 )
614 goto st3;
615 goto st0;
616 st3:
617 if ( ++p == pe )
618 goto _test_eof3;
619 case 3:
620 if ( (*p) == 102 )
621 goto st4;
622 goto st0;
623 st4:
624 if ( ++p == pe )
625 goto _test_eof4;
626 case 4:
627 if ( (*p) == 105 )
628 goto st5;
629 goto st0;
630 st5:
631 if ( ++p == pe )
632 goto _test_eof5;
633 case 5:
634 if ( (*p) == 110 )
635 goto st6;
636 goto st0;
637 st6:
638 if ( ++p == pe )
639 goto _test_eof6;
640 case 6:
641 if ( (*p) == 105 )
642 goto st7;
643 goto st0;
644 st7:
645 if ( ++p == pe )
646 goto _test_eof7;
647 case 7:
648 if ( (*p) == 116 )
649 goto st8;
650 goto st0;
651 st8:
652 if ( ++p == pe )
653 goto _test_eof8;
654 case 8:
655 if ( (*p) == 121 )
656 goto tr16;
657 goto st0;
658 st9:
659 if ( ++p == pe )
660 goto _test_eof9;
661 case 9:
662 if ( (*p) == 97 )
663 goto st10;
664 goto st0;
665 st10:
666 if ( ++p == pe )
667 goto _test_eof10;
668 case 10:
669 if ( (*p) == 78 )
670 goto tr18;
671 goto st0;
672 st11:
673 if ( ++p == pe )
674 goto _test_eof11;
675 case 11:
676 if ( (*p) == 97 )
677 goto st12;
678 goto st0;
679 st12:
680 if ( ++p == pe )
681 goto _test_eof12;
682 case 12:
683 if ( (*p) == 108 )
684 goto st13;
685 goto st0;
686 st13:
687 if ( ++p == pe )
688 goto _test_eof13;
689 case 13:
690 if ( (*p) == 115 )
691 goto st14;
692 goto st0;
693 st14:
694 if ( ++p == pe )
695 goto _test_eof14;
696 case 14:
697 if ( (*p) == 101 )
698 goto tr22;
699 goto st0;
700 st15:
701 if ( ++p == pe )
702 goto _test_eof15;
703 case 15:
704 if ( (*p) == 117 )
705 goto st16;
706 goto st0;
707 st16:
708 if ( ++p == pe )
709 goto _test_eof16;
710 case 16:
711 if ( (*p) == 108 )
712 goto st17;
713 goto st0;
714 st17:
715 if ( ++p == pe )
716 goto _test_eof17;
717 case 17:
718 if ( (*p) == 108 )
719 goto tr25;
720 goto st0;
721 st18:
722 if ( ++p == pe )
723 goto _test_eof18;
724 case 18:
725 if ( (*p) == 114 )
726 goto st19;
727 goto st0;
728 st19:
729 if ( ++p == pe )
730 goto _test_eof19;
731 case 19:
732 if ( (*p) == 117 )
733 goto st20;
734 goto st0;
735 st20:
736 if ( ++p == pe )
737 goto _test_eof20;
738 case 20:
739 if ( (*p) == 101 )
740 goto tr28;
741 goto st0;
742 }
743 _test_eof21: cs = 21; goto _test_eof;
744 _test_eof2: cs = 2; goto _test_eof;
745 _test_eof3: cs = 3; goto _test_eof;
746 _test_eof4: cs = 4; goto _test_eof;
747 _test_eof5: cs = 5; goto _test_eof;
748 _test_eof6: cs = 6; goto _test_eof;
749 _test_eof7: cs = 7; goto _test_eof;
750 _test_eof8: cs = 8; goto _test_eof;
751 _test_eof9: cs = 9; goto _test_eof;
752 _test_eof10: cs = 10; goto _test_eof;
753 _test_eof11: cs = 11; goto _test_eof;
754 _test_eof12: cs = 12; goto _test_eof;
755 _test_eof13: cs = 13; goto _test_eof;
756 _test_eof14: cs = 14; goto _test_eof;
757 _test_eof15: cs = 15; goto _test_eof;
758 _test_eof16: cs = 16; goto _test_eof;
759 _test_eof17: cs = 17; goto _test_eof;
760 _test_eof18: cs = 18; goto _test_eof;
761 _test_eof19: cs = 19; goto _test_eof;
762 _test_eof20: cs = 20; goto _test_eof;
763
764 _test_eof: {}
765 _out: {}
766 }
767
768 #line 279 "parser.rl"
769
770 if (cs >= JSON_value_first_final) {
771 return p;
772 } else {
773 return NULL;
774 }
775 }
776
777
778 #line 779 "parser.c"
779 static const int JSON_integer_start = 1;
780 static const int JSON_integer_first_final = 3;
781 static const int JSON_integer_error = 0;
782
783 static const int JSON_integer_en_main = 1;
784
785
786 #line 295 "parser.rl"
787
788
789 static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
790 {
791 int cs = EVIL;
792
793
794 #line 795 "parser.c"
795 {
796 cs = JSON_integer_start;
797 }
798
799 #line 302 "parser.rl"
800 json->memo = p;
801
802 #line 803 "parser.c"
803 {
804 if ( p == pe )
805 goto _test_eof;
806 switch ( cs )
807 {
808 case 1:
809 switch( (*p) ) {
810 case 45: goto st2;
811 case 48: goto st3;
812 }
813 if ( 49 <= (*p) && (*p) <= 57 )
814 goto st5;
815 goto st0;
816 st0:
817 cs = 0;
818 goto _out;
819 st2:
820 if ( ++p == pe )
821 goto _test_eof2;
822 case 2:
823 if ( (*p) == 48 )
824 goto st3;
825 if ( 49 <= (*p) && (*p) <= 57 )
826 goto st5;
827 goto st0;
828 st3:
829 if ( ++p == pe )
830 goto _test_eof3;
831 case 3:
832 if ( 48 <= (*p) && (*p) <= 57 )
833 goto st0;
834 goto tr4;
835 tr4:
836 #line 292 "parser.rl"
837 { p--; {p++; cs = 4; goto _out;} }
838 goto st4;
839 st4:
840 if ( ++p == pe )
841 goto _test_eof4;
842 case 4:
843 #line 844 "parser.c"
844 goto st0;
845 st5:
846 if ( ++p == pe )
847 goto _test_eof5;
848 case 5:
849 if ( 48 <= (*p) && (*p) <= 57 )
850 goto st5;
851 goto tr4;
852 }
853 _test_eof2: cs = 2; goto _test_eof;
854 _test_eof3: cs = 3; goto _test_eof;
855 _test_eof4: cs = 4; goto _test_eof;
856 _test_eof5: cs = 5; goto _test_eof;
857
858 _test_eof: {}
859 _out: {}
860 }
861
862 #line 304 "parser.rl"
863
864 if (cs >= JSON_integer_first_final) {
865 long len = p - json->memo;
866 fbuffer_clear(json->fbuffer);
867 fbuffer_append(json->fbuffer, json->memo, len);
868 fbuffer_append_char(json->fbuffer, '\0');
869 *result = rb_cstr2inum(FBUFFER_PTR(json->fbuffer), 10);
870 return p + 1;
871 } else {
872 return NULL;
873 }
874 }
875
876
877 #line 878 "parser.c"
878 static const int JSON_float_start = 1;
879 static const int JSON_float_first_final = 8;
880 static const int JSON_float_error = 0;
881
882 static const int JSON_float_en_main = 1;
883
884
885 #line 329 "parser.rl"
886
887
888 static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
889 {
890 int cs = EVIL;
891
892
893 #line 894 "parser.c"
894 {
895 cs = JSON_float_start;
896 }
897
898 #line 336 "parser.rl"
899 json->memo = p;
900
901 #line 902 "parser.c"
902 {
903 if ( p == pe )
904 goto _test_eof;
905 switch ( cs )
906 {
907 case 1:
908 switch( (*p) ) {
909 case 45: goto st2;
910 case 48: goto st3;
911 }
912 if ( 49 <= (*p) && (*p) <= 57 )
913 goto st7;
914 goto st0;
915 st0:
916 cs = 0;
917 goto _out;
918 st2:
919 if ( ++p == pe )
920 goto _test_eof2;
921 case 2:
922 if ( (*p) == 48 )
923 goto st3;
924 if ( 49 <= (*p) && (*p) <= 57 )
925 goto st7;
926 goto st0;
927 st3:
928 if ( ++p == pe )
929 goto _test_eof3;
930 case 3:
931 switch( (*p) ) {
932 case 46: goto st4;
933 case 69: goto st5;
934 case 101: goto st5;
935 }
936 goto st0;
937 st4:
938 if ( ++p == pe )
939 goto _test_eof4;
940 case 4:
941 if ( 48 <= (*p) && (*p) <= 57 )
942 goto st8;
943 goto st0;
944 st8:
945 if ( ++p == pe )
946 goto _test_eof8;
947 case 8:
948 switch( (*p) ) {
949 case 69: goto st5;
950 case 101: goto st5;
951 }
952 if ( (*p) > 46 ) {
953 if ( 48 <= (*p) && (*p) <= 57 )
954 goto st8;
955 } else if ( (*p) >= 45 )
956 goto st0;
957 goto tr9;
958 tr9:
959 #line 323 "parser.rl"
960 { p--; {p++; cs = 9; goto _out;} }
961 goto st9;
962 st9:
963 if ( ++p == pe )
964 goto _test_eof9;
965 case 9:
966 #line 967 "parser.c"
967 goto st0;
968 st5:
969 if ( ++p == pe )
970 goto _test_eof5;
971 case 5:
972 switch( (*p) ) {
973 case 43: goto st6;
974 case 45: goto st6;
975 }
976 if ( 48 <= (*p) && (*p) <= 57 )
977 goto st10;
978 goto st0;
979 st6:
980 if ( ++p == pe )
981 goto _test_eof6;
982 case 6:
983 if ( 48 <= (*p) && (*p) <= 57 )
984 goto st10;
985 goto st0;
986 st10:
987 if ( ++p == pe )
988 goto _test_eof10;
989 case 10:
990 switch( (*p) ) {
991 case 69: goto st0;
992 case 101: goto st0;
993 }
994 if ( (*p) > 46 ) {
995 if ( 48 <= (*p) && (*p) <= 57 )
996 goto st10;
997 } else if ( (*p) >= 45 )
998 goto st0;
999 goto tr9;
1000 st7:
1001 if ( ++p == pe )
1002 goto _test_eof7;
1003 case 7:
1004 switch( (*p) ) {
1005 case 46: goto st4;
1006 case 69: goto st5;
1007 case 101: goto st5;
1008 }
1009 if ( 48 <= (*p) && (*p) <= 57 )
1010 goto st7;
1011 goto st0;
1012 }
1013 _test_eof2: cs = 2; goto _test_eof;
1014 _test_eof3: cs = 3; goto _test_eof;
1015 _test_eof4: cs = 4; goto _test_eof;
1016 _test_eof8: cs = 8; goto _test_eof;
1017 _test_eof9: cs = 9; goto _test_eof;
1018 _test_eof5: cs = 5; goto _test_eof;
1019 _test_eof6: cs = 6; goto _test_eof;
1020 _test_eof10: cs = 10; goto _test_eof;
1021 _test_eof7: cs = 7; goto _test_eof;
1022
1023 _test_eof: {}
1024 _out: {}
1025 }
1026
1027 #line 338 "parser.rl"
1028
1029 if (cs >= JSON_float_first_final) {
1030 long len = p - json->memo;
1031 fbuffer_clear(json->fbuffer);
1032 fbuffer_append(json->fbuffer, json->memo, len);
1033 fbuffer_append_char(json->fbuffer, '\0');
1034 *result = rb_float_new(rb_cstr_to_dbl(FBUFFER_PTR(json->fbuffer), 1));
1035 return p + 1;
1036 } else {
1037 return NULL;
1038 }
1039 }
1040
1041
1042
1043 #line 1044 "parser.c"
1044 static const int JSON_array_start = 1;
1045 static const int JSON_array_first_final = 17;
1046 static const int JSON_array_error = 0;
1047
1048 static const int JSON_array_en_main = 1;
1049
1050
1051 #line 381 "parser.rl"
1052
1053
1054 static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result)
1055 {
1056 int cs = EVIL;
1057 VALUE array_class = json->array_class;
1058
1059 if (json->max_nesting && json->current_nesting > json->max_nesting) {
1060 rb_raise(eNestingError, "nesting of %d is too deep", json->current_nesting);
1061 }
1062 *result = NIL_P(array_class) ? rb_ary_new() : rb_class_new_instance(0, 0, array_class);
1063
1064
1065 #line 1066 "parser.c"
1066 {
1067 cs = JSON_array_start;
1068 }
1069
1070 #line 394 "parser.rl"
1071
1072 #line 1073 "parser.c"
1073 {
1074 if ( p == pe )
1075 goto _test_eof;
1076 switch ( cs )
1077 {
1078 case 1:
1079 if ( (*p) == 91 )
1080 goto st2;
1081 goto st0;
1082 st0:
1083 cs = 0;
1084 goto _out;
1085 st2:
1086 if ( ++p == pe )
1087 goto _test_eof2;
1088 case 2:
1089 switch( (*p) ) {
1090 case 13: goto st2;
1091 case 32: goto st2;
1092 case 34: goto tr2;
1093 case 45: goto tr2;
1094 case 47: goto st13;
1095 case 73: goto tr2;
1096 case 78: goto tr2;
1097 case 91: goto tr2;
1098 case 93: goto tr4;
1099 case 102: goto tr2;
1100 case 110: goto tr2;
1101 case 116: goto tr2;
1102 case 123: goto tr2;
1103 }
1104 if ( (*p) > 10 ) {
1105 if ( 48 <= (*p) && (*p) <= 57 )
1106 goto tr2;
1107 } else if ( (*p) >= 9 )
1108 goto st2;
1109 goto st0;
1110 tr2:
1111 #line 358 "parser.rl"
1112 {
1113 VALUE v = Qnil;
1114 char *np = JSON_parse_value(json, p, pe, &v);
1115 if (np == NULL) {
1116 p--; {p++; cs = 3; goto _out;}
1117 } else {
1118 if (NIL_P(json->array_class)) {
1119 rb_ary_push(*result, v);
1120 } else {
1121 rb_funcall(*result, i_leftshift, 1, v);
1122 }
1123 {p = (( np))-1;}
1124 }
1125 }
1126 goto st3;
1127 st3:
1128 if ( ++p == pe )
1129 goto _test_eof3;
1130 case 3:
1131 #line 1132 "parser.c"
1132 switch( (*p) ) {
1133 case 13: goto st3;
1134 case 32: goto st3;
1135 case 44: goto st4;
1136 case 47: goto st9;
1137 case 93: goto tr4;
1138 }
1139 if ( 9 <= (*p) && (*p) <= 10 )
1140 goto st3;
1141 goto st0;
1142 st4:
1143 if ( ++p == pe )
1144 goto _test_eof4;
1145 case 4:
1146 switch( (*p) ) {
1147 case 13: goto st4;
1148 case 32: goto st4;
1149 case 34: goto tr2;
1150 case 45: goto tr2;
1151 case 47: goto st5;
1152 case 73: goto tr2;
1153 case 78: goto tr2;
1154 case 91: goto tr2;
1155 case 102: goto tr2;
1156 case 110: goto tr2;
1157 case 116: goto tr2;
1158 case 123: goto tr2;
1159 }
1160 if ( (*p) > 10 ) {
1161 if ( 48 <= (*p) && (*p) <= 57 )
1162 goto tr2;
1163 } else if ( (*p) >= 9 )
1164 goto st4;
1165 goto st0;
1166 st5:
1167 if ( ++p == pe )
1168 goto _test_eof5;
1169 case 5:
1170 switch( (*p) ) {
1171 case 42: goto st6;
1172 case 47: goto st8;
1173 }
1174 goto st0;
1175 st6:
1176 if ( ++p == pe )
1177 goto _test_eof6;
1178 case 6:
1179 if ( (*p) == 42 )
1180 goto st7;
1181 goto st6;
1182 st7:
1183 if ( ++p == pe )
1184 goto _test_eof7;
1185 case 7:
1186 switch( (*p) ) {
1187 case 42: goto st7;
1188 case 47: goto st4;
1189 }
1190 goto st6;
1191 st8:
1192 if ( ++p == pe )
1193 goto _test_eof8;
1194 case 8:
1195 if ( (*p) == 10 )
1196 goto st4;
1197 goto st8;
1198 st9:
1199 if ( ++p == pe )
1200 goto _test_eof9;
1201 case 9:
1202 switch( (*p) ) {
1203 case 42: goto st10;
1204 case 47: goto st12;
1205 }
1206 goto st0;
1207 st10:
1208 if ( ++p == pe )
1209 goto _test_eof10;
1210 case 10:
1211 if ( (*p) == 42 )
1212 goto st11;
1213 goto st10;
1214 st11:
1215 if ( ++p == pe )
1216 goto _test_eof11;
1217 case 11:
1218 switch( (*p) ) {
1219 case 42: goto st11;
1220 case 47: goto st3;
1221 }
1222 goto st10;
1223 st12:
1224 if ( ++p == pe )
1225 goto _test_eof12;
1226 case 12:
1227 if ( (*p) == 10 )
1228 goto st3;
1229 goto st12;
1230 tr4:
1231 #line 373 "parser.rl"
1232 { p--; {p++; cs = 17; goto _out;} }
1233 goto st17;
1234 st17:
1235 if ( ++p == pe )
1236 goto _test_eof17;
1237 case 17:
1238 #line 1239 "parser.c"
1239 goto st0;
1240 st13:
1241 if ( ++p == pe )
1242 goto _test_eof13;
1243 case 13:
1244 switch( (*p) ) {
1245 case 42: goto st14;
1246 case 47: goto st16;
1247 }
1248 goto st0;
1249 st14:
1250 if ( ++p == pe )
1251 goto _test_eof14;
1252 case 14:
1253 if ( (*p) == 42 )
1254 goto st15;
1255 goto st14;
1256 st15:
1257 if ( ++p == pe )
1258 goto _test_eof15;
1259 case 15:
1260 switch( (*p) ) {
1261 case 42: goto st15;
1262 case 47: goto st2;
1263 }
1264 goto st14;
1265 st16:
1266 if ( ++p == pe )
1267 goto _test_eof16;
1268 case 16:
1269 if ( (*p) == 10 )
1270 goto st2;
1271 goto st16;
1272 }
1273 _test_eof2: cs = 2; goto _test_eof;
1274 _test_eof3: cs = 3; goto _test_eof;
1275 _test_eof4: cs = 4; goto _test_eof;
1276 _test_eof5: cs = 5; goto _test_eof;
1277 _test_eof6: cs = 6; goto _test_eof;
1278 _test_eof7: cs = 7; goto _test_eof;
1279 _test_eof8: cs = 8; goto _test_eof;
1280 _test_eof9: cs = 9; goto _test_eof;
1281 _test_eof10: cs = 10; goto _test_eof;
1282 _test_eof11: cs = 11; goto _test_eof;
1283 _test_eof12: cs = 12; goto _test_eof;
1284 _test_eof17: cs = 17; goto _test_eof;
1285 _test_eof13: cs = 13; goto _test_eof;
1286 _test_eof14: cs = 14; goto _test_eof;
1287 _test_eof15: cs = 15; goto _test_eof;
1288 _test_eof16: cs = 16; goto _test_eof;
1289
1290 _test_eof: {}
1291 _out: {}
1292 }
1293
1294 #line 395 "parser.rl"
1295
1296 if(cs >= JSON_array_first_final) {
1297 return p + 1;
1298 } else {
1299 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p);
1300 return NULL;
1301 }
1302 }
1303
1304 static VALUE json_string_unescape(VALUE result, char *string, char *stringEnd)
1305 {
1306 char *p = string, *pe = string, *unescape;
1307 int unescape_len;
1308 char buf[4];
1309
1310 while (pe < stringEnd) {
1311 if (*pe == '\\') {
1312 unescape = (char *) "?";
1313 unescape_len = 1;
1314 if (pe > p) rb_str_buf_cat(result, p, pe - p);
1315 switch (*++pe) {
1316 case 'n':
1317 unescape = (char *) "\n";
1318 break;
1319 case 'r':
1320 unescape = (char *) "\r";
1321 break;
1322 case 't':
1323 unescape = (char *) "\t";
1324 break;
1325 case '"':
1326 unescape = (char *) "\"";
1327 break;
1328 case '\\':
1329 unescape = (char *) "\\";
1330 break;
1331 case 'b':
1332 unescape = (char *) "\b";
1333 break;
1334 case 'f':
1335 unescape = (char *) "\f";
1336 break;
1337 case 'u':
1338 if (pe > stringEnd - 4) {
1339 return Qnil;
1340 } else {
1341 UTF32 ch = unescape_unicode((unsigned char *) ++pe);
1342 pe += 3;
1343 if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
1344 pe++;
1345 if (pe > stringEnd - 6) return Qnil;
1346 if (pe[0] == '\\' && pe[1] == 'u') {
1347 UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
1348 ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
1349 | (sur & 0x3FF));
1350 pe += 5;
1351 } else {
1352 unescape = (char *) "?";
1353 break;
1354 }
1355 }
1356 unescape_len = convert_UTF32_to_UTF8(buf, ch);
1357 unescape = buf;
1358 }
1359 break;
1360 default:
1361 p = pe;
1362 continue;
1363 }
1364 rb_str_buf_cat(result, unescape, unescape_len);
1365 p = ++pe;
1366 } else {
1367 pe++;
1368 }
1369 }
1370 rb_str_buf_cat(result, p, pe - p);
1371 return result;
1372 }
1373
1374
1375 #line 1376 "parser.c"
1376 static const int JSON_string_start = 1;
1377 static const int JSON_string_first_final = 8;
1378 static const int JSON_string_error = 0;
1379
1380 static const int JSON_string_en_main = 1;
1381
1382
1383 #line 494 "parser.rl"
1384
1385
1386 static int
1387 match_i(VALUE regexp, VALUE klass, VALUE memo)
1388 {
1389 if (regexp == Qundef) return ST_STOP;
1390 if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
1391 RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
1392 rb_ary_push(memo, klass);
1393 return ST_STOP;
1394 }
1395 return ST_CONTINUE;
1396 }
1397
1398 static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
1399 {
1400 int cs = EVIL;
1401 VALUE match_string;
1402
1403 *result = rb_str_buf_new(0);
1404
1405 #line 1406 "parser.c"
1406 {
1407 cs = JSON_string_start;
1408 }
1409
1410 #line 515 "parser.rl"
1411 json->memo = p;
1412
1413 #line 1414 "parser.c"
1414 {
1415 if ( p == pe )
1416 goto _test_eof;
1417 switch ( cs )
1418 {
1419 case 1:
1420 if ( (*p) == 34 )
1421 goto st2;
1422 goto st0;
1423 st0:
1424 cs = 0;
1425 goto _out;
1426 st2:
1427 if ( ++p == pe )
1428 goto _test_eof2;
1429 case 2:
1430 switch( (*p) ) {
1431 case 34: goto tr2;
1432 case 92: goto st3;
1433 }
1434 if ( 0 <= (*p) && (*p) <= 31 )
1435 goto st0;
1436 goto st2;
1437 tr2:
1438 #line 480 "parser.rl"
1439 {
1440 *result = json_string_unescape(*result, json->memo + 1, p);
1441 if (NIL_P(*result)) {
1442 p--;
1443 {p++; cs = 8; goto _out;}
1444 } else {
1445 FORCE_UTF8(*result);
1446 {p = (( p + 1))-1;}
1447 }
1448 }
1449 #line 491 "parser.rl"
1450 { p--; {p++; cs = 8; goto _out;} }
1451 goto st8;
1452 st8:
1453 if ( ++p == pe )
1454 goto _test_eof8;
1455 case 8:
1456 #line 1457 "parser.c"
1457 goto st0;
1458 st3:
1459 if ( ++p == pe )
1460 goto _test_eof3;
1461 case 3:
1462 if ( (*p) == 117 )
1463 goto st4;
1464 if ( 0 <= (*p) && (*p) <= 31 )
1465 goto st0;
1466 goto st2;
1467 st4:
1468 if ( ++p == pe )
1469 goto _test_eof4;
1470 case 4:
1471 if ( (*p) < 65 ) {
1472 if ( 48 <= (*p) && (*p) <= 57 )
1473 goto st5;
1474 } else if ( (*p) > 70 ) {
1475 if ( 97 <= (*p) && (*p) <= 102 )
1476 goto st5;
1477 } else
1478 goto st5;
1479 goto st0;
1480 st5:
1481 if ( ++p == pe )
1482 goto _test_eof5;
1483 case 5:
1484 if ( (*p) < 65 ) {
1485 if ( 48 <= (*p) && (*p) <= 57 )
1486 goto st6;
1487 } else if ( (*p) > 70 ) {
1488 if ( 97 <= (*p) && (*p) <= 102 )
1489 goto st6;
1490 } else
1491 goto st6;
1492 goto st0;
1493 st6:
1494 if ( ++p == pe )
1495 goto _test_eof6;
1496 case 6:
1497 if ( (*p) < 65 ) {
1498 if ( 48 <= (*p) && (*p) <= 57 )
1499 goto st7;
1500 } else if ( (*p) > 70 ) {
1501 if ( 97 <= (*p) && (*p) <= 102 )
1502 goto st7;
1503 } else
1504 goto st7;
1505 goto st0;
1506 st7:
1507 if ( ++p == pe )
1508 goto _test_eof7;
1509 case 7:
1510 if ( (*p) < 65 ) {
1511 if ( 48 <= (*p) && (*p) <= 57 )
1512 goto st2;
1513 } else if ( (*p) > 70 ) {
1514 if ( 97 <= (*p) && (*p) <= 102 )
1515 goto st2;
1516 } else
1517 goto st2;
1518 goto st0;
1519 }
1520 _test_eof2: cs = 2; goto _test_eof;
1521 _test_eof8: cs = 8; goto _test_eof;
1522 _test_eof3: cs = 3; goto _test_eof;
1523 _test_eof4: cs = 4; goto _test_eof;
1524 _test_eof5: cs = 5; goto _test_eof;
1525 _test_eof6: cs = 6; goto _test_eof;
1526 _test_eof7: cs = 7; goto _test_eof;
1527
1528 _test_eof: {}
1529 _out: {}
1530 }
1531
1532 #line 517 "parser.rl"
1533
1534 if (json->create_additions && RTEST(match_string = json->match_string)) {
1535 VALUE klass;
1536 VALUE memo = rb_ary_new2(2);
1537 rb_ary_push(memo, *result);
1538 rb_hash_foreach(match_string, match_i, memo);
1539 klass = rb_ary_entry(memo, 1);
1540 if (RTEST(klass)) {
1541 *result = rb_funcall(klass, i_json_create, 1, *result);
1542 }
1543 }
1544
1545 if (json->symbolize_names && json->parsing_name) {
1546 *result = rb_str_intern(*result);
1547 }
1548 if (cs >= JSON_string_first_final) {
1549 return p + 1;
1550 } else {
1551 return NULL;
1552 }
1553 }
1554
1555 /*
1556 * Document-class: JSON::Ext::Parser
1557 *
1558 * This is the JSON parser implemented as a C extension. It can be configured
1559 * to be used by setting
1560 *
1561 * JSON.parser = JSON::Ext::Parser
1562 *
1563 * with the method parser= in JSON.
1564 *
1565 */
1566
1567 static VALUE convert_encoding(VALUE source)
1568 {
1569 char *ptr = RSTRING_PTR(source);
1570 long len = RSTRING_LEN(source);
1571 if (len < 2) {
1572 rb_raise(eParserError, "A JSON text must at least contain two octets!");
1573 }
1574 #ifdef HAVE_RUBY_ENCODING_H
1575 {
1576 VALUE encoding = rb_funcall(source, i_encoding, 0);
1577 if (encoding == CEncoding_ASCII_8BIT) {
1578 if (len >= 4 && ptr[0] == 0 && ptr[1] == 0 && ptr[2] == 0) {
1579 source = rb_funcall(source, i_encode, 2, CEncoding_UTF_8, CEncoding_UTF_32BE);
1580 } else if (len >= 4 && ptr[0] == 0 && ptr[2] == 0) {
1581 source = rb_funcall(source, i_encode, 2, CEncoding_UTF_8, CEncoding_UTF_16BE);
1582 } else if (len >= 4 && ptr[1] == 0 && ptr[2] == 0 && ptr[3] == 0) {
1583 source = rb_funcall(source, i_encode, 2, CEncoding_UTF_8, CEncoding_UTF_32LE);
1584 } else if (len >= 4 && ptr[1] == 0 && ptr[3] == 0) {
1585 source = rb_funcall(source, i_encode, 2, CEncoding_UTF_8, CEncoding_UTF_16LE);
1586 } else {
1587 source = rb_str_dup(source);
1588 FORCE_UTF8(source);
1589 }
1590 } else {
1591 source = rb_funcall(source, i_encode, 1, CEncoding_UTF_8);
1592 }
1593 }
1594 #else
1595 if (len >= 4 && ptr[0] == 0 && ptr[1] == 0 && ptr[2] == 0) {
1596 source = rb_funcall(mJSON, i_iconv, 3, rb_str_new2("utf-8"), rb_str_new2("utf-32be"), source);
1597 } else if (len >= 4 && ptr[0] == 0 && ptr[2] == 0) {
1598 source = rb_funcall(mJSON, i_iconv, 3, rb_str_new2("utf-8"), rb_str_new2("utf-16be"), source);
1599 } else if (len >= 4 && ptr[1] == 0 && ptr[2] == 0 && ptr[3] == 0) {
1600 source = rb_funcall(mJSON, i_iconv, 3, rb_str_new2("utf-8"), rb_str_new2("utf-32le"), source);
1601 } else if (len >= 4 && ptr[1] == 0 && ptr[3] == 0) {
1602 source = rb_funcall(mJSON, i_iconv, 3, rb_str_new2("utf-8"), rb_str_new2("utf-16le"), source);
1603 }
1604 #endif
1605 return source;
1606 }
1607
1608 /*
1609 * call-seq: new(source, opts => {})
1610 *
1611 * Creates a new JSON::Ext::Parser instance for the string _source_.
1612 *
1613 * Creates a new JSON::Ext::Parser instance for the string _source_.
1614 *
1615 * It will be configured by the _opts_ hash. _opts_ can have the following
1616 * keys:
1617 *
1618 * _opts_ can have the following keys:
1619 * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
1620 * structures. Disable depth checking with :max_nesting => false|nil|0, it
1621 * defaults to 100.
1622 * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
1623 * defiance of RFC 4627 to be parsed by the Parser. This option defaults to
1624 * false.
1625 * * *symbolize_names*: If set to true, returns symbols for the names
1626 * (keys) in a JSON object. Otherwise strings are returned, which is also
1627 * the default.
1628 * * *create_additions*: If set to false, the Parser doesn't create
1629 * additions even if a matchin class and create_id was found. This option
1630 * defaults to true.
1631 * * *object_class*: Defaults to Hash
1632 * * *array_class*: Defaults to Array
1633 */
1634 static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
1635 {
1636 VALUE source, opts;
1637 GET_PARSER_INIT;
1638
1639 if (json->Vsource) {
1640 rb_raise(rb_eTypeError, "already initialized instance");
1641 }
1642 rb_scan_args(argc, argv, "11", &source, &opts);
1643 if (!NIL_P(opts)) {
1644 opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
1645 if (NIL_P(opts)) {
1646 rb_raise(rb_eArgError, "opts needs to be like a hash");
1647 } else {
1648 VALUE tmp = ID2SYM(i_max_nesting);
1649 if (option_given_p(opts, tmp)) {
1650 VALUE max_nesting = rb_hash_aref(opts, tmp);
1651 if (RTEST(max_nesting)) {
1652 Check_Type(max_nesting, T_FIXNUM);
1653 json->max_nesting = FIX2INT(max_nesting);
1654 } else {
1655 json->max_nesting = 0;
1656 }
1657 } else {
1658 json->max_nesting = 100;
1659 }
1660 tmp = ID2SYM(i_allow_nan);
1661 if (option_given_p(opts, tmp)) {
1662 json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1663 } else {
1664 json->allow_nan = 0;
1665 }
1666 tmp = ID2SYM(i_symbolize_names);
1667 if (option_given_p(opts, tmp)) {
1668 json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
1669 } else {
1670 json->symbolize_names = 0;
1671 }
1672 tmp = ID2SYM(i_quirks_mode);
1673 if (option_given_p(opts, tmp)) {
1674 VALUE quirks_mode = rb_hash_aref(opts, tmp);
1675 json->quirks_mode = RTEST(quirks_mode) ? 1 : 0;
1676 } else {
1677 json->quirks_mode = 0;
1678 }
1679 tmp = ID2SYM(i_create_additions);
1680 if (option_given_p(opts, tmp)) {
1681 json->create_additions = RTEST(rb_hash_aref(opts, tmp));
1682 } else {
1683 json->create_additions = 0;
1684 }
1685 tmp = ID2SYM(i_create_id);
1686 if (option_given_p(opts, tmp)) {
1687 json->create_id = rb_hash_aref(opts, tmp);
1688 } else {
1689 json->create_id = rb_funcall(mJSON, i_create_id, 0);
1690 }
1691 tmp = ID2SYM(i_object_class);
1692 if (option_given_p(opts, tmp)) {
1693 json->object_class = rb_hash_aref(opts, tmp);
1694 } else {
1695 json->object_class = Qnil;
1696 }
1697 tmp = ID2SYM(i_array_class);
1698 if (option_given_p(opts, tmp)) {
1699 json->array_class = rb_hash_aref(opts, tmp);
1700 } else {
1701 json->array_class = Qnil;
1702 }
1703 tmp = ID2SYM(i_match_string);
1704 if (option_given_p(opts, tmp)) {
1705 VALUE match_string = rb_hash_aref(opts, tmp);
1706 json->match_string = RTEST(match_string) ? match_string : Qnil;
1707 } else {
1708 json->match_string = Qnil;
1709 }
1710 }
1711 } else {
1712 json->max_nesting = 100;
1713 json->allow_nan = 0;
1714 json->create_additions = 1;
1715 json->create_id = rb_funcall(mJSON, i_create_id, 0);
1716 json->object_class = Qnil;
1717 json->array_class = Qnil;
1718 }
1719 source = rb_convert_type(source, T_STRING, "String", "to_str");
1720 if (!json->quirks_mode) {
1721 source = convert_encoding(StringValue(source));
1722 }
1723 json->current_nesting = 0;
1724 StringValue(source);
1725 json->len = RSTRING_LEN(source);
1726 json->source = RSTRING_PTR(source);;
1727 json->Vsource = source;
1728 return self;
1729 }
1730
1731
1732 #line 1733 "parser.c"
1733 static const int JSON_start = 1;
1734 static const int JSON_first_final = 10;
1735 static const int JSON_error = 0;
1736
1737 static const int JSON_en_main = 1;
1738
1739
1740 #line 740 "parser.rl"
1741
1742
1743 static VALUE cParser_parse_strict(VALUE self)
1744 {
1745 char *p, *pe;
1746 int cs = EVIL;
1747 VALUE result = Qnil;
1748 GET_PARSER;
1749
1750
1751 #line 1752 "parser.c"
1752 {
1753 cs = JSON_start;
1754 }
1755
1756 #line 750 "parser.rl"
1757 p = json->source;
1758 pe = p + json->len;
1759
1760 #line 1761 "parser.c"
1761 {
1762 if ( p == pe )
1763 goto _test_eof;
1764 switch ( cs )
1765 {
1766 st1:
1767 if ( ++p == pe )
1768 goto _test_eof1;
1769 case 1:
1770 switch( (*p) ) {
1771 case 13: goto st1;
1772 case 32: goto st1;
1773 case 47: goto st2;
1774 case 91: goto tr3;
1775 case 123: goto tr4;
1776 }
1777 if ( 9 <= (*p) && (*p) <= 10 )
1778 goto st1;
1779 goto st0;
1780 st0:
1781 cs = 0;
1782 goto _out;
1783 st2:
1784 if ( ++p == pe )
1785 goto _test_eof2;
1786 case 2:
1787 switch( (*p) ) {
1788 case 42: goto st3;
1789 case 47: goto st5;
1790 }
1791 goto st0;
1792 st3:
1793 if ( ++p == pe )
1794 goto _test_eof3;
1795 case 3:
1796 if ( (*p) == 42 )
1797 goto st4;
1798 goto st3;
1799 st4:
1800 if ( ++p == pe )
1801 goto _test_eof4;
1802 case 4:
1803 switch( (*p) ) {
1804 case 42: goto st4;
1805 case 47: goto st1;
1806 }
1807 goto st3;
1808 st5:
1809 if ( ++p == pe )
1810 goto _test_eof5;
1811 case 5:
1812 if ( (*p) == 10 )
1813 goto st1;
1814 goto st5;
1815 tr3:
1816 #line 729 "parser.rl"
1817 {
1818 char *np;
1819 json->current_nesting = 1;
1820 np = JSON_parse_array(json, p, pe, &result);
1821 if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
1822 }
1823 goto st10;
1824 tr4:
1825 #line 722 "parser.rl"
1826 {
1827 char *np;
1828 json->current_nesting = 1;
1829 np = JSON_parse_object(json, p, pe, &result);
1830 if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
1831 }
1832 goto st10;
1833 st10:
1834 if ( ++p == pe )
1835 goto _test_eof10;
1836 case 10:
1837 #line 1838 "parser.c"
1838 switch( (*p) ) {
1839 case 13: goto st10;
1840 case 32: goto st10;
1841 case 47: goto st6;
1842 }
1843 if ( 9 <= (*p) && (*p) <= 10 )
1844 goto st10;
1845 goto st0;
1846 st6:
1847 if ( ++p == pe )
1848 goto _test_eof6;
1849 case 6:
1850 switch( (*p) ) {
1851 case 42: goto st7;
1852 case 47: goto st9;
1853 }
1854 goto st0;
1855 st7:
1856 if ( ++p == pe )
1857 goto _test_eof7;
1858 case 7:
1859 if ( (*p) == 42 )
1860 goto st8;
1861 goto st7;
1862 st8:
1863 if ( ++p == pe )
1864 goto _test_eof8;
1865 case 8:
1866 switch( (*p) ) {
1867 case 42: goto st8;
1868 case 47: goto st10;
1869 }
1870 goto st7;
1871 st9:
1872 if ( ++p == pe )
1873 goto _test_eof9;
1874 case 9:
1875 if ( (*p) == 10 )
1876 goto st10;
1877 goto st9;
1878 }
1879 _test_eof1: cs = 1; goto _test_eof;
1880 _test_eof2: cs = 2; goto _test_eof;
1881 _test_eof3: cs = 3; goto _test_eof;
1882 _test_eof4: cs = 4; goto _test_eof;
1883 _test_eof5: cs = 5; goto _test_eof;
1884 _test_eof10: cs = 10; goto _test_eof;
1885 _test_eof6: cs = 6; goto _test_eof;
1886 _test_eof7: cs = 7; goto _test_eof;
1887 _test_eof8: cs = 8; goto _test_eof;
1888 _test_eof9: cs = 9; goto _test_eof;
1889
1890 _test_eof: {}
1891 _out: {}
1892 }
1893
1894 #line 753 "parser.rl"
1895
1896 if (cs >= JSON_first_final && p == pe) {
1897 return result;
1898 } else {
1899 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p);
1900 return Qnil;
1901 }
1902 }
1903
1904
1905
1906 #line 1907 "parser.c"
1907 static const int JSON_quirks_mode_start = 1;
1908 static const int JSON_quirks_mode_first_final = 10;
1909 static const int JSON_quirks_mode_error = 0;
1910
1911 static const int JSON_quirks_mode_en_main = 1;
1912
1913
1914 #line 778 "parser.rl"
1915
1916
1917 static VALUE cParser_parse_quirks_mode(VALUE self)
1918 {
1919 char *p, *pe;
1920 int cs = EVIL;
1921 VALUE result = Qnil;
1922 GET_PARSER;
1923
1924
1925 #line 1926 "parser.c"
1926 {
1927 cs = JSON_quirks_mode_start;
1928 }
1929
1930 #line 788 "parser.rl"
1931 p = json->source;
1932 pe = p + json->len;
1933
1934 #line 1935 "parser.c"
1935 {
1936 if ( p == pe )
1937 goto _test_eof;
1938 switch ( cs )
1939 {
1940 st1:
1941 if ( ++p == pe )
1942 goto _test_eof1;
1943 case 1:
1944 switch( (*p) ) {
1945 case 13: goto st1;
1946 case 32: goto st1;
1947 case 34: goto tr2;
1948 case 45: goto tr2;
1949 case 47: goto st6;
1950 case 73: goto tr2;
1951 case 78: goto tr2;
1952 case 91: goto tr2;
1953 case 102: goto tr2;
1954 case 110: goto tr2;
1955 case 116: goto tr2;
1956 case 123: goto tr2;
1957 }
1958 if ( (*p) > 10 ) {
1959 if ( 48 <= (*p) && (*p) <= 57 )
1960 goto tr2;
1961 } else if ( (*p) >= 9 )
1962 goto st1;
1963 goto st0;
1964 st0:
1965 cs = 0;
1966 goto _out;
1967 tr2:
1968 #line 770 "parser.rl"
1969 {
1970 char *np = JSON_parse_value(json, p, pe, &result);
1971 if (np == NULL) { p--; {p++; cs = 10; goto _out;} } else {p = (( np))-1;}
1972 }
1973 goto st10;
1974 st10:
1975 if ( ++p == pe )
1976 goto _test_eof10;
1977 case 10:
1978 #line 1979 "parser.c"
1979 switch( (*p) ) {
1980 case 13: goto st10;
1981 case 32: goto st10;
1982 case 47: goto st2;
1983 }
1984 if ( 9 <= (*p) && (*p) <= 10 )
1985 goto st10;
1986 goto st0;
1987 st2:
1988 if ( ++p == pe )
1989 goto _test_eof2;
1990 case 2:
1991 switch( (*p) ) {
1992 case 42: goto st3;
1993 case 47: goto st5;
1994 }
1995 goto st0;
1996 st3:
1997 if ( ++p == pe )
1998 goto _test_eof3;
1999 case 3:
2000 if ( (*p) == 42 )
2001 goto st4;
2002 goto st3;
2003 st4:
2004 if ( ++p == pe )
2005 goto _test_eof4;
2006 case 4:
2007 switch( (*p) ) {
2008 case 42: goto st4;
2009 case 47: goto st10;
2010 }
2011 goto st3;
2012 st5:
2013 if ( ++p == pe )
2014 goto _test_eof5;
2015 case 5:
2016 if ( (*p) == 10 )
2017 goto st10;
2018 goto st5;
2019 st6:
2020 if ( ++p == pe )
2021 goto _test_eof6;
2022 case 6:
2023 switch( (*p) ) {
2024 case 42: goto st7;
2025 case 47: goto st9;
2026 }
2027 goto st0;
2028 st7:
2029 if ( ++p == pe )
2030 goto _test_eof7;
2031 case 7:
2032 if ( (*p) == 42 )
2033 goto st8;
2034 goto st7;
2035 st8:
2036 if ( ++p == pe )
2037 goto _test_eof8;
2038 case 8:
2039 switch( (*p) ) {
2040 case 42: goto st8;
2041 case 47: goto st1;
2042 }
2043 goto st7;
2044 st9:
2045 if ( ++p == pe )
2046 goto _test_eof9;
2047 case 9:
2048 if ( (*p) == 10 )
2049 goto st1;
2050 goto st9;
2051 }
2052 _test_eof1: cs = 1; goto _test_eof;
2053 _test_eof10: cs = 10; goto _test_eof;
2054 _test_eof2: cs = 2; goto _test_eof;
2055 _test_eof3: cs = 3; goto _test_eof;
2056 _test_eof4: cs = 4; goto _test_eof;
2057 _test_eof5: cs = 5; goto _test_eof;
2058 _test_eof6: cs = 6; goto _test_eof;
2059 _test_eof7: cs = 7; goto _test_eof;
2060 _test_eof8: cs = 8; goto _test_eof;
2061 _test_eof9: cs = 9; goto _test_eof;
2062
2063 _test_eof: {}
2064 _out: {}
2065 }
2066
2067 #line 791 "parser.rl"
2068
2069 if (cs >= JSON_quirks_mode_first_final && p == pe) {
2070 return result;
2071 } else {
2072 rb_raise(eParserError, "%u: unexpected token at '%s'", __LINE__, p);
2073 return Qnil;
2074 }
2075 }
2076
2077 /*
2078 * call-seq: parse()
2079 *
2080 * Parses the current JSON text _source_ and returns the complete data
2081 * structure as a result.
2082 */
2083 static VALUE cParser_parse(VALUE self)
2084 {
2085 GET_PARSER;
2086
2087 if (json->quirks_mode) {
2088 return cParser_parse_quirks_mode(self);
2089 } else {
2090 return cParser_parse_strict(self);
2091 }
2092 }
2093
2094
2095 static JSON_Parser *JSON_allocate()
2096 {
2097 JSON_Parser *json = ALLOC(JSON_Parser);
2098 MEMZERO(json, JSON_Parser, 1);
2099 json->fbuffer = fbuffer_alloc(0);
2100 return json;
2101 }
2102
2103 static void JSON_mark(JSON_Parser *json)
2104 {
2105 rb_gc_mark_maybe(json->Vsource);
2106 rb_gc_mark_maybe(json->create_id);
2107 rb_gc_mark_maybe(json->object_class);
2108 rb_gc_mark_maybe(json->array_class);
2109 rb_gc_mark_maybe(json->match_string);
2110 }
2111
2112 static void JSON_free(JSON_Parser *json)
2113 {
2114 fbuffer_free(json->fbuffer);
2115 ruby_xfree(json);
2116 }
2117
2118 static VALUE cJSON_parser_s_allocate(VALUE klass)
2119 {
2120 JSON_Parser *json = JSON_allocate();
2121 return Data_Wrap_Struct(klass, JSON_mark, JSON_free, json);
2122 }
2123
2124 /*
2125 * call-seq: source()
2126 *
2127 * Returns a copy of the current _source_ string, that was used to construct
2128 * this Parser.
2129 */
2130 static VALUE cParser_source(VALUE self)
2131 {
2132 GET_PARSER;
2133 return rb_str_dup(json->Vsource);
2134 }
2135
2136 /*
2137 * call-seq: quirks_mode?()
2138 *
2139 * Returns a true, if this parser is in quirks_mode, false otherwise.
2140 */
2141 static VALUE cParser_quirks_mode_p(VALUE self)
2142 {
2143 GET_PARSER;
2144 return json->quirks_mode ? Qtrue : Qfalse;
2145 }
2146
2147
2148 void Init_parser()
2149 {
2150 rb_require("json/common");
2151 mJSON = rb_define_module("JSON");
2152 mExt = rb_define_module_under(mJSON, "Ext");
2153 cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
2154 eParserError = rb_path2class("JSON::ParserError");
2155 eNestingError = rb_path2class("JSON::NestingError");
2156 rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
2157 rb_define_method(cParser, "initialize", cParser_initialize, -1);
2158 rb_define_method(cParser, "parse", cParser_parse, 0);
2159 rb_define_method(cParser, "source", cParser_source, 0);
2160 rb_define_method(cParser, "quirks_mode?", cParser_quirks_mode_p, 0);
2161
2162 CNaN = rb_const_get(mJSON, rb_intern("NaN"));
2163 CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
2164 CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
2165
2166 i_json_creatable_p = rb_intern("json_creatable?");
2167 i_json_create = rb_intern("json_create");
2168 i_create_id = rb_intern("create_id");
2169 i_create_additions = rb_intern("create_additions");
2170 i_chr = rb_intern("chr");
2171 i_max_nesting = rb_intern("max_nesting");
2172 i_allow_nan = rb_intern("allow_nan");
2173 i_symbolize_names = rb_intern("symbolize_names");
2174 i_quirks_mode = rb_intern("quirks_mode");
2175 i_object_class = rb_intern("object_class");
2176 i_array_class = rb_intern("array_class");
2177 i_match = rb_intern("match");
2178 i_match_string = rb_intern("match_string");
2179 i_key_p = rb_intern("key?");
2180 i_deep_const_get = rb_intern("deep_const_get");
2181 i_aset = rb_intern("[]=");
2182 i_aref = rb_intern("[]");
2183 i_leftshift = rb_intern("<<");
2184 #ifdef HAVE_RUBY_ENCODING_H
2185 CEncoding_UTF_8 = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-8"));
2186 CEncoding_UTF_16BE = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-16be"));
2187 CEncoding_UTF_16LE = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-16le"));
2188 CEncoding_UTF_32BE = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-32be"));
2189 CEncoding_UTF_32LE = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-32le"));
2190 CEncoding_ASCII_8BIT = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("ascii-8bit"));
2191 i_encoding = rb_intern("encoding");
2192 i_encode = rb_intern("encode");
2193 #else
2194 i_iconv = rb_intern("iconv");
2195 #endif
2196 }
2197
2198 /*
2199 * Local variables:
2200 * mode: c
2201 * c-file-style: ruby
2202 * indent-tabs-mode: nil
2203 * End:
2204 */
ALLOC
#define ALLOC(type)
tmp
volatile VALUE tmp
Definition: tcltklib.c:10209
fbuffer_clear
static void fbuffer_clear(FBuffer *fb)
Definition: fbuffer.h:83
JSON_ParserStruct::create_additions
int create_additions
Definition: parser.h:44
JSON_string_error
static const int JSON_string_error
Definition: parser.c:1378
JSON_allocate
static JSON_Parser * JSON_allocate()
Definition: parser.c:2095
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1101
JSON_ParserStruct::memo
char * memo
Definition: parser.h:34
JSON_value_error
static const int JSON_value_error
Definition: parser.c:472
rb_class_new_instance
VALUE rb_class_new_instance(int, VALUE *, VALUE)
Definition: object.c:1775
i_aref
static ID i_aref
Definition: parser.c:81
p
Win32OLEIDispatch * p
Definition: win32ole.c:786
JSON_float_first_final
static const int JSON_float_first_final
Definition: parser.c:879
cParser_source
static VALUE cParser_source(VALUE self)
Definition: parser.c:2130
rb_cstr_to_dbl
double rb_cstr_to_dbl(const char *, int)
Definition: object.c:2535
rb_const_get
VALUE rb_const_get(VALUE, ID)
Definition: variable.c:1876
option_given_p
#define option_given_p(opts, key)
Definition: generator.h:24
convert_encoding
static VALUE convert_encoding(VALUE source)
Definition: parser.c:1567
CEncoding_UTF_16BE
static VALUE CEncoding_UTF_16BE
Definition: parser.c:71
i_allow_nan
static ID i_allow_nan
Definition: parser.c:81
rb_eTypeError
VALUE rb_eTypeError
Definition: error.c:511
rb_define_alloc_func
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
JSON_ParserStruct::allow_nan
int allow_nan
Definition: parser.h:38
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
rb_require
VALUE rb_require(const char *)
Definition: load.c:1024
eParserError
static VALUE eParserError
Definition: parser.c:78
match_string
static VALUE match_string(VALUE match)
Definition: re.c:1818
i_max_nesting
static ID i_max_nesting
Definition: parser.c:81
RSTRING_PTR
#define RSTRING_PTR(str)
NIL_P
NIL_P(eventloop_thread)
Definition: tcltklib.c:4068
JSON_ParserStruct::parsing_name
int parsing_name
Definition: parser.h:39
fbuffer_append_char
static void fbuffer_append_char(FBuffer *fb, char newchr)
Definition: fbuffer.h:126
rb_funcall
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:774
rb_define_class_under
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition: class.c:545
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1780
T_HASH
#define T_HASH
Qtrue
return Qtrue
Definition: tcltklib.c:9610
JSON_object_start
static const int JSON_object_start
Definition: parser.c:92
i_encoding
static ID i_encoding
Definition: parser.c:73
cJSON_parser_s_allocate
static VALUE cJSON_parser_s_allocate(VALUE klass)
Definition: parser.c:2118
cParser_parse
static VALUE cParser_parse(VALUE self)
Definition: parser.c:2083
JSON_ParserStruct::current_nesting
int current_nesting
Definition: parser.h:37
CMinusInfinity
static VALUE CMinusInfinity
Definition: parser.c:79
JSON_string_first_final
static const int JSON_string_first_final
Definition: parser.c:1377
convert_UTF32_to_UTF8
static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
Definition: parser.c:44
rb_str_new2
#define rb_str_new2
rb_path2class
VALUE rb_path2class(const char *)
Definition: variable.c:371
JSON_float_en_main
static const int JSON_float_en_main
Definition: parser.c:882
ID2SYM
#define ID2SYM(x)
GET_PARSER
#define GET_PARSER
Definition: parser.h:49
i_aset
static ID i_aset
Definition: parser.c:81
cParser_initialize
static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
Definition: parser.c:1634
rb_hash_foreach
void rb_hash_foreach(VALUE, int(*)(ANYARGS), VALUE)
Definition: hash.c:200
MEMZERO
#define MEMZERO(p, type, n)
parser.h
JSON_array_first_final
static const int JSON_array_first_final
Definition: parser.c:1045
JSON_parse_object
static char * JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:102
rb_float_new
static VALUE rb_float_new(double d)
Definition: ripper.y:790
JSON_array_error
static const int JSON_array_error
Definition: parser.c:1046
JSON_parse_string
static char * JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:1398
i_chr
static ID i_chr
Definition: parser.c:81
JSON_mark
static void JSON_mark(JSON_Parser *json)
Definition: parser.c:2103
Data_Wrap_Struct
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
GET_PARSER_INIT
#define GET_PARSER_INIT
Definition: parser.h:52
i_deep_const_get
static ID i_deep_const_get
Definition: parser.c:81
Qfalse
return Qfalse
Definition: tcltklib.c:6779
eNestingError
static VALUE eNestingError
Definition: parser.c:78
JSON_value_start
static const int JSON_value_start
Definition: parser.c:470
Qnil
#define Qnil
Definition: tcltklib.c:1896
i_match
static ID i_match
Definition: parser.c:81
JSON_parse_array
static char * JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:1054
JSON_en_main
static const int JSON_en_main
Definition: parser.c:1737
fbuffer_append
static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
Definition: fbuffer.h:105
JSON_integer_start
static const int JSON_integer_start
Definition: parser.c:779
rb_ary_new
VALUE rb_ary_new(void)
Definition: array.c:424
Check_Type
#define Check_Type(v, t)
ID
unsigned long ID
Definition: ripper.y:105
UTF32
unsigned long UTF32
Definition: generator.h:30
RSTRING_LEN
#define RSTRING_LEN(str)
FIX2INT
#define FIX2INT(x)
i_object_class
static ID i_object_class
Definition: parser.c:81
JSON_ParserStruct::object_class
VALUE object_class
Definition: parser.h:42
JSON_integer_error
static const int JSON_integer_error
Definition: parser.c:781
T_STRING
#define T_STRING
cParser
static VALUE cParser
Definition: parser.c:78
JSON_quirks_mode_error
static const int JSON_quirks_mode_error
Definition: parser.c:1909
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
i_match_string
static ID i_match_string
Definition: parser.c:81
JSON_ParserStruct::symbolize_names
int symbolize_names
Definition: parser.h:40
cParser_parse_strict
static VALUE cParser_parse_strict(VALUE self)
Definition: parser.c:1743
JSON_string_en_main
static const int JSON_string_en_main
Definition: parser.c:1380
JSON_ParserStruct::max_nesting
int max_nesting
Definition: parser.h:36
CNaN
static VALUE CNaN
Definition: parser.c:79
rb_str_buf_cat
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1947
fbuffer_alloc
static FBuffer * fbuffer_alloc(unsigned long initial_length)
Definition: fbuffer.h:67
rb_str_dup
VALUE rb_str_dup(VALUE)
Definition: string.c:946
CEncoding_UTF_32BE
static VALUE CEncoding_UTF_32BE
Definition: parser.c:71
argv
VALUE * argv
Definition: tcltklib.c:1971
CEncoding_UTF_32LE
static VALUE CEncoding_UTF_32LE
Definition: parser.c:71
rb_hash_aset
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
RTEST
#define RTEST(v)
JSON_float_error
static const int JSON_float_error
Definition: parser.c:880
i_json_create
static ID i_json_create
Definition: parser.c:81
result
q result
Definition: tcltklib.c:7070
StringValue
#define StringValue(v)
cParser_parse_quirks_mode
static VALUE cParser_parse_quirks_mode(VALUE self)
Definition: parser.c:1917
JSON_error
static const int JSON_error
Definition: parser.c:1735
ruby_xfree
void ruby_xfree(void *x)
Definition: gc.c:3651
JSON_free
static void JSON_free(JSON_Parser *json)
Definition: parser.c:2112
rb_scan_args
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1570
JSON_float_start
static const int JSON_float_start
Definition: parser.c:878
cParser_quirks_mode_p
static VALUE cParser_quirks_mode_p(VALUE self)
Definition: parser.c:2141
T_FIXNUM
#define T_FIXNUM
argc
int argc
Definition: tcltklib.c:1970
rb_str_buf_new
VALUE rb_str_buf_new(long)
Definition: string.c:777
JSON_parse_value
static char * JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:480
mJSON
static VALUE mJSON
Definition: parser.c:78
i_key_p
static ID i_key_p
Definition: parser.c:81
JSON_ParserStruct::quirks_mode
int quirks_mode
Definition: parser.h:41
ST_CONTINUE
Definition: ripper.y:108
UNI_SUR_HIGH_START
#define UNI_SUR_HIGH_START
Definition: generator.h:40
b
Real * b
Definition: bigdecimal.c:1182
ptr
return ptr
Definition: tcltklib.c:784
rb_gc_mark_maybe
void rb_gc_mark_maybe(VALUE)
Definition: gc.c:2547
JSON_object_first_final
static const int JSON_object_first_final
Definition: parser.c:93
rb_define_module_under
VALUE rb_define_module_under(VALUE outer, const char *name)
Definition: class.c:637
Init_parser
void Init_parser()
Definition: parser.c:2148
JSON_quirks_mode_first_final
static const int JSON_quirks_mode_first_final
Definition: parser.c:1908
i_encode
static ID i_encode
Definition: parser.c:73
mExt
static VALUE mExt
Definition: parser.c:78
i_array_class
static ID i_array_class
Definition: parser.c:81
JSON_integer_en_main
static const int JSON_integer_en_main
Definition: parser.c:783
JSON_start
static const int JSON_start
Definition: parser.c:1733
JSON_array_start
static const int JSON_array_start
Definition: parser.c:1044
JSON_integer_first_final
static const int JSON_integer_first_final
Definition: parser.c:780
i_create_id
static ID i_create_id
Definition: parser.c:81
Qundef
#define Qundef
JSON_object_en_main
static const int JSON_object_en_main
Definition: parser.c:96
CInfinity
static VALUE CInfinity
Definition: parser.c:79
FORCE_UTF8
#define FORCE_UTF8(obj)
Definition: fbuffer.h:30
JSON_quirks_mode_en_main
static const int JSON_quirks_mode_en_main
Definition: parser.c:1911
fbuffer_free
static void fbuffer_free(FBuffer *fb)
Definition: fbuffer.h:77
JSON_first_final
static const int JSON_first_final
Definition: parser.c:1734
FBUFFER_PTR
#define FBUFFER_PTR(fb)
Definition: fbuffer.h:49
JSON_parse_integer
static char * JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:789
unescape_unicode
static UTF32 unescape_unicode(const unsigned char *p)
Definition: parser.c:25
rb_cObject
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1426
JSON_array_en_main
static const int JSON_array_en_main
Definition: parser.c:1048
ST_STOP
Definition: ripper.y:108
MinusInfinity
#define MinusInfinity
Definition: parser.h:56
digit_values
static const char digit_values[256]
Definition: parser.c:8
klass
klass
Definition: tcltklib.c:3504
JSON_string_start
static const int JSON_string_start
Definition: parser.c:1376
CEncoding_ASCII_8BIT
static VALUE CEncoding_ASCII_8BIT
Definition: parser.c:71
JSON_value_first_final
static const int JSON_value_first_final
Definition: parser.c:471
UNI_REPLACEMENT_CHAR
#define UNI_REPLACEMENT_CHAR
Definition: generator.h:34
rb_ary_new2
VALUE rb_ary_new2(long capa)
Definition: array.c:417
i_symbolize_names
static ID i_symbolize_names
Definition: parser.c:81
JSON_quirks_mode_start
static const int JSON_quirks_mode_start
Definition: parser.c:1907
JSON_value_en_main
static const int JSON_value_en_main
Definition: parser.c:474
rb_hash_new
VALUE rb_hash_new(void)
Definition: hash.c:234
JSON_ParserStruct::fbuffer
FBuffer * fbuffer
Definition: parser.h:46
rb_str_intern
VALUE rb_str_intern(VALUE)
Definition: string.c:7211
JSON_object_error
static const int JSON_object_error
Definition: parser.c:94
i_json_creatable_p
static ID i_json_creatable_p
Definition: parser.c:81
JSON_ParserStruct::array_class
VALUE array_class
Definition: parser.h:43
i_create_additions
static ID i_create_additions
Definition: parser.c:81
CEncoding_UTF_16LE
static VALUE CEncoding_UTF_16LE
Definition: parser.c:71
rb_hash_aref
VALUE rb_hash_aref(VALUE, VALUE)
Definition: hash.c:560
opts
VALUE opts
Definition: tcltklib.c:6146
VALUE
unsigned long VALUE
Definition: ripper.y:104
EVIL
#define EVIL
Definition: parser.h:57
JSON_ParserStruct::Vsource
VALUE Vsource
Definition: parser.h:31
JSON_ParserStruct::match_string
VALUE match_string
Definition: parser.h:45
JSON_parse_float
static char * JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:888
match_i
static int match_i(VALUE regexp, VALUE klass, VALUE memo)
Definition: parser.c:1387
json_string_unescape
static VALUE json_string_unescape(VALUE result, char *string, char *stringEnd)
Definition: parser.c:1304
i_leftshift
static ID i_leftshift
Definition: parser.c:81
rb_define_module
VALUE rb_define_module(const char *name)
Definition: class.c:617
rb_intern
#define rb_intern(str)
v
BDIGIT v
Definition: bigdecimal.c:5656
NULL
#define NULL
Definition: _sdbm.c:103
rb_define_method
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1344
i_quirks_mode
static ID i_quirks_mode
Definition: parser.c:81
JSON_ParserStruct::create_id
VALUE create_id
Definition: parser.h:35
JSON_ParserStruct
Definition: parser.h:30
rb_eArgError
VALUE rb_eArgError
Definition: error.c:512
rb_convert_type
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Definition: object.c:2368
rb_cstr2inum
VALUE rb_cstr2inum(const char *str, int base)
Definition: bignum.c:865
CEncoding_UTF_8
static VALUE CEncoding_UTF_8
Definition: parser.c:71
len
size_t len
Definition: tcltklib.c:3568