edn_turbo 0.2.2 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +54 -9
  3. data/ext/edn_turbo/edn_parser.cc +493 -370
  4. data/ext/edn_turbo/edn_parser.h +48 -47
  5. data/ext/edn_turbo/edn_parser.rl +138 -107
  6. data/ext/edn_turbo/edn_parser_util.cc +122 -28
  7. data/ext/edn_turbo/extconf.rb +1 -1
  8. data/ext/edn_turbo/main.cc +90 -15
  9. data/lib/edn_turbo.rb +1 -1
  10. data/lib/edn_turbo/edn_parser.rb +19 -2
  11. data/lib/edn_turbo/version.rb +2 -2
  12. data/test/test_output_diff.rb +8 -8
  13. metadata +2 -16
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: a70e4427453a794f2ccaac6034998708b9784a7d
4
- data.tar.gz: d7fe39621793765d1aabe054d68fe11ecaf39efa
3
+ metadata.gz: 3bedae4e49919f1fb8b5eb7ac3438288353ba840
4
+ data.tar.gz: a1685384d17a698d5ea050aa5557e7106be81c21
5
5
  SHA512:
6
- metadata.gz: dbe5d42a67406237809cae635bd33d036a33fdf936fce7e2d80e767f4094ad7e056d5a4e6097c723a7177156e1064aed090b862985d319111bda1a613b585d14
7
- data.tar.gz: c8dd167e57663ab45837b89dd6034b8e151f5d1b18d6abd853fb1dc842473a1267bdadc3c01aa8a9063fd9aa43df50dfd568088aef12844e3f103ccdfb214f52
6
+ metadata.gz: 762c77382240141aaab80528a5fae3865d789a7740401215320b9416d078df72acaea10512fe0a9967307ab997ed4c68a0fb9bcf2d71248bac8155811ddfcea0
7
+ data.tar.gz: 644544230a2dcceb3139fedf9d83071c13b653746f40e041a512bdf8de5797d35890516aeaa15ae6059322c960038eabce3636e332ccefe8c9403e9abfc563c5
data/README.md CHANGED
@@ -18,13 +18,13 @@ and `edn_turbo` (see [issue 12](https://github.com/relevance/edn-ruby/issues/12)
18
18
  irb(main):004:0> s = "[{\"x\" {\"id\" \"/model/952\", \"model_name\" \"person\", \"ancestors\" [\"record\" \"asset\"], \"format\" \"edn\"}, \"id\" 952, \"name\" nil, \"model_name\" \"person\", \"rel\" {}, \"description\" nil, \"age\" nil, \"updated_at\" nil, \"created_at\" nil, \"anniversary\" nil, \"job\" nil, \"start_date\" nil, \"username\" nil, \"vacation_start\" nil, \"vacation_end\" nil, \"expenses\" nil, \"rate\" nil, \"display_name\" nil, \"gross_profit_per_month\" nil}]"
19
19
  => "[{\"x\" {\"id\" \"/model/952\", \"model_name\" \"person\", \"ancestors\" [\"record\" \"asset\"], \"format\" \"edn\"}, \"id\" 952, \"name\" nil, \"model_name\" \"person\", \"rel\" {}, \"description\" nil, \"age\" nil, \"updated_at\" nil, \"created_at\" nil, \"anniversary\" nil, \"job\" nil, \"start_date\" nil, \"username\" nil, \"vacation_start\" nil, \"vacation_end\" nil, \"expenses\" nil, \"rate\" nil, \"display_name\" nil, \"gross_profit_per_month\" nil}]"
20
20
  irb(main):005:0> Benchmark.realtime { 100.times { EDN::read(s) } }
21
- => 0.08602
21
+ => 0.078503
22
22
  irb(main):006:0> Benchmark.realtime { 100.times { EDNT::read(s) } }
23
- => 0.005923
23
+ => 0.002669
24
24
  irb(main):007:0> Benchmark.realtime { 100000.times { EDN::read(s) } }
25
- => 81.185499
25
+ => 75.219344
26
26
  irb(main):008:0> Benchmark.realtime { 100000.times { EDNT::read(s) } }
27
- => 3.929506
27
+ => 2.560593
28
28
  ```
29
29
 
30
30
  Dependencies
@@ -33,15 +33,25 @@ Dependencies
33
33
  - ruby gems:
34
34
  - [rake 10.3.2](http://rake.rubyforge.org)
35
35
  - [rake-compiler 0.9.2](http://rake-compiler.rubyforge.org)
36
- - [rice 1.7.0](http://rice.rubyforge.org)
37
36
  - [edn 1.0.7](https://github.com/relevance/edn-ruby)
38
37
  - [icu4c](http://icu-project.org/apiref/icu4c/)
39
38
 
40
- `edn_turbo` uses a ragel-based parser but the generated .cc file is
41
- bundled so ragel should not need to be installed.
39
+
40
+ Notes:
41
+ ------
42
+
43
+ - `edn_turbo` uses a ragel-based parser but the generated .cc file is
44
+ bundled so ragel should not need to be installed.
45
+
46
+ - As of 0.3.0, [rice](http://rice.rubyforge.org) is no longer
47
+ required.
48
+
42
49
 
43
50
  Usage
44
51
  =====
52
+
53
+ Simlar to `edn-ruby`:
54
+
45
55
  ```ruby
46
56
  require 'edn_turbo'
47
57
 
@@ -49,10 +59,45 @@ Usage
49
59
  output = EDNT.read(file)
50
60
  pp output if output != nil
51
61
  end
62
+
63
+ # also accepts a string
64
+ pp EDNT.read("[ 1 2 3 abc ]")
65
+
66
+ ```
67
+
68
+ Or instantiate and reuse an instance of a parser:
69
+
70
+ ```ruby
71
+ require 'edn_turbo'
72
+
73
+ p = EDNT::Parser.new
74
+ File.open(filename) do |file|
75
+ output = p.parse(file)
76
+ pp output if output != nil
77
+ end
78
+
79
+ # with a string
80
+ pp p.parse("[ 1 2 3 abc ]")
81
+
82
+
83
+ # set new input
84
+ s = "(1) :abc { 1 2 }"
85
+ p.set_input(s)
86
+
87
+ # parse token by token
88
+ loop do
89
+ t = p.read
90
+ break if t == EDNT::EOF
91
+
92
+ pp t
93
+ end
52
94
  ```
53
95
 
96
+
54
97
  Known problems
55
98
  ==============
56
- v0.2.2:
99
+ v0.3.0:
57
100
 
58
- - Need to emulate EDN::Reader.each
101
+ - No checks for valid characters in #uuid or #inst are performed by
102
+ the parser. However, DateTime will throw an error if the date can't
103
+ be parsed and this is reported.
data/ext/edn_turbo/edn_parser.cc CHANGED
@@ -3,11 +3,7 @@
3
3
  #include <iostream>
4
4
  #include <string>
5
5
  #include <stack>
6
-
7
- #include <rice/Hash.hpp>
8
- #include <rice/Array.hpp>
9
- #include <rice/to_from_ruby.hpp>
10
- #include <rice/Exception.hpp>
6
+ #include <exception>
11
7
 
12
8
  #include "edn_parser.h"
13
9
 
@@ -20,7 +16,7 @@
20
16
  //
21
17
 
22
18
 
23
- #line 62 "edn_parser.rl"
19
+ #line 58 "edn_parser.rl"
24
20
 
25
21
 
26
22
  // ============================================================
@@ -28,7 +24,7 @@
28
24
  //
29
25
 
30
26
 
31
- #line 32 "edn_parser.cc"
27
+ #line 28 "edn_parser.cc"
32
28
  static const int EDN_value_start = 1;
33
29
  static const int EDN_value_first_final = 2;
34
30
  static const int EDN_value_error = 0;
@@ -36,23 +32,23 @@ static const int EDN_value_error = 0;
36
32
  static const int EDN_value_en_main = 1;
37
33
 
38
34
 
39
- #line 170 "edn_parser.rl"
35
+ #line 167 "edn_parser.rl"
40
36
 
41
37
 
42
38
 
43
- const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object& o)
39
+ const char *edn::Parser::parse_value(const char *p, const char *pe, VALUE& v)
44
40
  {
45
41
  int cs;
46
42
 
47
43
 
48
- #line 49 "edn_parser.cc"
44
+ #line 45 "edn_parser.cc"
49
45
  {
50
46
  cs = EDN_value_start;
51
47
  }
52
48
 
53
- #line 178 "edn_parser.rl"
49
+ #line 175 "edn_parser.rl"
54
50
 
55
- #line 56 "edn_parser.cc"
51
+ #line 52 "edn_parser.cc"
56
52
  {
57
53
  if ( p == pe )
58
54
  goto _test_eof;
@@ -94,46 +90,46 @@ st0:
94
90
  cs = 0;
95
91
  goto _out;
96
92
  tr0:
97
- #line 106 "edn_parser.rl"
93
+ #line 102 "edn_parser.rl"
98
94
  {
99
95
  // stand-alone operators *, +, -, etc.
100
- const char *np = parse_operator(p, pe, o);
96
+ const char *np = parse_operator(p, pe, v);
101
97
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
102
98
  }
103
99
  goto st2;
104
100
  tr2:
105
- #line 74 "edn_parser.rl"
101
+ #line 70 "edn_parser.rl"
106
102
  {
107
103
  // string types within double-quotes
108
- const char *np = parse_string(p, pe, o);
104
+ const char *np = parse_string(p, pe, v);
109
105
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
110
106
  }
111
107
  goto st2;
112
108
  tr3:
113
- #line 151 "edn_parser.rl"
109
+ #line 148 "edn_parser.rl"
114
110
  {
115
111
  // handles tokens w/ leading # ("#_", "#{", and tagged elems)
116
- const char *np = parse_dispatch(p + 1, pe, o);
112
+ const char *np = parse_dispatch(p + 1, pe, v);
117
113
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
118
114
  }
119
115
  goto st2;
120
116
  tr4:
121
- #line 139 "edn_parser.rl"
117
+ #line 136 "edn_parser.rl"
122
118
  {
123
119
  // (
124
- const char *np = parse_list(p, pe, o);
120
+ const char *np = parse_list(p, pe, v);
125
121
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
126
122
  }
127
123
  goto st2;
128
124
  tr5:
129
- #line 86 "edn_parser.rl"
125
+ #line 82 "edn_parser.rl"
130
126
  {
131
127
  // tokens w/ leading digits: non-negative integers & decimals.
132
128
  // try to parse a decimal first
133
- const char *np = parse_decimal(p, pe, o);
129
+ const char *np = parse_decimal(p, pe, v);
134
130
  if (np == NULL) {
135
131
  // if we can't, try to parse it as an int
136
- np = parse_integer(p, pe, o);
132
+ np = parse_integer(p, pe, v);
137
133
  }
138
134
 
139
135
  if (np) {
@@ -148,51 +144,52 @@ tr5:
148
144
  }
149
145
  goto st2;
150
146
  tr6:
151
- #line 80 "edn_parser.rl"
147
+ #line 76 "edn_parser.rl"
152
148
  {
153
149
  // tokens with a leading ':'
154
- const char *np = parse_keyword(p, pe, o);
150
+ const char *np = parse_keyword(p, pe, v);
155
151
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
156
152
  }
157
153
  goto st2;
158
154
  tr7:
159
- #line 118 "edn_parser.rl"
155
+ #line 114 "edn_parser.rl"
160
156
  {
161
157
  // user identifiers and reserved keywords (true, false, nil)
162
- std::string sym;
158
+ VALUE sym = Qnil;
163
159
  const char *np = parse_symbol(p, pe, sym);
164
160
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
165
- if (sym == "true") { o = Qtrue; }
166
- else if (sym == "false") { o = Qfalse; }
167
- else if (sym == "nil") { o = Qnil; }
161
+ // parse_symbol will make 'sym' a ruby string
162
+ if (std::strcmp(RSTRING_PTR(sym), "true") == 0) { v = Qtrue; }
163
+ else if (std::strcmp(RSTRING_PTR(sym), "false") == 0) { v = Qfalse; }
164
+ else if (std::strcmp(RSTRING_PTR(sym), "nil") == 0) { v = Qnil; }
168
165
  else {
169
- o = Parser::make_edn_symbol(sym);
166
+ v = Parser::make_edn_symbol(sym);
170
167
  }
171
168
  {p = (( np))-1;}
172
169
  }
173
170
  }
174
171
  goto st2;
175
172
  tr8:
176
- #line 133 "edn_parser.rl"
173
+ #line 130 "edn_parser.rl"
177
174
  {
178
175
  // [
179
- const char *np = parse_vector(p, pe, o);
176
+ const char *np = parse_vector(p, pe, v);
180
177
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
181
178
  }
182
179
  goto st2;
183
180
  tr9:
184
- #line 112 "edn_parser.rl"
181
+ #line 108 "edn_parser.rl"
185
182
  {
186
183
  // tokens w/ leading \ (escaped characters \newline, \c, etc.)
187
- const char *np = parse_esc_char(p, pe, o);
184
+ const char *np = parse_esc_char(p, pe, v);
188
185
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
189
186
  }
190
187
  goto st2;
191
188
  tr10:
192
- #line 145 "edn_parser.rl"
189
+ #line 142 "edn_parser.rl"
193
190
  {
194
191
  // {
195
- const char *np = parse_map(p, pe, o);
192
+ const char *np = parse_map(p, pe, v);
196
193
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
197
194
  }
198
195
  goto st2;
@@ -200,9 +197,9 @@ st2:
200
197
  if ( ++p == pe )
201
198
  goto _test_eof2;
202
199
  case 2:
203
- #line 61 "edn_parser.rl"
200
+ #line 57 "edn_parser.rl"
204
201
  { p--; {p++; cs = 2; goto _out;} }
205
- #line 206 "edn_parser.cc"
202
+ #line 203 "edn_parser.cc"
206
203
  goto st0;
207
204
  }
208
205
  _test_eof2: cs = 2; goto _test_eof;
@@ -211,7 +208,7 @@ case 2:
211
208
  _out: {}
212
209
  }
213
210
 
214
- #line 179 "edn_parser.rl"
211
+ #line 176 "edn_parser.rl"
215
212
 
216
213
  if (cs >= EDN_value_first_final) {
217
214
  return p;
@@ -233,7 +230,7 @@ case 2:
233
230
  // ascii range is found.
234
231
  //
235
232
 
236
- #line 237 "edn_parser.cc"
233
+ #line 234 "edn_parser.cc"
237
234
  static const int EDN_string_start = 1;
238
235
  static const int EDN_string_first_final = 8;
239
236
  static const int EDN_string_error = 0;
@@ -241,29 +238,27 @@ static const int EDN_string_error = 0;
241
238
  static const int EDN_string_en_main = 1;
242
239
 
243
240
 
244
- #line 224 "edn_parser.rl"
241
+ #line 221 "edn_parser.rl"
245
242
 
246
243
 
247
244
 
248
- const char* edn::Parser::parse_string(const char *p, const char *pe, Rice::Object& o)
245
+ const char* edn::Parser::parse_string(const char *p, const char *pe, VALUE& v)
249
246
  {
250
247
  // std::cerr << __FUNCTION__ << " - p: '" << p << "'" << std::endl;
251
248
  static const char* EDN_TYPE = "string";
252
249
  int cs;
253
250
  bool encode = false;
254
- const char *eof = pe;
255
- Rice::String s;
256
251
 
257
252
 
258
- #line 259 "edn_parser.cc"
253
+ #line 254 "edn_parser.cc"
259
254
  {
260
255
  cs = EDN_string_start;
261
256
  }
262
257
 
263
- #line 237 "edn_parser.rl"
264
- p_save = p;
258
+ #line 232 "edn_parser.rl"
259
+ const char* p_save = p;
265
260
 
266
- #line 267 "edn_parser.cc"
261
+ #line 262 "edn_parser.cc"
267
262
  {
268
263
  if ( p == pe )
269
264
  goto _test_eof;
@@ -274,7 +269,7 @@ case 1:
274
269
  goto st2;
275
270
  goto st0;
276
271
  tr3:
277
- #line 54 "edn_parser.rl"
272
+ #line 50 "edn_parser.rl"
278
273
  {
279
274
  std::stringstream s;
280
275
  s << "unterminated " << EDN_TYPE;
@@ -282,12 +277,12 @@ tr3:
282
277
  p--; {p++; cs = 0; goto _out;}
283
278
  }
284
279
  goto st0;
285
- #line 286 "edn_parser.cc"
280
+ #line 281 "edn_parser.cc"
286
281
  st0:
287
282
  cs = 0;
288
283
  goto _out;
289
284
  tr2:
290
- #line 213 "edn_parser.rl"
285
+ #line 210 "edn_parser.rl"
291
286
  {
292
287
  encode = true;
293
288
  }
@@ -296,7 +291,7 @@ st2:
296
291
  if ( ++p == pe )
297
292
  goto _test_eof2;
298
293
  case 2:
299
- #line 300 "edn_parser.cc"
294
+ #line 295 "edn_parser.cc"
300
295
  switch( (*p) ) {
301
296
  case 34: goto tr4;
302
297
  case 92: goto tr5;
@@ -308,25 +303,25 @@ case 2:
308
303
  goto tr2;
309
304
  goto st2;
310
305
  tr4:
311
- #line 205 "edn_parser.rl"
306
+ #line 202 "edn_parser.rl"
312
307
  {
313
- if (Parser::parse_byte_stream(p_save + 1, p, s, encode)) {
308
+ if (Parser::parse_byte_stream(p_save + 1, p, v, encode)) {
314
309
  {p = (( p + 1))-1;}
315
310
  } else {
316
311
  p--; {p++; cs = 8; goto _out;}
317
312
  }
318
313
  }
319
- #line 61 "edn_parser.rl"
314
+ #line 57 "edn_parser.rl"
320
315
  { p--; {p++; cs = 8; goto _out;} }
321
316
  goto st8;
322
317
  st8:
323
318
  if ( ++p == pe )
324
319
  goto _test_eof8;
325
320
  case 8:
326
- #line 327 "edn_parser.cc"
321
+ #line 322 "edn_parser.cc"
327
322
  goto st0;
328
323
  tr5:
329
- #line 213 "edn_parser.rl"
324
+ #line 210 "edn_parser.rl"
330
325
  {
331
326
  encode = true;
332
327
  }
@@ -335,7 +330,7 @@ st3:
335
330
  if ( ++p == pe )
336
331
  goto _test_eof3;
337
332
  case 3:
338
- #line 339 "edn_parser.cc"
333
+ #line 334 "edn_parser.cc"
339
334
  switch( (*p) ) {
340
335
  case 34: goto tr2;
341
336
  case 47: goto tr2;
@@ -351,7 +346,7 @@ case 3:
351
346
  goto st0;
352
347
  goto st2;
353
348
  tr6:
354
- #line 213 "edn_parser.rl"
349
+ #line 210 "edn_parser.rl"
355
350
  {
356
351
  encode = true;
357
352
  }
@@ -360,7 +355,7 @@ st4:
360
355
  if ( ++p == pe )
361
356
  goto _test_eof4;
362
357
  case 4:
363
- #line 364 "edn_parser.cc"
358
+ #line 359 "edn_parser.cc"
364
359
  if ( (*p) < 65 ) {
365
360
  if ( 48 <= (*p) && (*p) <= 57 )
366
361
  goto tr7;
@@ -371,7 +366,7 @@ case 4:
371
366
  goto tr7;
372
367
  goto st0;
373
368
  tr7:
374
- #line 213 "edn_parser.rl"
369
+ #line 210 "edn_parser.rl"
375
370
  {
376
371
  encode = true;
377
372
  }
@@ -380,7 +375,7 @@ st5:
380
375
  if ( ++p == pe )
381
376
  goto _test_eof5;
382
377
  case 5:
383
- #line 384 "edn_parser.cc"
378
+ #line 379 "edn_parser.cc"
384
379
  if ( (*p) < 65 ) {
385
380
  if ( 48 <= (*p) && (*p) <= 57 )
386
381
  goto tr8;
@@ -391,7 +386,7 @@ case 5:
391
386
  goto tr8;
392
387
  goto st0;
393
388
  tr8:
394
- #line 213 "edn_parser.rl"
389
+ #line 210 "edn_parser.rl"
395
390
  {
396
391
  encode = true;
397
392
  }
@@ -400,7 +395,7 @@ st6:
400
395
  if ( ++p == pe )
401
396
  goto _test_eof6;
402
397
  case 6:
403
- #line 404 "edn_parser.cc"
398
+ #line 399 "edn_parser.cc"
404
399
  if ( (*p) < 65 ) {
405
400
  if ( 48 <= (*p) && (*p) <= 57 )
406
401
  goto tr9;
@@ -411,7 +406,7 @@ case 6:
411
406
  goto tr9;
412
407
  goto st0;
413
408
  tr9:
414
- #line 213 "edn_parser.rl"
409
+ #line 210 "edn_parser.rl"
415
410
  {
416
411
  encode = true;
417
412
  }
@@ -420,7 +415,7 @@ st7:
420
415
  if ( ++p == pe )
421
416
  goto _test_eof7;
422
417
  case 7:
423
- #line 424 "edn_parser.cc"
418
+ #line 419 "edn_parser.cc"
424
419
  if ( (*p) < 65 ) {
425
420
  if ( 48 <= (*p) && (*p) <= 57 )
426
421
  goto tr2;
@@ -444,7 +439,7 @@ case 7:
444
439
  {
445
440
  switch ( cs ) {
446
441
  case 2:
447
- #line 54 "edn_parser.rl"
442
+ #line 50 "edn_parser.rl"
448
443
  {
449
444
  std::stringstream s;
450
445
  s << "unterminated " << EDN_TYPE;
@@ -452,17 +447,16 @@ case 7:
452
447
  p--; {p++; cs = 0; goto _out;}
453
448
  }
454
449
  break;
455
- #line 456 "edn_parser.cc"
450
+ #line 451 "edn_parser.cc"
456
451
  }
457
452
  }
458
453
 
459
454
  _out: {}
460
455
  }
461
456
 
462
- #line 239 "edn_parser.rl"
457
+ #line 234 "edn_parser.rl"
463
458
 
464
459
  if (cs >= EDN_string_first_final) {
465
- o = s;
466
460
  return p + 1;
467
461
  }
468
462
  else if (cs == EDN_string_error) {
@@ -478,7 +472,7 @@ case 7:
478
472
  // keyword parsing
479
473
  //
480
474
 
481
- #line 482 "edn_parser.cc"
475
+ #line 476 "edn_parser.cc"
482
476
  static const int EDN_keyword_start = 1;
483
477
  static const int EDN_keyword_first_final = 3;
484
478
  static const int EDN_keyword_error = 0;
@@ -486,24 +480,24 @@ static const int EDN_keyword_error = 0;
486
480
  static const int EDN_keyword_en_main = 1;
487
481
 
488
482
 
489
- #line 269 "edn_parser.rl"
483
+ #line 263 "edn_parser.rl"
490
484
 
491
485
 
492
486
 
493
- const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Object& o)
487
+ const char* edn::Parser::parse_keyword(const char *p, const char *pe, VALUE& v)
494
488
  {
495
489
  int cs;
496
490
 
497
491
 
498
- #line 499 "edn_parser.cc"
492
+ #line 493 "edn_parser.cc"
499
493
  {
500
494
  cs = EDN_keyword_start;
501
495
  }
502
496
 
503
- #line 277 "edn_parser.rl"
504
- p_save = p;
497
+ #line 271 "edn_parser.rl"
498
+ const char* p_save = p;
505
499
 
506
- #line 507 "edn_parser.cc"
500
+ #line 501 "edn_parser.cc"
507
501
  {
508
502
  if ( p == pe )
509
503
  goto _test_eof;
@@ -558,14 +552,14 @@ case 3:
558
552
  goto st3;
559
553
  goto tr3;
560
554
  tr3:
561
- #line 61 "edn_parser.rl"
555
+ #line 57 "edn_parser.rl"
562
556
  { p--; {p++; cs = 4; goto _out;} }
563
557
  goto st4;
564
558
  st4:
565
559
  if ( ++p == pe )
566
560
  goto _test_eof4;
567
561
  case 4:
568
- #line 569 "edn_parser.cc"
562
+ #line 563 "edn_parser.cc"
569
563
  goto st0;
570
564
  }
571
565
  _test_eof2: cs = 2; goto _test_eof;
@@ -576,14 +570,14 @@ case 4:
576
570
  _out: {}
577
571
  }
578
572
 
579
- #line 279 "edn_parser.rl"
573
+ #line 273 "edn_parser.rl"
580
574
 
581
575
  if (cs >= EDN_keyword_first_final) {
582
576
  std::string buf;
583
577
  uint32_t len = p - p_save;
584
- // don't include leading ':' because Rice::Symbol will handle it
578
+ // don't include leading ':' because the ruby symbol will handle it
585
579
  buf.append(p_save + 1, len - 1);
586
- o = Rice::Symbol(buf);
580
+ v = ID2SYM(rb_intern(buf.c_str()));
587
581
  return p;
588
582
  }
589
583
  else if (cs == EDN_keyword_error) {
@@ -600,31 +594,31 @@ case 4:
600
594
  // decimal parsing machine
601
595
  //
602
596
 
603
- #line 604 "edn_parser.cc"
597
+ #line 598 "edn_parser.cc"
604
598
  static const int EDN_decimal_start = 1;
605
599
  static const int EDN_decimal_first_final = 9;
606
600
 
607
601
  static const int EDN_decimal_en_main = 1;
608
602
 
609
603
 
610
- #line 312 "edn_parser.rl"
604
+ #line 306 "edn_parser.rl"
611
605
 
612
606
 
613
607
 
614
- const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Object& o)
608
+ const char* edn::Parser::parse_decimal(const char *p, const char *pe, VALUE& v)
615
609
  {
616
610
  int cs;
617
611
 
618
612
 
619
- #line 620 "edn_parser.cc"
613
+ #line 614 "edn_parser.cc"
620
614
  {
621
615
  cs = EDN_decimal_start;
622
616
  }
623
617
 
624
- #line 320 "edn_parser.rl"
625
- p_save = p;
618
+ #line 314 "edn_parser.rl"
619
+ const char* p_save = p;
626
620
 
627
- #line 628 "edn_parser.cc"
621
+ #line 622 "edn_parser.cc"
628
622
  {
629
623
  if ( p == pe )
630
624
  goto _test_eof;
@@ -678,14 +672,14 @@ case 9:
678
672
  goto st0;
679
673
  goto tr10;
680
674
  tr10:
681
- #line 61 "edn_parser.rl"
675
+ #line 57 "edn_parser.rl"
682
676
  { p--; {p++; cs = 10; goto _out;} }
683
677
  goto st10;
684
678
  st10:
685
679
  if ( ++p == pe )
686
680
  goto _test_eof10;
687
681
  case 10:
688
- #line 689 "edn_parser.cc"
682
+ #line 683 "edn_parser.cc"
689
683
  goto st0;
690
684
  st4:
691
685
  if ( ++p == pe )
@@ -801,10 +795,10 @@ case 8:
801
795
  _out: {}
802
796
  }
803
797
 
804
- #line 322 "edn_parser.rl"
798
+ #line 316 "edn_parser.rl"
805
799
 
806
800
  if (cs >= EDN_decimal_first_final) {
807
- o = Parser::float_to_ruby(p_save, p - p_save);
801
+ v = Parser::float_to_ruby(p_save, p - p_save);
808
802
  return p + 1;
809
803
  }
810
804
  else if (cs == EDN_decimal_en_main) {} // silence ragel warning
@@ -816,30 +810,30 @@ case 8:
816
810
  // integer parsing machine
817
811
  //
818
812
 
819
- #line 820 "edn_parser.cc"
813
+ #line 814 "edn_parser.cc"
820
814
  static const int EDN_integer_start = 1;
821
815
  static const int EDN_integer_first_final = 3;
822
816
 
823
817
  static const int EDN_integer_en_main = 1;
824
818
 
825
819
 
826
- #line 345 "edn_parser.rl"
820
+ #line 339 "edn_parser.rl"
827
821
 
828
822
 
829
- const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Object& o)
823
+ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
830
824
  {
831
825
  int cs;
832
826
 
833
827
 
834
- #line 835 "edn_parser.cc"
828
+ #line 829 "edn_parser.cc"
835
829
  {
836
830
  cs = EDN_integer_start;
837
831
  }
838
832
 
839
- #line 352 "edn_parser.rl"
840
- p_save = p;
833
+ #line 346 "edn_parser.rl"
834
+ const char* p_save = p;
841
835
 
842
- #line 843 "edn_parser.cc"
836
+ #line 837 "edn_parser.cc"
843
837
  {
844
838
  if ( p == pe )
845
839
  goto _test_eof;
@@ -881,14 +875,14 @@ case 3:
881
875
  goto st0;
882
876
  goto tr4;
883
877
  tr4:
884
- #line 61 "edn_parser.rl"
878
+ #line 57 "edn_parser.rl"
885
879
  { p--; {p++; cs = 4; goto _out;} }
886
880
  goto st4;
887
881
  st4:
888
882
  if ( ++p == pe )
889
883
  goto _test_eof4;
890
884
  case 4:
891
- #line 892 "edn_parser.cc"
885
+ #line 886 "edn_parser.cc"
892
886
  goto st0;
893
887
  st5:
894
888
  if ( ++p == pe )
@@ -929,10 +923,10 @@ case 6:
929
923
  _out: {}
930
924
  }
931
925
 
932
- #line 354 "edn_parser.rl"
926
+ #line 348 "edn_parser.rl"
933
927
 
934
928
  if (cs >= EDN_integer_first_final) {
935
- o = Parser::integer_to_ruby(p_save, p - p_save);
929
+ v = Parser::integer_to_ruby(p_save, p - p_save);
936
930
  return p + 1;
937
931
  }
938
932
  else if (cs == EDN_integer_en_main) {} // silence ragel warning
@@ -949,7 +943,7 @@ case 6:
949
943
  // 3. stand-alone operators: +, -, /, *, etc.
950
944
  //
951
945
 
952
- #line 953 "edn_parser.cc"
946
+ #line 947 "edn_parser.cc"
953
947
  static const int EDN_operator_start = 1;
954
948
  static const int EDN_operator_first_final = 3;
955
949
  static const int EDN_operator_error = 0;
@@ -957,24 +951,24 @@ static const int EDN_operator_error = 0;
957
951
  static const int EDN_operator_en_main = 1;
958
952
 
959
953
 
960
- #line 424 "edn_parser.rl"
954
+ #line 418 "edn_parser.rl"
961
955
 
962
956
 
963
957
 
964
- const char* edn::Parser::parse_operator(const char *p, const char *pe, Rice::Object& o)
958
+ const char* edn::Parser::parse_operator(const char *p, const char *pe, VALUE& v)
965
959
  {
966
960
  int cs;
967
961
 
968
962
 
969
- #line 970 "edn_parser.cc"
963
+ #line 964 "edn_parser.cc"
970
964
  {
971
965
  cs = EDN_operator_start;
972
966
  }
973
967
 
974
- #line 432 "edn_parser.rl"
975
- p_save = p;
968
+ #line 426 "edn_parser.rl"
969
+ const char* p_save = p;
976
970
 
977
- #line 978 "edn_parser.cc"
971
+ #line 972 "edn_parser.cc"
978
972
  {
979
973
  if ( p == pe )
980
974
  goto _test_eof;
@@ -1030,69 +1024,69 @@ case 3:
1030
1024
  goto st0;
1031
1025
  goto tr6;
1032
1026
  tr6:
1033
- #line 411 "edn_parser.rl"
1027
+ #line 405 "edn_parser.rl"
1034
1028
  {
1035
1029
  // stand-alone operators (-, +, /, ... etc)
1036
- std::string sym;
1037
- sym += *(p_save);
1038
- o = Parser::make_edn_symbol(sym);
1030
+ char op[2] = { *p_save, 0 };
1031
+ VALUE sym = rb_str_new2(op);
1032
+ v = Parser::make_edn_symbol(sym);
1039
1033
  }
1040
- #line 61 "edn_parser.rl"
1034
+ #line 57 "edn_parser.rl"
1041
1035
  { p--; {p++; cs = 4; goto _out;} }
1042
1036
  goto st4;
1043
1037
  tr10:
1044
- #line 61 "edn_parser.rl"
1038
+ #line 57 "edn_parser.rl"
1045
1039
  { p--; {p++; cs = 4; goto _out;} }
1046
1040
  goto st4;
1047
1041
  st4:
1048
1042
  if ( ++p == pe )
1049
1043
  goto _test_eof4;
1050
1044
  case 4:
1051
- #line 1052 "edn_parser.cc"
1045
+ #line 1046 "edn_parser.cc"
1052
1046
  goto st0;
1053
1047
  tr5:
1054
- #line 24 "edn_parser.rl"
1048
+ #line 20 "edn_parser.rl"
1055
1049
  { line_number++; }
1056
1050
  goto st5;
1057
1051
  tr7:
1058
- #line 411 "edn_parser.rl"
1052
+ #line 405 "edn_parser.rl"
1059
1053
  {
1060
1054
  // stand-alone operators (-, +, /, ... etc)
1061
- std::string sym;
1062
- sym += *(p_save);
1063
- o = Parser::make_edn_symbol(sym);
1055
+ char op[2] = { *p_save, 0 };
1056
+ VALUE sym = rb_str_new2(op);
1057
+ v = Parser::make_edn_symbol(sym);
1064
1058
  }
1065
- #line 61 "edn_parser.rl"
1059
+ #line 57 "edn_parser.rl"
1066
1060
  { p--; {p++; cs = 5; goto _out;} }
1067
1061
  goto st5;
1068
1062
  tr8:
1069
- #line 411 "edn_parser.rl"
1063
+ #line 405 "edn_parser.rl"
1070
1064
  {
1071
1065
  // stand-alone operators (-, +, /, ... etc)
1072
- std::string sym;
1073
- sym += *(p_save);
1074
- o = Parser::make_edn_symbol(sym);
1066
+ char op[2] = { *p_save, 0 };
1067
+ VALUE sym = rb_str_new2(op);
1068
+ v = Parser::make_edn_symbol(sym);
1075
1069
  }
1076
- #line 24 "edn_parser.rl"
1070
+ #line 20 "edn_parser.rl"
1077
1071
  { line_number++; }
1078
- #line 61 "edn_parser.rl"
1072
+ #line 57 "edn_parser.rl"
1079
1073
  { p--; {p++; cs = 5; goto _out;} }
1080
1074
  goto st5;
1081
1075
  tr11:
1082
- #line 61 "edn_parser.rl"
1076
+ #line 57 "edn_parser.rl"
1083
1077
  { p--; {p++; cs = 5; goto _out;} }
1084
1078
  goto st5;
1085
1079
  tr12:
1086
- #line 24 "edn_parser.rl"
1080
+ #line 20 "edn_parser.rl"
1087
1081
  { line_number++; }
1088
- #line 61 "edn_parser.rl"
1082
+ #line 57 "edn_parser.rl"
1089
1083
  { p--; {p++; cs = 5; goto _out;} }
1090
1084
  goto st5;
1091
1085
  st5:
1092
1086
  if ( ++p == pe )
1093
1087
  goto _test_eof5;
1094
1088
  case 5:
1095
- #line 1096 "edn_parser.cc"
1089
+ #line 1090 "edn_parser.cc"
1096
1090
  switch( (*p) ) {
1097
1091
  case 10: goto tr12;
1098
1092
  case 32: goto tr11;
@@ -1120,25 +1114,25 @@ case 5:
1120
1114
  goto st0;
1121
1115
  goto tr10;
1122
1116
  tr9:
1123
- #line 411 "edn_parser.rl"
1117
+ #line 405 "edn_parser.rl"
1124
1118
  {
1125
1119
  // stand-alone operators (-, +, /, ... etc)
1126
- std::string sym;
1127
- sym += *(p_save);
1128
- o = Parser::make_edn_symbol(sym);
1120
+ char op[2] = { *p_save, 0 };
1121
+ VALUE sym = rb_str_new2(op);
1122
+ v = Parser::make_edn_symbol(sym);
1129
1123
  }
1130
- #line 61 "edn_parser.rl"
1124
+ #line 57 "edn_parser.rl"
1131
1125
  { p--; {p++; cs = 6; goto _out;} }
1132
1126
  goto st6;
1133
1127
  tr13:
1134
- #line 61 "edn_parser.rl"
1128
+ #line 57 "edn_parser.rl"
1135
1129
  { p--; {p++; cs = 6; goto _out;} }
1136
1130
  goto st6;
1137
1131
  st6:
1138
1132
  if ( ++p == pe )
1139
1133
  goto _test_eof6;
1140
1134
  case 6:
1141
- #line 1142 "edn_parser.cc"
1135
+ #line 1136 "edn_parser.cc"
1142
1136
  if ( (*p) == 10 )
1143
1137
  goto tr5;
1144
1138
  goto st2;
@@ -1183,17 +1177,17 @@ case 7:
1183
1177
  goto tr14;
1184
1178
  goto tr6;
1185
1179
  tr14:
1186
- #line 388 "edn_parser.rl"
1180
+ #line 382 "edn_parser.rl"
1187
1181
  {
1188
1182
  // parse a number with the leading symbol - this is slightly
1189
1183
  // different than the one within EDN_value since it includes
1190
1184
  // the leading - or +
1191
1185
  //
1192
1186
  // try to parse a decimal first
1193
- const char *np = parse_decimal(p_save, pe, o);
1187
+ const char *np = parse_decimal(p_save, pe, v);
1194
1188
  if (np == NULL) {
1195
1189
  // if we can't, try to parse it as an int
1196
- np = parse_integer(p_save, pe, o);
1190
+ np = parse_integer(p_save, pe, v);
1197
1191
  }
1198
1192
 
1199
1193
  if (np) {
@@ -1208,13 +1202,13 @@ tr14:
1208
1202
  }
1209
1203
  goto st8;
1210
1204
  tr15:
1211
- #line 378 "edn_parser.rl"
1205
+ #line 372 "edn_parser.rl"
1212
1206
  {
1213
1207
  // parse a symbol including the leading operator (-, +, .)
1214
- std::string sym;
1208
+ VALUE sym = Qnil;
1215
1209
  const char *np = parse_symbol(p_save, pe, sym);
1216
1210
  if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else {
1217
- o = Parser::make_edn_symbol(sym);
1211
+ v = Parser::make_edn_symbol(sym);
1218
1212
  {p = (( np))-1;}
1219
1213
  }
1220
1214
  }
@@ -1223,7 +1217,7 @@ st8:
1223
1217
  if ( ++p == pe )
1224
1218
  goto _test_eof8;
1225
1219
  case 8:
1226
- #line 1227 "edn_parser.cc"
1220
+ #line 1221 "edn_parser.cc"
1227
1221
  switch( (*p) ) {
1228
1222
  case 33: goto st0;
1229
1223
  case 95: goto st0;
@@ -1293,22 +1287,22 @@ case 9:
1293
1287
  case 3:
1294
1288
  case 7:
1295
1289
  case 9:
1296
- #line 411 "edn_parser.rl"
1290
+ #line 405 "edn_parser.rl"
1297
1291
  {
1298
1292
  // stand-alone operators (-, +, /, ... etc)
1299
- std::string sym;
1300
- sym += *(p_save);
1301
- o = Parser::make_edn_symbol(sym);
1293
+ char op[2] = { *p_save, 0 };
1294
+ VALUE sym = rb_str_new2(op);
1295
+ v = Parser::make_edn_symbol(sym);
1302
1296
  }
1303
1297
  break;
1304
- #line 1305 "edn_parser.cc"
1298
+ #line 1299 "edn_parser.cc"
1305
1299
  }
1306
1300
  }
1307
1301
 
1308
1302
  _out: {}
1309
1303
  }
1310
1304
 
1311
- #line 434 "edn_parser.rl"
1305
+ #line 428 "edn_parser.rl"
1312
1306
 
1313
1307
  if (cs >= EDN_operator_first_final) {
1314
1308
  return p;
@@ -1327,7 +1321,7 @@ case 9:
1327
1321
  // escaped char parsing - handles \c, \newline, \formfeed, etc.
1328
1322
  //
1329
1323
 
1330
- #line 1331 "edn_parser.cc"
1324
+ #line 1325 "edn_parser.cc"
1331
1325
  static const int EDN_escaped_char_start = 1;
1332
1326
  static const int EDN_escaped_char_first_final = 4;
1333
1327
  static const int EDN_escaped_char_error = 0;
@@ -1335,24 +1329,24 @@ static const int EDN_escaped_char_error = 0;
1335
1329
  static const int EDN_escaped_char_en_main = 1;
1336
1330
 
1337
1331
 
1338
- #line 463 "edn_parser.rl"
1332
+ #line 457 "edn_parser.rl"
1339
1333
 
1340
1334
 
1341
1335
 
1342
- const char* edn::Parser::parse_esc_char(const char *p, const char *pe, Rice::Object& o)
1336
+ const char* edn::Parser::parse_esc_char(const char *p, const char *pe, VALUE& v)
1343
1337
  {
1344
1338
  int cs;
1345
1339
 
1346
1340
 
1347
- #line 1348 "edn_parser.cc"
1341
+ #line 1342 "edn_parser.cc"
1348
1342
  {
1349
1343
  cs = EDN_escaped_char_start;
1350
1344
  }
1351
1345
 
1352
- #line 471 "edn_parser.rl"
1353
- p_save = p;
1346
+ #line 465 "edn_parser.rl"
1347
+ const char* p_save = p;
1354
1348
 
1355
- #line 1356 "edn_parser.cc"
1349
+ #line 1350 "edn_parser.cc"
1356
1350
  {
1357
1351
  if ( p == pe )
1358
1352
  goto _test_eof;
@@ -1396,34 +1390,34 @@ case 4:
1396
1390
  goto st4;
1397
1391
  goto tr5;
1398
1392
  tr5:
1399
- #line 61 "edn_parser.rl"
1393
+ #line 57 "edn_parser.rl"
1400
1394
  { p--; {p++; cs = 5; goto _out;} }
1401
1395
  goto st5;
1402
1396
  st5:
1403
1397
  if ( ++p == pe )
1404
1398
  goto _test_eof5;
1405
1399
  case 5:
1406
- #line 1407 "edn_parser.cc"
1400
+ #line 1401 "edn_parser.cc"
1407
1401
  goto st0;
1408
1402
  tr4:
1409
- #line 24 "edn_parser.rl"
1403
+ #line 20 "edn_parser.rl"
1410
1404
  { line_number++; }
1411
1405
  goto st6;
1412
1406
  tr6:
1413
- #line 61 "edn_parser.rl"
1407
+ #line 57 "edn_parser.rl"
1414
1408
  { p--; {p++; cs = 6; goto _out;} }
1415
1409
  goto st6;
1416
1410
  tr7:
1417
- #line 24 "edn_parser.rl"
1411
+ #line 20 "edn_parser.rl"
1418
1412
  { line_number++; }
1419
- #line 61 "edn_parser.rl"
1413
+ #line 57 "edn_parser.rl"
1420
1414
  { p--; {p++; cs = 6; goto _out;} }
1421
1415
  goto st6;
1422
1416
  st6:
1423
1417
  if ( ++p == pe )
1424
1418
  goto _test_eof6;
1425
1419
  case 6:
1426
- #line 1427 "edn_parser.cc"
1420
+ #line 1421 "edn_parser.cc"
1427
1421
  switch( (*p) ) {
1428
1422
  case 10: goto tr7;
1429
1423
  case 32: goto tr6;
@@ -1441,14 +1435,14 @@ case 6:
1441
1435
  goto st0;
1442
1436
  goto tr5;
1443
1437
  tr8:
1444
- #line 61 "edn_parser.rl"
1438
+ #line 57 "edn_parser.rl"
1445
1439
  { p--; {p++; cs = 7; goto _out;} }
1446
1440
  goto st7;
1447
1441
  st7:
1448
1442
  if ( ++p == pe )
1449
1443
  goto _test_eof7;
1450
1444
  case 7:
1451
- #line 1452 "edn_parser.cc"
1445
+ #line 1446 "edn_parser.cc"
1452
1446
  if ( (*p) == 10 )
1453
1447
  goto tr4;
1454
1448
  goto st3;
@@ -1471,11 +1465,11 @@ case 3:
1471
1465
  _out: {}
1472
1466
  }
1473
1467
 
1474
- #line 473 "edn_parser.rl"
1468
+ #line 467 "edn_parser.rl"
1475
1469
 
1476
1470
  if (cs >= EDN_escaped_char_first_final) {
1477
1471
  // convert the escaped value to a character
1478
- if (!Parser::parse_escaped_char(p_save + 1, p, o)) {
1472
+ if (!Parser::parse_escaped_char(p_save + 1, p, v)) {
1479
1473
  return pe;
1480
1474
  }
1481
1475
  return p;
@@ -1496,8 +1490,9 @@ case 3:
1496
1490
  // character and an optional leading operator (name, -today,
1497
1491
  // .yesterday)
1498
1492
  //
1493
+ //
1499
1494
 
1500
- #line 1501 "edn_parser.cc"
1495
+ #line 1496 "edn_parser.cc"
1501
1496
  static const int EDN_symbol_start = 1;
1502
1497
  static const int EDN_symbol_first_final = 5;
1503
1498
  static const int EDN_symbol_error = 0;
@@ -1505,24 +1500,24 @@ static const int EDN_symbol_error = 0;
1505
1500
  static const int EDN_symbol_en_main = 1;
1506
1501
 
1507
1502
 
1508
- #line 507 "edn_parser.rl"
1503
+ #line 502 "edn_parser.rl"
1509
1504
 
1510
1505
 
1511
1506
 
1512
- const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string& sym)
1507
+ const char* edn::Parser::parse_symbol(const char *p, const char *pe, VALUE& s)
1513
1508
  {
1514
1509
  int cs;
1515
1510
 
1516
1511
 
1517
- #line 1518 "edn_parser.cc"
1512
+ #line 1513 "edn_parser.cc"
1518
1513
  {
1519
1514
  cs = EDN_symbol_start;
1520
1515
  }
1521
1516
 
1522
- #line 515 "edn_parser.rl"
1523
- p_save = p;
1517
+ #line 510 "edn_parser.rl"
1518
+ const char* p_save = p;
1524
1519
 
1525
- #line 1526 "edn_parser.cc"
1520
+ #line 1521 "edn_parser.cc"
1526
1521
  {
1527
1522
  if ( p == pe )
1528
1523
  goto _test_eof;
@@ -1600,34 +1595,34 @@ case 5:
1600
1595
  goto st5;
1601
1596
  goto tr6;
1602
1597
  tr6:
1603
- #line 61 "edn_parser.rl"
1598
+ #line 57 "edn_parser.rl"
1604
1599
  { p--; {p++; cs = 6; goto _out;} }
1605
1600
  goto st6;
1606
1601
  st6:
1607
1602
  if ( ++p == pe )
1608
1603
  goto _test_eof6;
1609
1604
  case 6:
1610
- #line 1611 "edn_parser.cc"
1605
+ #line 1606 "edn_parser.cc"
1611
1606
  goto st0;
1612
1607
  tr4:
1613
- #line 24 "edn_parser.rl"
1608
+ #line 20 "edn_parser.rl"
1614
1609
  { line_number++; }
1615
1610
  goto st7;
1616
1611
  tr7:
1617
- #line 61 "edn_parser.rl"
1612
+ #line 57 "edn_parser.rl"
1618
1613
  { p--; {p++; cs = 7; goto _out;} }
1619
1614
  goto st7;
1620
1615
  tr8:
1621
- #line 24 "edn_parser.rl"
1616
+ #line 20 "edn_parser.rl"
1622
1617
  { line_number++; }
1623
- #line 61 "edn_parser.rl"
1618
+ #line 57 "edn_parser.rl"
1624
1619
  { p--; {p++; cs = 7; goto _out;} }
1625
1620
  goto st7;
1626
1621
  st7:
1627
1622
  if ( ++p == pe )
1628
1623
  goto _test_eof7;
1629
1624
  case 7:
1630
- #line 1631 "edn_parser.cc"
1625
+ #line 1626 "edn_parser.cc"
1631
1626
  switch( (*p) ) {
1632
1627
  case 10: goto tr8;
1633
1628
  case 32: goto tr7;
@@ -1652,14 +1647,14 @@ case 7:
1652
1647
  goto st0;
1653
1648
  goto tr6;
1654
1649
  tr10:
1655
- #line 61 "edn_parser.rl"
1650
+ #line 57 "edn_parser.rl"
1656
1651
  { p--; {p++; cs = 8; goto _out;} }
1657
1652
  goto st8;
1658
1653
  st8:
1659
1654
  if ( ++p == pe )
1660
1655
  goto _test_eof8;
1661
1656
  case 8:
1662
- #line 1663 "edn_parser.cc"
1657
+ #line 1658 "edn_parser.cc"
1663
1658
  if ( (*p) == 10 )
1664
1659
  goto tr4;
1665
1660
  goto st3;
@@ -1729,12 +1724,13 @@ case 9:
1729
1724
  _out: {}
1730
1725
  }
1731
1726
 
1732
- #line 517 "edn_parser.rl"
1727
+ #line 512 "edn_parser.rl"
1733
1728
 
1734
1729
  if (cs >= EDN_symbol_first_final) {
1735
1730
  // copy the symbol text
1736
- sym.clear();
1737
- sym.append(p_save, p - p_save);
1731
+ if (s == Qnil)
1732
+ s = rb_str_new2("");
1733
+ rb_str_cat(s, p_save, p - p_save);
1738
1734
  return p;
1739
1735
  }
1740
1736
  else if (cs == EDN_symbol_error) {
@@ -1749,18 +1745,18 @@ case 9:
1749
1745
 
1750
1746
  // ============================================================
1751
1747
  // EDN_sequence_common is used to parse EDN containers - elements are
1752
- // initially stored in a rice array and then the final corresponding
1748
+ // initially stored in an array and then the final corresponding
1753
1749
  // container is built from the list (although, for vectors, lists, and
1754
1750
  // sets the same array is used)
1755
1751
  //
1756
1752
 
1757
- #line 572 "edn_parser.rl"
1753
+ #line 568 "edn_parser.rl"
1758
1754
 
1759
1755
 
1760
1756
  //
1761
1757
  // vector-specific machine
1762
1758
 
1763
- #line 1764 "edn_parser.cc"
1759
+ #line 1760 "edn_parser.cc"
1764
1760
  static const int EDN_vector_start = 1;
1765
1761
  static const int EDN_vector_first_final = 4;
1766
1762
  static const int EDN_vector_error = 0;
@@ -1768,29 +1764,29 @@ static const int EDN_vector_error = 0;
1768
1764
  static const int EDN_vector_en_main = 1;
1769
1765
 
1770
1766
 
1771
- #line 588 "edn_parser.rl"
1767
+ #line 584 "edn_parser.rl"
1772
1768
 
1773
1769
 
1774
1770
 
1775
1771
  //
1776
1772
  // vector parsing
1777
1773
  //
1778
- const char* edn::Parser::parse_vector(const char *p, const char *pe, Rice::Object& o)
1774
+ const char* edn::Parser::parse_vector(const char *p, const char *pe, VALUE& v)
1779
1775
  {
1780
1776
  static const char* EDN_TYPE = "vector";
1781
1777
 
1782
1778
  int cs;
1783
- Rice::Array elems; // will store the vector's elements
1779
+ VALUE elems = rb_ary_new(); // will store the vector's elements
1784
1780
 
1785
1781
 
1786
- #line 1787 "edn_parser.cc"
1782
+ #line 1783 "edn_parser.cc"
1787
1783
  {
1788
1784
  cs = EDN_vector_start;
1789
1785
  }
1790
1786
 
1791
- #line 602 "edn_parser.rl"
1787
+ #line 598 "edn_parser.rl"
1792
1788
 
1793
- #line 1794 "edn_parser.cc"
1789
+ #line 1790 "edn_parser.cc"
1794
1790
  {
1795
1791
  if ( p == pe )
1796
1792
  goto _test_eof;
@@ -1801,7 +1797,7 @@ case 1:
1801
1797
  goto st2;
1802
1798
  goto st0;
1803
1799
  tr2:
1804
- #line 54 "edn_parser.rl"
1800
+ #line 50 "edn_parser.rl"
1805
1801
  {
1806
1802
  std::stringstream s;
1807
1803
  s << "unterminated " << EDN_TYPE;
@@ -1809,22 +1805,22 @@ tr2:
1809
1805
  p--; {p++; cs = 0; goto _out;}
1810
1806
  }
1811
1807
  goto st0;
1812
- #line 1813 "edn_parser.cc"
1808
+ #line 1809 "edn_parser.cc"
1813
1809
  st0:
1814
1810
  cs = 0;
1815
1811
  goto _out;
1816
1812
  tr3:
1817
- #line 24 "edn_parser.rl"
1813
+ #line 20 "edn_parser.rl"
1818
1814
  { line_number++; }
1819
1815
  goto st2;
1820
1816
  tr4:
1821
- #line 544 "edn_parser.rl"
1817
+ #line 540 "edn_parser.rl"
1822
1818
  {
1823
1819
  // reads an item within a sequence (vector, list, map, or
1824
1820
  // set). Regardless of the sequence type, an array of the
1825
1821
  // items is built. Once done, the sequence parser will convert
1826
1822
  // if needed
1827
- Rice::Object e;
1823
+ VALUE e;
1828
1824
  const char *np = parse_value(p, pe, e);
1829
1825
  if (np == NULL) {
1830
1826
  p--; {p++; cs = 2; goto _out;}
@@ -1838,7 +1834,7 @@ tr4:
1838
1834
  else {
1839
1835
  // otherwise we add it to the list of elements for the
1840
1836
  // corresponding container
1841
- elems.push(e);
1837
+ rb_ary_push(elems, e);
1842
1838
  }
1843
1839
  {p = (( np))-1;}
1844
1840
  }
@@ -1848,7 +1844,7 @@ st2:
1848
1844
  if ( ++p == pe )
1849
1845
  goto _test_eof2;
1850
1846
  case 2:
1851
- #line 1852 "edn_parser.cc"
1847
+ #line 1848 "edn_parser.cc"
1852
1848
  switch( (*p) ) {
1853
1849
  case 10: goto tr3;
1854
1850
  case 32: goto st2;
@@ -1881,14 +1877,14 @@ case 3:
1881
1877
  goto tr3;
1882
1878
  goto st3;
1883
1879
  tr6:
1884
- #line 61 "edn_parser.rl"
1880
+ #line 57 "edn_parser.rl"
1885
1881
  { p--; {p++; cs = 4; goto _out;} }
1886
1882
  goto st4;
1887
1883
  st4:
1888
1884
  if ( ++p == pe )
1889
1885
  goto _test_eof4;
1890
1886
  case 4:
1891
- #line 1892 "edn_parser.cc"
1887
+ #line 1888 "edn_parser.cc"
1892
1888
  goto st0;
1893
1889
  }
1894
1890
  _test_eof2: cs = 2; goto _test_eof;
@@ -1901,7 +1897,7 @@ case 4:
1901
1897
  switch ( cs ) {
1902
1898
  case 2:
1903
1899
  case 3:
1904
- #line 54 "edn_parser.rl"
1900
+ #line 50 "edn_parser.rl"
1905
1901
  {
1906
1902
  std::stringstream s;
1907
1903
  s << "unterminated " << EDN_TYPE;
@@ -1909,17 +1905,17 @@ case 4:
1909
1905
  p--; {p++; cs = 0; goto _out;}
1910
1906
  }
1911
1907
  break;
1912
- #line 1913 "edn_parser.cc"
1908
+ #line 1909 "edn_parser.cc"
1913
1909
  }
1914
1910
  }
1915
1911
 
1916
1912
  _out: {}
1917
1913
  }
1918
1914
 
1919
- #line 603 "edn_parser.rl"
1915
+ #line 599 "edn_parser.rl"
1920
1916
 
1921
1917
  if (cs >= EDN_vector_first_final) {
1922
- o = elems;
1918
+ v = elems;
1923
1919
  return p + 1;
1924
1920
  }
1925
1921
  else if (cs == EDN_vector_error) {
@@ -1936,7 +1932,7 @@ case 4:
1936
1932
  // list parsing machine
1937
1933
  //
1938
1934
 
1939
- #line 1940 "edn_parser.cc"
1935
+ #line 1936 "edn_parser.cc"
1940
1936
  static const int EDN_list_start = 1;
1941
1937
  static const int EDN_list_first_final = 4;
1942
1938
  static const int EDN_list_error = 0;
@@ -1944,28 +1940,28 @@ static const int EDN_list_error = 0;
1944
1940
  static const int EDN_list_en_main = 1;
1945
1941
 
1946
1942
 
1947
- #line 632 "edn_parser.rl"
1943
+ #line 628 "edn_parser.rl"
1948
1944
 
1949
1945
 
1950
1946
  //
1951
1947
  // list parsing
1952
1948
  //
1953
- const char* edn::Parser::parse_list(const char *p, const char *pe, Rice::Object& o)
1949
+ const char* edn::Parser::parse_list(const char *p, const char *pe, VALUE& v)
1954
1950
  {
1955
1951
  static const char* EDN_TYPE = "list";
1956
1952
 
1957
1953
  int cs;
1958
- Rice::Array elems;
1954
+ VALUE elems = rb_ary_new();
1959
1955
 
1960
1956
 
1961
- #line 1962 "edn_parser.cc"
1957
+ #line 1958 "edn_parser.cc"
1962
1958
  {
1963
1959
  cs = EDN_list_start;
1964
1960
  }
1965
1961
 
1966
- #line 645 "edn_parser.rl"
1962
+ #line 641 "edn_parser.rl"
1967
1963
 
1968
- #line 1969 "edn_parser.cc"
1964
+ #line 1965 "edn_parser.cc"
1969
1965
  {
1970
1966
  if ( p == pe )
1971
1967
  goto _test_eof;
@@ -1976,7 +1972,7 @@ case 1:
1976
1972
  goto st2;
1977
1973
  goto st0;
1978
1974
  tr2:
1979
- #line 54 "edn_parser.rl"
1975
+ #line 50 "edn_parser.rl"
1980
1976
  {
1981
1977
  std::stringstream s;
1982
1978
  s << "unterminated " << EDN_TYPE;
@@ -1984,22 +1980,22 @@ tr2:
1984
1980
  p--; {p++; cs = 0; goto _out;}
1985
1981
  }
1986
1982
  goto st0;
1987
- #line 1988 "edn_parser.cc"
1983
+ #line 1984 "edn_parser.cc"
1988
1984
  st0:
1989
1985
  cs = 0;
1990
1986
  goto _out;
1991
1987
  tr3:
1992
- #line 24 "edn_parser.rl"
1988
+ #line 20 "edn_parser.rl"
1993
1989
  { line_number++; }
1994
1990
  goto st2;
1995
1991
  tr4:
1996
- #line 544 "edn_parser.rl"
1992
+ #line 540 "edn_parser.rl"
1997
1993
  {
1998
1994
  // reads an item within a sequence (vector, list, map, or
1999
1995
  // set). Regardless of the sequence type, an array of the
2000
1996
  // items is built. Once done, the sequence parser will convert
2001
1997
  // if needed
2002
- Rice::Object e;
1998
+ VALUE e;
2003
1999
  const char *np = parse_value(p, pe, e);
2004
2000
  if (np == NULL) {
2005
2001
  p--; {p++; cs = 2; goto _out;}
@@ -2013,7 +2009,7 @@ tr4:
2013
2009
  else {
2014
2010
  // otherwise we add it to the list of elements for the
2015
2011
  // corresponding container
2016
- elems.push(e);
2012
+ rb_ary_push(elems, e);
2017
2013
  }
2018
2014
  {p = (( np))-1;}
2019
2015
  }
@@ -2023,7 +2019,7 @@ st2:
2023
2019
  if ( ++p == pe )
2024
2020
  goto _test_eof2;
2025
2021
  case 2:
2026
- #line 2027 "edn_parser.cc"
2022
+ #line 2023 "edn_parser.cc"
2027
2023
  switch( (*p) ) {
2028
2024
  case 10: goto tr3;
2029
2025
  case 32: goto st2;
@@ -2048,14 +2044,14 @@ case 2:
2048
2044
  goto tr4;
2049
2045
  goto tr2;
2050
2046
  tr5:
2051
- #line 61 "edn_parser.rl"
2047
+ #line 57 "edn_parser.rl"
2052
2048
  { p--; {p++; cs = 4; goto _out;} }
2053
2049
  goto st4;
2054
2050
  st4:
2055
2051
  if ( ++p == pe )
2056
2052
  goto _test_eof4;
2057
2053
  case 4:
2058
- #line 2059 "edn_parser.cc"
2054
+ #line 2055 "edn_parser.cc"
2059
2055
  goto st0;
2060
2056
  st3:
2061
2057
  if ( ++p == pe )
@@ -2075,7 +2071,7 @@ case 3:
2075
2071
  switch ( cs ) {
2076
2072
  case 2:
2077
2073
  case 3:
2078
- #line 54 "edn_parser.rl"
2074
+ #line 50 "edn_parser.rl"
2079
2075
  {
2080
2076
  std::stringstream s;
2081
2077
  s << "unterminated " << EDN_TYPE;
@@ -2083,17 +2079,17 @@ case 3:
2083
2079
  p--; {p++; cs = 0; goto _out;}
2084
2080
  }
2085
2081
  break;
2086
- #line 2087 "edn_parser.cc"
2082
+ #line 2083 "edn_parser.cc"
2087
2083
  }
2088
2084
  }
2089
2085
 
2090
2086
  _out: {}
2091
2087
  }
2092
2088
 
2093
- #line 646 "edn_parser.rl"
2089
+ #line 642 "edn_parser.rl"
2094
2090
 
2095
2091
  if (cs >= EDN_list_first_final) {
2096
- o = elems;
2092
+ v = elems;
2097
2093
  return p + 1;
2098
2094
  }
2099
2095
  else if (cs == EDN_list_error) {
@@ -2110,7 +2106,7 @@ case 3:
2110
2106
  // hash parsing
2111
2107
  //
2112
2108
 
2113
- #line 2114 "edn_parser.cc"
2109
+ #line 2110 "edn_parser.cc"
2114
2110
  static const int EDN_map_start = 1;
2115
2111
  static const int EDN_map_first_final = 4;
2116
2112
  static const int EDN_map_error = 0;
@@ -2118,28 +2114,28 @@ static const int EDN_map_error = 0;
2118
2114
  static const int EDN_map_en_main = 1;
2119
2115
 
2120
2116
 
2121
- #line 676 "edn_parser.rl"
2117
+ #line 672 "edn_parser.rl"
2122
2118
 
2123
2119
 
2124
2120
 
2125
- const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object& o)
2121
+ const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
2126
2122
  {
2127
2123
  static const char* EDN_TYPE = "map";
2128
2124
 
2129
2125
  int cs;
2130
2126
  // since we don't know whether we're looking at a key or value,
2131
2127
  // initially store all elements in a list
2132
- Rice::Array elems;
2128
+ VALUE elems = rb_ary_new();
2133
2129
 
2134
2130
 
2135
- #line 2136 "edn_parser.cc"
2131
+ #line 2132 "edn_parser.cc"
2136
2132
  {
2137
2133
  cs = EDN_map_start;
2138
2134
  }
2139
2135
 
2140
- #line 689 "edn_parser.rl"
2136
+ #line 685 "edn_parser.rl"
2141
2137
 
2142
- #line 2143 "edn_parser.cc"
2138
+ #line 2139 "edn_parser.cc"
2143
2139
  {
2144
2140
  if ( p == pe )
2145
2141
  goto _test_eof;
@@ -2150,7 +2146,7 @@ case 1:
2150
2146
  goto st2;
2151
2147
  goto st0;
2152
2148
  tr2:
2153
- #line 54 "edn_parser.rl"
2149
+ #line 50 "edn_parser.rl"
2154
2150
  {
2155
2151
  std::stringstream s;
2156
2152
  s << "unterminated " << EDN_TYPE;
@@ -2158,22 +2154,22 @@ tr2:
2158
2154
  p--; {p++; cs = 0; goto _out;}
2159
2155
  }
2160
2156
  goto st0;
2161
- #line 2162 "edn_parser.cc"
2157
+ #line 2158 "edn_parser.cc"
2162
2158
  st0:
2163
2159
  cs = 0;
2164
2160
  goto _out;
2165
2161
  tr3:
2166
- #line 24 "edn_parser.rl"
2162
+ #line 20 "edn_parser.rl"
2167
2163
  { line_number++; }
2168
2164
  goto st2;
2169
2165
  tr4:
2170
- #line 544 "edn_parser.rl"
2166
+ #line 540 "edn_parser.rl"
2171
2167
  {
2172
2168
  // reads an item within a sequence (vector, list, map, or
2173
2169
  // set). Regardless of the sequence type, an array of the
2174
2170
  // items is built. Once done, the sequence parser will convert
2175
2171
  // if needed
2176
- Rice::Object e;
2172
+ VALUE e;
2177
2173
  const char *np = parse_value(p, pe, e);
2178
2174
  if (np == NULL) {
2179
2175
  p--; {p++; cs = 2; goto _out;}
@@ -2187,7 +2183,7 @@ tr4:
2187
2183
  else {
2188
2184
  // otherwise we add it to the list of elements for the
2189
2185
  // corresponding container
2190
- elems.push(e);
2186
+ rb_ary_push(elems, e);
2191
2187
  }
2192
2188
  {p = (( np))-1;}
2193
2189
  }
@@ -2197,7 +2193,7 @@ st2:
2197
2193
  if ( ++p == pe )
2198
2194
  goto _test_eof2;
2199
2195
  case 2:
2200
- #line 2201 "edn_parser.cc"
2196
+ #line 2197 "edn_parser.cc"
2201
2197
  switch( (*p) ) {
2202
2198
  case 10: goto tr3;
2203
2199
  case 32: goto st2;
@@ -2230,14 +2226,14 @@ case 3:
2230
2226
  goto tr3;
2231
2227
  goto st3;
2232
2228
  tr6:
2233
- #line 61 "edn_parser.rl"
2229
+ #line 57 "edn_parser.rl"
2234
2230
  { p--; {p++; cs = 4; goto _out;} }
2235
2231
  goto st4;
2236
2232
  st4:
2237
2233
  if ( ++p == pe )
2238
2234
  goto _test_eof4;
2239
2235
  case 4:
2240
- #line 2241 "edn_parser.cc"
2236
+ #line 2237 "edn_parser.cc"
2241
2237
  goto st0;
2242
2238
  }
2243
2239
  _test_eof2: cs = 2; goto _test_eof;
@@ -2250,7 +2246,7 @@ case 4:
2250
2246
  switch ( cs ) {
2251
2247
  case 2:
2252
2248
  case 3:
2253
- #line 54 "edn_parser.rl"
2249
+ #line 50 "edn_parser.rl"
2254
2250
  {
2255
2251
  std::stringstream s;
2256
2252
  s << "unterminated " << EDN_TYPE;
@@ -2258,32 +2254,32 @@ case 4:
2258
2254
  p--; {p++; cs = 0; goto _out;}
2259
2255
  }
2260
2256
  break;
2261
- #line 2262 "edn_parser.cc"
2257
+ #line 2258 "edn_parser.cc"
2262
2258
  }
2263
2259
  }
2264
2260
 
2265
2261
  _out: {}
2266
2262
  }
2267
2263
 
2268
- #line 690 "edn_parser.rl"
2264
+ #line 686 "edn_parser.rl"
2269
2265
 
2270
2266
  if (cs >= EDN_map_first_final) {
2271
2267
 
2272
2268
  // hash parsing is done. Make sure we have an even count
2273
- if ((elems.size() % 2) != 0) {
2269
+ if ((RARRAY_LEN(elems) % 2) != 0) {
2274
2270
  error(__FUNCTION__, "odd number of elements in map");
2275
2271
  return pe;
2276
2272
  }
2277
2273
 
2278
2274
  // now convert the sequence to a hash
2279
- Rice::Hash rslt;
2280
- while (elems.size())
2275
+ VALUE rslt = rb_hash_new();
2276
+ while (RARRAY_LEN(elems) > 0)
2281
2277
  {
2282
- Rice::Object k = elems.shift();
2283
- rslt[k] = elems.shift();
2278
+ VALUE k = rb_ary_shift(elems);
2279
+ rb_hash_aset(rslt, k, rb_ary_shift(elems));
2284
2280
  }
2285
2281
 
2286
- o = rslt;
2282
+ v = rslt;
2287
2283
  return p + 1;
2288
2284
  }
2289
2285
  else if (cs == EDN_map_error) {
@@ -2301,7 +2297,7 @@ case 4:
2301
2297
  // the remaining data to the correct parser
2302
2298
  //
2303
2299
 
2304
- #line 2305 "edn_parser.cc"
2300
+ #line 2301 "edn_parser.cc"
2305
2301
  static const int EDN_dispatch_start = 1;
2306
2302
  static const int EDN_dispatch_first_final = 2;
2307
2303
  static const int EDN_dispatch_error = 0;
@@ -2309,23 +2305,23 @@ static const int EDN_dispatch_error = 0;
2309
2305
  static const int EDN_dispatch_en_main = 1;
2310
2306
 
2311
2307
 
2312
- #line 754 "edn_parser.rl"
2308
+ #line 750 "edn_parser.rl"
2313
2309
 
2314
2310
 
2315
2311
 
2316
- const char* edn::Parser::parse_dispatch(const char *p, const char *pe, Rice::Object& o)
2312
+ const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
2317
2313
  {
2318
2314
  int cs;
2319
2315
 
2320
2316
 
2321
- #line 2322 "edn_parser.cc"
2317
+ #line 2318 "edn_parser.cc"
2322
2318
  {
2323
2319
  cs = EDN_dispatch_start;
2324
2320
  }
2325
2321
 
2326
- #line 762 "edn_parser.rl"
2322
+ #line 758 "edn_parser.rl"
2327
2323
 
2328
- #line 2329 "edn_parser.cc"
2324
+ #line 2325 "edn_parser.cc"
2329
2325
  {
2330
2326
  if ( p == pe )
2331
2327
  goto _test_eof;
@@ -2346,40 +2342,40 @@ st0:
2346
2342
  cs = 0;
2347
2343
  goto _out;
2348
2344
  tr0:
2349
- #line 742 "edn_parser.rl"
2345
+ #line 738 "edn_parser.rl"
2350
2346
  {
2351
2347
  // #inst, #uuid, or #user/tag
2352
- const char *np = parse_tagged(p, pe, o);
2348
+ const char *np = parse_tagged(p, pe, v);
2353
2349
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
2354
2350
  }
2355
- #line 61 "edn_parser.rl"
2351
+ #line 57 "edn_parser.rl"
2356
2352
  { p--; {p++; cs = 2; goto _out;} }
2357
2353
  goto st2;
2358
2354
  tr2:
2359
- #line 736 "edn_parser.rl"
2355
+ #line 732 "edn_parser.rl"
2360
2356
  {
2361
2357
  // discard token #_
2362
2358
  const char *np = parse_discard(p, pe);
2363
2359
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
2364
2360
  }
2365
- #line 61 "edn_parser.rl"
2361
+ #line 57 "edn_parser.rl"
2366
2362
  { p--; {p++; cs = 2; goto _out;} }
2367
2363
  goto st2;
2368
2364
  tr3:
2369
- #line 730 "edn_parser.rl"
2365
+ #line 726 "edn_parser.rl"
2370
2366
  {
2371
2367
  // #{ }
2372
- const char *np = parse_set(p, pe, o);
2368
+ const char *np = parse_set(p, pe, v);
2373
2369
  if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
2374
2370
  }
2375
- #line 61 "edn_parser.rl"
2371
+ #line 57 "edn_parser.rl"
2376
2372
  { p--; {p++; cs = 2; goto _out;} }
2377
2373
  goto st2;
2378
2374
  st2:
2379
2375
  if ( ++p == pe )
2380
2376
  goto _test_eof2;
2381
2377
  case 2:
2382
- #line 2383 "edn_parser.cc"
2378
+ #line 2379 "edn_parser.cc"
2383
2379
  goto st0;
2384
2380
  }
2385
2381
  _test_eof2: cs = 2; goto _test_eof;
@@ -2388,7 +2384,7 @@ case 2:
2388
2384
  _out: {}
2389
2385
  }
2390
2386
 
2391
- #line 763 "edn_parser.rl"
2387
+ #line 759 "edn_parser.rl"
2392
2388
 
2393
2389
  if (cs >= EDN_dispatch_first_final) {
2394
2390
  return p + 1;
@@ -2407,7 +2403,7 @@ case 2:
2407
2403
  // set parsing machine
2408
2404
  //
2409
2405
 
2410
- #line 2411 "edn_parser.cc"
2406
+ #line 2407 "edn_parser.cc"
2411
2407
  static const int EDN_set_start = 1;
2412
2408
  static const int EDN_set_first_final = 4;
2413
2409
  static const int EDN_set_error = 0;
@@ -2415,28 +2411,28 @@ static const int EDN_set_error = 0;
2415
2411
  static const int EDN_set_en_main = 1;
2416
2412
 
2417
2413
 
2418
- #line 792 "edn_parser.rl"
2414
+ #line 788 "edn_parser.rl"
2419
2415
 
2420
2416
 
2421
2417
  //
2422
2418
  // set parsing
2423
2419
  //
2424
- const char* edn::Parser::parse_set(const char *p, const char *pe, Rice::Object& o)
2420
+ const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
2425
2421
  {
2426
2422
  static const char* EDN_TYPE = "set";
2427
2423
 
2428
2424
  int cs;
2429
- Rice::Array elems; // stored as a vector
2425
+ VALUE elems = rb_ary_new(); // stored as an array
2430
2426
 
2431
2427
 
2432
- #line 2433 "edn_parser.cc"
2428
+ #line 2429 "edn_parser.cc"
2433
2429
  {
2434
2430
  cs = EDN_set_start;
2435
2431
  }
2436
2432
 
2437
- #line 805 "edn_parser.rl"
2433
+ #line 801 "edn_parser.rl"
2438
2434
 
2439
- #line 2440 "edn_parser.cc"
2435
+ #line 2436 "edn_parser.cc"
2440
2436
  {
2441
2437
  if ( p == pe )
2442
2438
  goto _test_eof;
@@ -2447,7 +2443,7 @@ case 1:
2447
2443
  goto st2;
2448
2444
  goto st0;
2449
2445
  tr2:
2450
- #line 54 "edn_parser.rl"
2446
+ #line 50 "edn_parser.rl"
2451
2447
  {
2452
2448
  std::stringstream s;
2453
2449
  s << "unterminated " << EDN_TYPE;
@@ -2455,22 +2451,22 @@ tr2:
2455
2451
  p--; {p++; cs = 0; goto _out;}
2456
2452
  }
2457
2453
  goto st0;
2458
- #line 2459 "edn_parser.cc"
2454
+ #line 2455 "edn_parser.cc"
2459
2455
  st0:
2460
2456
  cs = 0;
2461
2457
  goto _out;
2462
2458
  tr3:
2463
- #line 24 "edn_parser.rl"
2459
+ #line 20 "edn_parser.rl"
2464
2460
  { line_number++; }
2465
2461
  goto st2;
2466
2462
  tr4:
2467
- #line 544 "edn_parser.rl"
2463
+ #line 540 "edn_parser.rl"
2468
2464
  {
2469
2465
  // reads an item within a sequence (vector, list, map, or
2470
2466
  // set). Regardless of the sequence type, an array of the
2471
2467
  // items is built. Once done, the sequence parser will convert
2472
2468
  // if needed
2473
- Rice::Object e;
2469
+ VALUE e;
2474
2470
  const char *np = parse_value(p, pe, e);
2475
2471
  if (np == NULL) {
2476
2472
  p--; {p++; cs = 2; goto _out;}
@@ -2484,7 +2480,7 @@ tr4:
2484
2480
  else {
2485
2481
  // otherwise we add it to the list of elements for the
2486
2482
  // corresponding container
2487
- elems.push(e);
2483
+ rb_ary_push(elems, e);
2488
2484
  }
2489
2485
  {p = (( np))-1;}
2490
2486
  }
@@ -2494,7 +2490,7 @@ st2:
2494
2490
  if ( ++p == pe )
2495
2491
  goto _test_eof2;
2496
2492
  case 2:
2497
- #line 2498 "edn_parser.cc"
2493
+ #line 2494 "edn_parser.cc"
2498
2494
  switch( (*p) ) {
2499
2495
  case 10: goto tr3;
2500
2496
  case 32: goto st2;
@@ -2527,14 +2523,14 @@ case 3:
2527
2523
  goto tr3;
2528
2524
  goto st3;
2529
2525
  tr6:
2530
- #line 61 "edn_parser.rl"
2526
+ #line 57 "edn_parser.rl"
2531
2527
  { p--; {p++; cs = 4; goto _out;} }
2532
2528
  goto st4;
2533
2529
  st4:
2534
2530
  if ( ++p == pe )
2535
2531
  goto _test_eof4;
2536
2532
  case 4:
2537
- #line 2538 "edn_parser.cc"
2533
+ #line 2534 "edn_parser.cc"
2538
2534
  goto st0;
2539
2535
  }
2540
2536
  _test_eof2: cs = 2; goto _test_eof;
@@ -2547,7 +2543,7 @@ case 4:
2547
2543
  switch ( cs ) {
2548
2544
  case 2:
2549
2545
  case 3:
2550
- #line 54 "edn_parser.rl"
2546
+ #line 50 "edn_parser.rl"
2551
2547
  {
2552
2548
  std::stringstream s;
2553
2549
  s << "unterminated " << EDN_TYPE;
@@ -2555,18 +2551,18 @@ case 4:
2555
2551
  p--; {p++; cs = 0; goto _out;}
2556
2552
  }
2557
2553
  break;
2558
- #line 2559 "edn_parser.cc"
2554
+ #line 2555 "edn_parser.cc"
2559
2555
  }
2560
2556
  }
2561
2557
 
2562
2558
  _out: {}
2563
2559
  }
2564
2560
 
2565
- #line 806 "edn_parser.rl"
2561
+ #line 802 "edn_parser.rl"
2566
2562
 
2567
2563
  if (cs >= EDN_set_first_final) {
2568
2564
  // all elements collected; now convert to a set
2569
- o = Parser::make_ruby_set(elems);
2565
+ v = Parser::make_ruby_set(elems);
2570
2566
  return p + 1;
2571
2567
  }
2572
2568
  else if (cs == EDN_set_error) {
@@ -2581,12 +2577,11 @@ case 4:
2581
2577
 
2582
2578
  // ============================================================
2583
2579
  // discard - consume the discard token and parse the next value to
2584
- // discard. TODO: perhaps optimize this so no object data is built
2585
- // by defining a new machine(s) to consume items within container
2586
- // delimiters
2580
+ // discard. TODO: perhaps optimize this so no object data is built by
2581
+ // defining a machine to consume items within container delimiters
2587
2582
  //
2588
2583
 
2589
- #line 2590 "edn_parser.cc"
2584
+ #line 2585 "edn_parser.cc"
2590
2585
  static const int EDN_discard_start = 1;
2591
2586
  static const int EDN_discard_first_final = 4;
2592
2587
  static const int EDN_discard_error = 0;
@@ -2594,24 +2589,24 @@ static const int EDN_discard_error = 0;
2594
2589
  static const int EDN_discard_en_main = 1;
2595
2590
 
2596
2591
 
2597
- #line 853 "edn_parser.rl"
2592
+ #line 848 "edn_parser.rl"
2598
2593
 
2599
2594
 
2600
2595
 
2601
2596
  const char* edn::Parser::parse_discard(const char *p, const char *pe)
2602
2597
  {
2603
2598
  int cs;
2604
- Rice::Object o;
2599
+ VALUE v;
2605
2600
 
2606
2601
 
2607
- #line 2608 "edn_parser.cc"
2602
+ #line 2603 "edn_parser.cc"
2608
2603
  {
2609
2604
  cs = EDN_discard_start;
2610
2605
  }
2611
2606
 
2612
- #line 862 "edn_parser.rl"
2607
+ #line 857 "edn_parser.rl"
2613
2608
 
2614
- #line 2615 "edn_parser.cc"
2609
+ #line 2610 "edn_parser.cc"
2615
2610
  {
2616
2611
  if ( p == pe )
2617
2612
  goto _test_eof;
@@ -2625,14 +2620,14 @@ st0:
2625
2620
  cs = 0;
2626
2621
  goto _out;
2627
2622
  tr2:
2628
- #line 24 "edn_parser.rl"
2623
+ #line 20 "edn_parser.rl"
2629
2624
  { line_number++; }
2630
2625
  goto st2;
2631
2626
  st2:
2632
2627
  if ( ++p == pe )
2633
2628
  goto _test_eof2;
2634
2629
  case 2:
2635
- #line 2636 "edn_parser.cc"
2630
+ #line 2631 "edn_parser.cc"
2636
2631
  switch( (*p) ) {
2637
2632
  case 10: goto tr2;
2638
2633
  case 32: goto st2;
@@ -2657,27 +2652,27 @@ case 2:
2657
2652
  goto tr3;
2658
2653
  goto st0;
2659
2654
  tr3:
2660
- #line 836 "edn_parser.rl"
2655
+ #line 831 "edn_parser.rl"
2661
2656
  {
2662
- const char *np = parse_value(p, pe, o);
2657
+ const char *np = parse_value(p, pe, v);
2663
2658
  if (np) {
2664
2659
  // this token is to be discard it so store it in the
2665
2660
  // discard stack - we really don't need to save it so this
2666
2661
  // could be simplified
2667
- discard.push(o);
2662
+ discard.push(v);
2668
2663
  {p = (( np))-1;}
2669
2664
  } else {
2670
2665
  p--; {p++; cs = 4; goto _out;}
2671
2666
  }
2672
2667
  }
2673
- #line 61 "edn_parser.rl"
2668
+ #line 57 "edn_parser.rl"
2674
2669
  { p--; {p++; cs = 4; goto _out;} }
2675
2670
  goto st4;
2676
2671
  st4:
2677
2672
  if ( ++p == pe )
2678
2673
  goto _test_eof4;
2679
2674
  case 4:
2680
- #line 2681 "edn_parser.cc"
2675
+ #line 2676 "edn_parser.cc"
2681
2676
  goto st0;
2682
2677
  st3:
2683
2678
  if ( ++p == pe )
@@ -2695,7 +2690,7 @@ case 3:
2695
2690
  _out: {}
2696
2691
  }
2697
2692
 
2698
- #line 863 "edn_parser.rl"
2693
+ #line 858 "edn_parser.rl"
2699
2694
 
2700
2695
  if (cs >= EDN_discard_first_final) {
2701
2696
  return p + 1;
@@ -2726,7 +2721,7 @@ case 3:
2726
2721
  // 2. add parse checks for uuid and inst for better error reporting
2727
2722
  //
2728
2723
 
2729
- #line 2730 "edn_parser.cc"
2724
+ #line 2725 "edn_parser.cc"
2730
2725
  static const int EDN_tagged_start = 1;
2731
2726
  static const int EDN_tagged_first_final = 6;
2732
2727
  static const int EDN_tagged_error = 0;
@@ -2734,26 +2729,26 @@ static const int EDN_tagged_error = 0;
2734
2729
  static const int EDN_tagged_en_main = 1;
2735
2730
 
2736
2731
 
2737
- #line 914 "edn_parser.rl"
2732
+ #line 909 "edn_parser.rl"
2738
2733
 
2739
2734
 
2740
2735
 
2741
- const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Object& o)
2736
+ const char* edn::Parser::parse_tagged(const char *p, const char *pe, VALUE& v)
2742
2737
  {
2743
- std::string sym_name;
2744
- Rice::Object data;
2738
+ VALUE sym_name = Qnil;
2739
+ VALUE data = Qnil;
2745
2740
 
2746
2741
  int cs;
2747
2742
 
2748
2743
 
2749
- #line 2750 "edn_parser.cc"
2744
+ #line 2745 "edn_parser.cc"
2750
2745
  {
2751
2746
  cs = EDN_tagged_start;
2752
2747
  }
2753
2748
 
2754
- #line 925 "edn_parser.rl"
2749
+ #line 920 "edn_parser.rl"
2755
2750
 
2756
- #line 2757 "edn_parser.cc"
2751
+ #line 2752 "edn_parser.cc"
2757
2752
  {
2758
2753
  if ( p == pe )
2759
2754
  goto _test_eof;
@@ -2770,7 +2765,7 @@ st0:
2770
2765
  cs = 0;
2771
2766
  goto _out;
2772
2767
  tr0:
2773
- #line 901 "edn_parser.rl"
2768
+ #line 896 "edn_parser.rl"
2774
2769
  {
2775
2770
  // parses the symbol portion of the pair
2776
2771
  const char *np = parse_symbol(p, pe, sym_name);
@@ -2781,7 +2776,7 @@ st2:
2781
2776
  if ( ++p == pe )
2782
2777
  goto _test_eof2;
2783
2778
  case 2:
2784
- #line 2785 "edn_parser.cc"
2779
+ #line 2780 "edn_parser.cc"
2785
2780
  switch( (*p) ) {
2786
2781
  case 10: goto tr3;
2787
2782
  case 32: goto st3;
@@ -2818,14 +2813,14 @@ case 2:
2818
2813
  goto tr5;
2819
2814
  goto st0;
2820
2815
  tr3:
2821
- #line 24 "edn_parser.rl"
2816
+ #line 20 "edn_parser.rl"
2822
2817
  { line_number++; }
2823
2818
  goto st3;
2824
2819
  st3:
2825
2820
  if ( ++p == pe )
2826
2821
  goto _test_eof3;
2827
2822
  case 3:
2828
- #line 2829 "edn_parser.cc"
2823
+ #line 2824 "edn_parser.cc"
2829
2824
  switch( (*p) ) {
2830
2825
  case 10: goto tr3;
2831
2826
  case 32: goto st3;
@@ -2850,20 +2845,20 @@ case 3:
2850
2845
  goto tr4;
2851
2846
  goto st0;
2852
2847
  tr4:
2853
- #line 906 "edn_parser.rl"
2848
+ #line 901 "edn_parser.rl"
2854
2849
  {
2855
2850
  // parses the value portion
2856
2851
  const char *np = parse_value(p, pe, data);
2857
2852
  if (np == NULL) { p--; {p++; cs = 6; goto _out;} } else { {p = (( np))-1;} }
2858
2853
  }
2859
- #line 61 "edn_parser.rl"
2854
+ #line 57 "edn_parser.rl"
2860
2855
  { p--; {p++; cs = 6; goto _out;} }
2861
2856
  goto st6;
2862
2857
  st6:
2863
2858
  if ( ++p == pe )
2864
2859
  goto _test_eof6;
2865
2860
  case 6:
2866
- #line 2867 "edn_parser.cc"
2861
+ #line 2862 "edn_parser.cc"
2867
2862
  goto st0;
2868
2863
  st4:
2869
2864
  if ( ++p == pe )
@@ -2873,20 +2868,20 @@ case 4:
2873
2868
  goto tr3;
2874
2869
  goto st4;
2875
2870
  tr5:
2876
- #line 906 "edn_parser.rl"
2871
+ #line 901 "edn_parser.rl"
2877
2872
  {
2878
2873
  // parses the value portion
2879
2874
  const char *np = parse_value(p, pe, data);
2880
2875
  if (np == NULL) { p--; {p++; cs = 7; goto _out;} } else { {p = (( np))-1;} }
2881
2876
  }
2882
- #line 61 "edn_parser.rl"
2877
+ #line 57 "edn_parser.rl"
2883
2878
  { p--; {p++; cs = 7; goto _out;} }
2884
2879
  goto st7;
2885
2880
  st7:
2886
2881
  if ( ++p == pe )
2887
2882
  goto _test_eof7;
2888
2883
  case 7:
2889
- #line 2890 "edn_parser.cc"
2884
+ #line 2885 "edn_parser.cc"
2890
2885
  switch( (*p) ) {
2891
2886
  case 10: goto tr3;
2892
2887
  case 32: goto st3;
@@ -2923,20 +2918,20 @@ case 7:
2923
2918
  goto tr5;
2924
2919
  goto st0;
2925
2920
  tr6:
2926
- #line 906 "edn_parser.rl"
2921
+ #line 901 "edn_parser.rl"
2927
2922
  {
2928
2923
  // parses the value portion
2929
2924
  const char *np = parse_value(p, pe, data);
2930
2925
  if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else { {p = (( np))-1;} }
2931
2926
  }
2932
- #line 61 "edn_parser.rl"
2927
+ #line 57 "edn_parser.rl"
2933
2928
  { p--; {p++; cs = 8; goto _out;} }
2934
2929
  goto st8;
2935
2930
  st8:
2936
2931
  if ( ++p == pe )
2937
2932
  goto _test_eof8;
2938
2933
  case 8:
2939
- #line 2940 "edn_parser.cc"
2934
+ #line 2935 "edn_parser.cc"
2940
2935
  if ( (*p) > 90 ) {
2941
2936
  if ( 97 <= (*p) && (*p) <= 122 )
2942
2937
  goto st5;
@@ -2983,20 +2978,20 @@ case 5:
2983
2978
  goto tr8;
2984
2979
  goto st0;
2985
2980
  tr8:
2986
- #line 906 "edn_parser.rl"
2981
+ #line 901 "edn_parser.rl"
2987
2982
  {
2988
2983
  // parses the value portion
2989
2984
  const char *np = parse_value(p, pe, data);
2990
2985
  if (np == NULL) { p--; {p++; cs = 9; goto _out;} } else { {p = (( np))-1;} }
2991
2986
  }
2992
- #line 61 "edn_parser.rl"
2987
+ #line 57 "edn_parser.rl"
2993
2988
  { p--; {p++; cs = 9; goto _out;} }
2994
2989
  goto st9;
2995
2990
  st9:
2996
2991
  if ( ++p == pe )
2997
2992
  goto _test_eof9;
2998
2993
  case 9:
2999
- #line 3000 "edn_parser.cc"
2994
+ #line 2995 "edn_parser.cc"
3000
2995
  switch( (*p) ) {
3001
2996
  case 10: goto tr3;
3002
2997
  case 32: goto st3;
@@ -3046,7 +3041,7 @@ case 9:
3046
3041
  _out: {}
3047
3042
  }
3048
3043
 
3049
- #line 926 "edn_parser.rl"
3044
+ #line 921 "edn_parser.rl"
3050
3045
 
3051
3046
  if (cs >= EDN_tagged_first_final) {
3052
3047
  //std::cerr << __FUNCTION__ << " parse symbol name as '" << sym_name << "', value is: " << data << std::endl;
@@ -3054,9 +3049,9 @@ case 9:
3054
3049
  try {
3055
3050
  // tagged_element makes a call to ruby which may throw an
3056
3051
  // exception when parsing the data
3057
- o = Parser::tagged_element(sym_name, data);
3058
- } catch (Rice::Exception& e) {
3059
- error(__FUNCTION__, e.message().str());
3052
+ v = Parser::tagged_element(sym_name, data);
3053
+ } catch (std::exception& e) {
3054
+ error(__FUNCTION__, e.what());
3060
3055
  return pe;
3061
3056
  }
3062
3057
  return p + 1;
@@ -3072,58 +3067,53 @@ case 9:
3072
3067
 
3073
3068
 
3074
3069
  // ============================================================
3075
- // main parsing machine
3070
+ // parses entire input but expects single valid token at the
3071
+ // top-level, therefore, does not tokenize source stream
3076
3072
  //
3077
3073
 
3078
- #line 3079 "edn_parser.cc"
3079
- static const int EDN_start = 2;
3080
- static const int EDN_error = 0;
3074
+ #line 3075 "edn_parser.cc"
3075
+ static const int EDN_parser_start = 2;
3076
+ static const int EDN_parser_first_final = 2;
3077
+ static const int EDN_parser_error = 0;
3081
3078
 
3082
- static const int EDN_en_main = 2;
3079
+ static const int EDN_parser_en_main = 2;
3083
3080
 
3084
3081
 
3085
- #line 969 "edn_parser.rl"
3082
+ #line 965 "edn_parser.rl"
3086
3083
 
3087
3084
 
3088
- //
3089
- // TODO: Currently using a sequence to handle cases with a discard
3090
- // but EDN's Reader allows token by token parsing
3091
- Rice::Object edn::Parser::parse(const char* buf, std::size_t len)
3085
+
3086
+ VALUE edn::Parser::parse(const char* src, std::size_t len)
3092
3087
  {
3093
3088
  int cs;
3094
- const char *p;
3095
- const char *pe;
3096
- Rice::Object result;
3089
+ VALUE result = Qnil;
3097
3090
 
3098
- // init
3099
- line_number = 1;
3100
- p_save = NULL;
3101
- while (!discard.empty())
3102
- discard.pop();
3091
+ // reset line counter & discard stack
3092
+ reset();
3103
3093
 
3104
3094
 
3105
- #line 3106 "edn_parser.cc"
3095
+ #line 3096 "edn_parser.cc"
3106
3096
  {
3107
- cs = EDN_start;
3097
+ cs = EDN_parser_start;
3108
3098
  }
3109
3099
 
3110
- #line 988 "edn_parser.rl"
3111
- p = &buf[0];
3100
+ #line 977 "edn_parser.rl"
3101
+ p = src;
3112
3102
  pe = p + len;
3113
- eof = pe; // eof defined in Parser class
3103
+ eof = pe;
3114
3104
 
3115
- #line 3116 "edn_parser.cc"
3105
+ #line 3106 "edn_parser.cc"
3116
3106
  {
3117
3107
  if ( p == pe )
3118
3108
  goto _test_eof;
3119
3109
  switch ( cs )
3120
3110
  {
3121
3111
  tr1:
3122
- #line 24 "edn_parser.rl"
3112
+ #line 20 "edn_parser.rl"
3123
3113
  { line_number++; }
3124
3114
  goto st2;
3125
3115
  tr4:
3126
- #line 959 "edn_parser.rl"
3116
+ #line 955 "edn_parser.rl"
3127
3117
  {
3128
3118
  const char* np = parse_value(p, pe, result);
3129
3119
  if (np == NULL) { {p = (( pe))-1;} {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
@@ -3133,7 +3123,7 @@ st2:
3133
3123
  if ( ++p == pe )
3134
3124
  goto _test_eof2;
3135
3125
  case 2:
3136
- #line 3137 "edn_parser.cc"
3126
+ #line 3127 "edn_parser.cc"
3137
3127
  switch( (*p) ) {
3138
3128
  case 10: goto tr1;
3139
3129
  case 32: goto st2;
@@ -3175,16 +3165,149 @@ case 1:
3175
3165
  _out: {}
3176
3166
  }
3177
3167
 
3178
- #line 992 "edn_parser.rl"
3168
+ #line 981 "edn_parser.rl"
3179
3169
 
3180
- if (cs == EDN_error) {
3170
+ if (cs == EDN_parser_error) {
3181
3171
  error(__FUNCTION__, *p);
3182
3172
  return Qnil;
3183
3173
  }
3184
- else if (cs == EDN_en_main) {} // silence ragel warning
3174
+ else if (cs == EDN_parser_first_final) {
3175
+ // whole source is parsed so reset
3176
+ p = pe = eof = NULL;
3177
+ reset();
3178
+ }
3179
+ else if (cs == EDN_parser_en_main) {} // silence ragel warning
3180
+ return result;
3181
+ }
3182
+
3183
+
3184
+ // ============================================================
3185
+ // token-by-token machine
3186
+ //
3187
+
3188
+ #line 3189 "edn_parser.cc"
3189
+ static const int EDN_tokens_start = 1;
3190
+
3191
+ static const int EDN_tokens_en_main = 1;
3192
+
3193
+
3194
+ #line 1013 "edn_parser.rl"
3195
+
3196
+
3197
+
3198
+ //
3199
+ //
3200
+ VALUE edn::Parser::next()
3201
+ {
3202
+ VALUE result = Qnil;
3203
+ int cs;
3204
+
3205
+
3206
+ #line 3207 "edn_parser.cc"
3207
+ {
3208
+ cs = EDN_tokens_start;
3209
+ }
3210
+
3211
+ #line 1024 "edn_parser.rl"
3212
+
3213
+ #line 3214 "edn_parser.cc"
3214
+ {
3215
+ if ( p == pe )
3216
+ goto _test_eof;
3217
+ switch ( cs )
3218
+ {
3219
+ tr2:
3220
+ #line 20 "edn_parser.rl"
3221
+ { line_number++; }
3222
+ goto st1;
3223
+ st1:
3224
+ if ( ++p == pe )
3225
+ goto _test_eof1;
3226
+ case 1:
3227
+ #line 3228 "edn_parser.cc"
3228
+ switch( (*p) ) {
3229
+ case 10: goto tr2;
3230
+ case 32: goto st1;
3231
+ case 40: goto tr3;
3232
+ case 44: goto st1;
3233
+ case 59: goto st3;
3234
+ case 95: goto tr3;
3235
+ }
3236
+ if ( (*p) < 42 ) {
3237
+ if ( (*p) > 13 ) {
3238
+ if ( 33 <= (*p) && (*p) <= 38 )
3239
+ goto tr3;
3240
+ } else if ( (*p) >= 9 )
3241
+ goto st1;
3242
+ } else if ( (*p) > 63 ) {
3243
+ if ( (*p) > 92 ) {
3244
+ if ( 97 <= (*p) && (*p) <= 123 )
3245
+ goto tr3;
3246
+ } else if ( (*p) >= 65 )
3247
+ goto tr3;
3248
+ } else
3249
+ goto tr3;
3250
+ goto st0;
3251
+ st0:
3252
+ cs = 0;
3253
+ goto _out;
3254
+ tr6:
3255
+ #line 20 "edn_parser.rl"
3256
+ { line_number++; }
3257
+ goto st4;
3258
+ tr3:
3259
+ #line 1005 "edn_parser.rl"
3260
+ {
3261
+ const char* np = parse_value(p, pe, result);
3262
+ if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else { {p = (( np))-1;} }
3263
+ }
3264
+ goto st4;
3265
+ st4:
3266
+ if ( ++p == pe )
3267
+ goto _test_eof4;
3268
+ case 4:
3269
+ #line 3270 "edn_parser.cc"
3270
+ switch( (*p) ) {
3271
+ case 10: goto tr6;
3272
+ case 32: goto st4;
3273
+ case 44: goto st4;
3274
+ case 59: goto st2;
3275
+ }
3276
+ if ( 9 <= (*p) && (*p) <= 13 )
3277
+ goto st4;
3278
+ goto st0;
3279
+ st2:
3280
+ if ( ++p == pe )
3281
+ goto _test_eof2;
3282
+ case 2:
3283
+ if ( (*p) == 10 )
3284
+ goto tr6;
3285
+ goto st2;
3286
+ st3:
3287
+ if ( ++p == pe )
3288
+ goto _test_eof3;
3289
+ case 3:
3290
+ if ( (*p) == 10 )
3291
+ goto tr2;
3292
+ goto st3;
3293
+ }
3294
+ _test_eof1: cs = 1; goto _test_eof;
3295
+ _test_eof4: cs = 4; goto _test_eof;
3296
+ _test_eof2: cs = 2; goto _test_eof;
3297
+ _test_eof3: cs = 3; goto _test_eof;
3298
+
3299
+ _test_eof: {}
3300
+ _out: {}
3301
+ }
3302
+
3303
+ #line 1025 "edn_parser.rl"
3304
+
3305
+ if (cs == EDN_tokens_en_main) {} // silence ragel warning
3306
+
3185
3307
  return result;
3186
3308
  }
3187
3309
 
3310
+
3188
3311
  /*
3189
3312
  * Local variables:
3190
3313
  * mode: c