es-scout 5.3.0.es1

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