Ruby  2.0.0p247(2013-06-27revision41674)
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
74 #else
75 static ID i_iconv;
76 #endif
77 
80 
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
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;
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 
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  */
1635 {
1636  VALUE source, opts;
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 {
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 
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 
1918 {
1919  char *p, *pe;
1920  int cs = EVIL;
1921  VALUE result = Qnil;
1922  GET_PARSER;
1923 
1924 
1925 #line 1926 "parser.c"
1926  {
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  */
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 
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);
2110 }
2111 
2112 static void JSON_free(JSON_Parser *json)
2113 {
2114  fbuffer_free(json->fbuffer);
2115  ruby_xfree(json);
2116 }
2117 
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  */
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  */
2142 {
2143  GET_PARSER;
2144  return json->quirks_mode ? Qtrue : Qfalse;
2145 }
2146 
2147 
2149 {
2150  rb_require("json/common");
2151  mJSON = rb_define_module("JSON");
2152  mExt = rb_define_module_under(mJSON, "Ext");
2154  eParserError = rb_path2class("JSON::ParserError");
2155  eNestingError = rb_path2class("JSON::NestingError");
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  */
#define ALLOC(type)
volatile VALUE tmp
Definition: tcltklib.c:10209
static void fbuffer_clear(FBuffer *fb)
Definition: fbuffer.h:83
int create_additions
Definition: parser.h:44
static const int JSON_string_error
Definition: parser.c:1378
static JSON_Parser * JSON_allocate()
Definition: parser.c:2095
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1101
char * memo
Definition: parser.h:34
static const int JSON_value_error
Definition: parser.c:472
VALUE rb_class_new_instance(int, VALUE *, VALUE)
Definition: object.c:1756
static ID i_aref
Definition: parser.c:81
Win32OLEIDispatch * p
Definition: win32ole.c:786
static const int JSON_float_first_final
Definition: parser.c:879
static VALUE cParser_source(VALUE self)
Definition: parser.c:2130
double rb_cstr_to_dbl(const char *, int)
Definition: object.c:2516
VALUE rb_const_get(VALUE, ID)
Definition: variable.c:1871
#define option_given_p(opts, key)
Definition: generator.h:24
static VALUE convert_encoding(VALUE source)
Definition: parser.c:1567
static VALUE CEncoding_UTF_16BE
Definition: parser.c:71
static ID i_allow_nan
Definition: parser.c:81
VALUE rb_eTypeError
Definition: error.c:511
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
VALUE rb_require(const char *)
Definition: load.c:997
static VALUE eParserError
Definition: parser.c:78
static VALUE match_string(VALUE match)
Definition: re.c:1818
static ID i_max_nesting
Definition: parser.c:81
#define RSTRING_PTR(str)
NIL_P(eventloop_thread)
Definition: tcltklib.c:4068
int parsing_name
Definition: parser.h:39
static void fbuffer_append_char(FBuffer *fb, char newchr)
Definition: fbuffer.h:126
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:774
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition: class.c:545
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1780
#define T_HASH
return Qtrue
Definition: tcltklib.c:9610
static const int JSON_object_start
Definition: parser.c:92
static ID i_encoding
Definition: parser.c:73
static VALUE cJSON_parser_s_allocate(VALUE klass)
Definition: parser.c:2118
static VALUE cParser_parse(VALUE self)
Definition: parser.c:2083
int current_nesting
Definition: parser.h:37
static VALUE CMinusInfinity
Definition: parser.c:79
static const int JSON_string_first_final
Definition: parser.c:1377
static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
Definition: parser.c:44
#define rb_str_new2
VALUE rb_path2class(const char *)
Definition: variable.c:366
static const int JSON_float_en_main
Definition: parser.c:882
#define ID2SYM(x)
#define GET_PARSER
Definition: parser.h:49
static ID i_aset
Definition: parser.c:81
static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
Definition: parser.c:1634
void rb_hash_foreach(VALUE, int(*)(ANYARGS), VALUE)
Definition: hash.c:200
#define MEMZERO(p, type, n)
static const int JSON_array_first_final
Definition: parser.c:1045
static char * JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:102
static VALUE rb_float_new(double d)
Definition: ripper.y:790
static const int JSON_array_error
Definition: parser.c:1046
static char * JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:1398
static ID i_chr
Definition: parser.c:81
static void JSON_mark(JSON_Parser *json)
Definition: parser.c:2103
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
#define GET_PARSER_INIT
Definition: parser.h:52
static ID i_deep_const_get
Definition: parser.c:81
return Qfalse
Definition: tcltklib.c:6779
static VALUE eNestingError
Definition: parser.c:78
static const int JSON_value_start
Definition: parser.c:470
#define Qnil
Definition: tcltklib.c:1896
static ID i_match
Definition: parser.c:81
static char * JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:1054
static const int JSON_en_main
Definition: parser.c:1737
static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
Definition: fbuffer.h:105
static const int JSON_integer_start
Definition: parser.c:779
VALUE rb_ary_new(void)
Definition: array.c:424
#define Check_Type(v, t)
unsigned long ID
Definition: ripper.y:105
unsigned long UTF32
Definition: generator.h:30
#define RSTRING_LEN(str)
#define FIX2INT(x)
static ID i_object_class
Definition: parser.c:81
VALUE object_class
Definition: parser.h:42
static const int JSON_integer_error
Definition: parser.c:781
#define T_STRING
static VALUE cParser
Definition: parser.c:78
static const int JSON_quirks_mode_error
Definition: parser.c:1909
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
static ID i_match_string
Definition: parser.c:81
int symbolize_names
Definition: parser.h:40
static VALUE cParser_parse_strict(VALUE self)
Definition: parser.c:1743
static const int JSON_string_en_main
Definition: parser.c:1380
static VALUE CNaN
Definition: parser.c:79
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1940
static FBuffer * fbuffer_alloc(unsigned long initial_length)
Definition: fbuffer.h:67
VALUE rb_str_dup(VALUE)
Definition: string.c:946
static VALUE CEncoding_UTF_32BE
Definition: parser.c:71
VALUE * argv
Definition: tcltklib.c:1971
static VALUE CEncoding_UTF_32LE
Definition: parser.c:71
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define RTEST(v)
static const int JSON_float_error
Definition: parser.c:880
static ID i_json_create
Definition: parser.c:81
q result
Definition: tcltklib.c:7070
#define StringValue(v)
static VALUE cParser_parse_quirks_mode(VALUE self)
Definition: parser.c:1917
static const int JSON_error
Definition: parser.c:1735
void ruby_xfree(void *x)
Definition: gc.c:3649
static void JSON_free(JSON_Parser *json)
Definition: parser.c:2112
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1566
static const int JSON_float_start
Definition: parser.c:878
static VALUE cParser_quirks_mode_p(VALUE self)
Definition: parser.c:2141
#define T_FIXNUM
int argc
Definition: tcltklib.c:1970
VALUE rb_str_buf_new(long)
Definition: string.c:777
static char * JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:480
static VALUE mJSON
Definition: parser.c:78
static ID i_key_p
Definition: parser.c:81
#define UNI_SUR_HIGH_START
Definition: generator.h:40
Real * b
Definition: bigdecimal.c:1182
return ptr
Definition: tcltklib.c:784
void rb_gc_mark_maybe(VALUE)
Definition: gc.c:2547
static const int JSON_object_first_final
Definition: parser.c:93
VALUE rb_define_module_under(VALUE outer, const char *name)
Definition: class.c:637
void Init_parser()
Definition: parser.c:2148
static const int JSON_quirks_mode_first_final
Definition: parser.c:1908
static ID i_encode
Definition: parser.c:73
static VALUE mExt
Definition: parser.c:78
static ID i_array_class
Definition: parser.c:81
static const int JSON_integer_en_main
Definition: parser.c:783
static const int JSON_start
Definition: parser.c:1733
static const int JSON_array_start
Definition: parser.c:1044
static const int JSON_integer_first_final
Definition: parser.c:780
static ID i_create_id
Definition: parser.c:81
#define Qundef
static const int JSON_object_en_main
Definition: parser.c:96
static VALUE CInfinity
Definition: parser.c:79
#define FORCE_UTF8(obj)
Definition: fbuffer.h:30
static const int JSON_quirks_mode_en_main
Definition: parser.c:1911
static void fbuffer_free(FBuffer *fb)
Definition: fbuffer.h:77
static const int JSON_first_final
Definition: parser.c:1734
#define FBUFFER_PTR(fb)
Definition: fbuffer.h:49
static char * JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:789
static UTF32 unescape_unicode(const unsigned char *p)
Definition: parser.c:25
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1426
static const int JSON_array_en_main
Definition: parser.c:1048
#define MinusInfinity
Definition: parser.h:56
static const char digit_values[256]
Definition: parser.c:8
klass
Definition: tcltklib.c:3504
static const int JSON_string_start
Definition: parser.c:1376
static VALUE CEncoding_ASCII_8BIT
Definition: parser.c:71
static const int JSON_value_first_final
Definition: parser.c:471
#define UNI_REPLACEMENT_CHAR
Definition: generator.h:34
VALUE rb_ary_new2(long capa)
Definition: array.c:417
static ID i_symbolize_names
Definition: parser.c:81
static const int JSON_quirks_mode_start
Definition: parser.c:1907
static const int JSON_value_en_main
Definition: parser.c:474
VALUE rb_hash_new(void)
Definition: hash.c:234
FBuffer * fbuffer
Definition: parser.h:46
VALUE rb_str_intern(VALUE)
Definition: string.c:7203
static const int JSON_object_error
Definition: parser.c:94
static ID i_json_creatable_p
Definition: parser.c:81
VALUE array_class
Definition: parser.h:43
static ID i_create_additions
Definition: parser.c:81
static VALUE CEncoding_UTF_16LE
Definition: parser.c:71
VALUE rb_hash_aref(VALUE, VALUE)
Definition: hash.c:560
VALUE opts
Definition: tcltklib.c:6146
unsigned long VALUE
Definition: ripper.y:104
#define EVIL
Definition: parser.h:57
VALUE Vsource
Definition: parser.h:31
VALUE match_string
Definition: parser.h:45
static char * JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
Definition: parser.c:888
static int match_i(VALUE regexp, VALUE klass, VALUE memo)
Definition: parser.c:1387
static VALUE json_string_unescape(VALUE result, char *string, char *stringEnd)
Definition: parser.c:1304
static ID i_leftshift
Definition: parser.c:81
VALUE rb_define_module(const char *name)
Definition: class.c:617
#define rb_intern(str)
BDIGIT v
Definition: bigdecimal.c:5656
#define NULL
Definition: _sdbm.c:103
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1340
static ID i_quirks_mode
Definition: parser.c:81
VALUE create_id
Definition: parser.h:35
VALUE rb_eArgError
Definition: error.c:512
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Definition: object.c:2349
VALUE rb_cstr2inum(const char *str, int base)
Definition: bignum.c:865
static VALUE CEncoding_UTF_8
Definition: parser.c:71
size_t len
Definition: tcltklib.c:3568