edn_turbo 0.1.0 → 0.1.1

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.
@@ -3,9 +3,6 @@
3
3
  #include <iostream>
4
4
  #include <string>
5
5
 
6
- #include <ruby/ruby.h>
7
- #include <ruby/encoding.h>
8
-
9
6
  #include <rice/Hash.hpp>
10
7
  #include <rice/Array.hpp>
11
8
  #include <rice/to_from_ruby.hpp>
@@ -15,9 +12,13 @@
15
12
  //
16
13
  // EDN spec at: https://github.com/edn-format/edn
17
14
  //
15
+ //
16
+ // many thanks to Florian Frank for json-ruby which was essential in
17
+ // helping me learn about ragel
18
+ //
18
19
 
19
20
 
20
- #line 47 "edn_parser.rl"
21
+ #line 48 "edn_parser.rl"
21
22
 
22
23
 
23
24
  // ============================================================
@@ -25,7 +26,7 @@
25
26
  //
26
27
 
27
28
 
28
- #line 29 "edn_parser.cc"
29
+ #line 30 "edn_parser.cc"
29
30
  static const int EDN_value_start = 1;
30
31
  static const int EDN_value_first_final = 11;
31
32
  static const int EDN_value_error = 0;
@@ -33,23 +34,23 @@ static const int EDN_value_error = 0;
33
34
  static const int EDN_value_en_main = 1;
34
35
 
35
36
 
36
- #line 126 "edn_parser.rl"
37
+ #line 127 "edn_parser.rl"
37
38
 
38
39
 
39
40
 
40
- const char *edn::Parser::EDN_parse_value(const char *p, const char *pe, Rice::Object& o)
41
+ const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object& o)
41
42
  {
42
43
  int cs;
43
44
 
44
45
 
45
- #line 46 "edn_parser.cc"
46
+ #line 47 "edn_parser.cc"
46
47
  {
47
48
  cs = EDN_value_start;
48
49
  }
49
50
 
50
- #line 134 "edn_parser.rl"
51
+ #line 135 "edn_parser.rl"
51
52
 
52
- #line 53 "edn_parser.cc"
53
+ #line 54 "edn_parser.cc"
53
54
  {
54
55
  if ( p == pe )
55
56
  goto _test_eof;
@@ -74,27 +75,27 @@ st0:
74
75
  cs = 0;
75
76
  goto _out;
76
77
  tr0:
77
- #line 74 "edn_parser.rl"
78
+ #line 75 "edn_parser.rl"
78
79
  {
79
- const char *np = EDN_parse_string(p, pe, o);
80
+ const char *np = parse_string(p, pe, o);
80
81
  if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
81
82
  }
82
83
  goto st11;
83
84
  tr2:
84
- #line 103 "edn_parser.rl"
85
+ #line 104 "edn_parser.rl"
85
86
  {
86
- const char *np = EDN_parse_list(p, pe, o);
87
+ const char *np = parse_list(p, pe, o);
87
88
  if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
88
89
  }
89
90
  goto st11;
90
91
  tr3:
91
- #line 79 "edn_parser.rl"
92
+ #line 80 "edn_parser.rl"
92
93
  {
93
94
  // try to parse a decimal first
94
- const char *np = EDN_parse_decimal(p, pe, o);
95
+ const char *np = parse_decimal(p, pe, o);
95
96
  if (np == NULL) {
96
97
  // if we can't, try to parse it as an int
97
- np = EDN_parse_integer(p, pe, o);
98
+ np = parse_integer(p, pe, o);
98
99
  }
99
100
 
100
101
  if (np) {
@@ -109,40 +110,40 @@ tr3:
109
110
  }
110
111
  goto st11;
111
112
  tr4:
112
- #line 69 "edn_parser.rl"
113
+ #line 70 "edn_parser.rl"
113
114
  {
114
- const char *np = EDN_parse_keyword(p, pe, o);
115
+ const char *np = parse_keyword(p, pe, o);
115
116
  if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
116
117
  }
117
118
  goto st11;
118
119
  tr5:
119
- #line 98 "edn_parser.rl"
120
+ #line 99 "edn_parser.rl"
120
121
  {
121
- const char *np = EDN_parse_vector(p, pe, o);
122
+ const char *np = parse_vector(p, pe, o);
122
123
  if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
123
124
  }
124
125
  goto st11;
125
126
  tr9:
126
- #line 108 "edn_parser.rl"
127
+ #line 109 "edn_parser.rl"
127
128
  {
128
- const char *np = EDN_parse_map(p, pe, o);
129
+ const char *np = parse_map(p, pe, o);
129
130
  if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
130
131
  }
131
132
  goto st11;
132
133
  tr13:
133
- #line 62 "edn_parser.rl"
134
+ #line 63 "edn_parser.rl"
134
135
  {
135
136
  o = Qfalse;
136
137
  }
137
138
  goto st11;
138
139
  tr15:
139
- #line 59 "edn_parser.rl"
140
+ #line 60 "edn_parser.rl"
140
141
  {
141
142
  o = Qnil;
142
143
  }
143
144
  goto st11;
144
145
  tr18:
145
- #line 65 "edn_parser.rl"
146
+ #line 66 "edn_parser.rl"
146
147
  {
147
148
  o = Qtrue;
148
149
  }
@@ -151,9 +152,9 @@ st11:
151
152
  if ( ++p == pe )
152
153
  goto _test_eof11;
153
154
  case 11:
154
- #line 113 "edn_parser.rl"
155
+ #line 114 "edn_parser.rl"
155
156
  { p--; {p++; cs = 11; goto _out;} }
156
- #line 157 "edn_parser.cc"
157
+ #line 158 "edn_parser.cc"
157
158
  goto st0;
158
159
  st2:
159
160
  if ( ++p == pe )
@@ -234,7 +235,7 @@ case 10:
234
235
  _out: {}
235
236
  }
236
237
 
237
- #line 135 "edn_parser.rl"
238
+ #line 136 "edn_parser.rl"
238
239
 
239
240
  if (cs >= EDN_value_first_final) {
240
241
  return p;
@@ -248,35 +249,34 @@ case 10:
248
249
  }
249
250
 
250
251
 
252
+
251
253
  // ============================================================
252
- // tagged element parsing - any of #uuid, #inst, #{, #(some symbol)
253
- // discard (#_ <ident>) is handled by the top-level machine
254
+ // keyword parsing
254
255
  //
255
256
 
256
- #line 257 "edn_parser.cc"
257
- static const int EDN_dispatch_start = 1;
258
- static const int EDN_dispatch_first_final = 15;
259
- static const int EDN_dispatch_error = 0;
257
+ #line 258 "edn_parser.cc"
258
+ static const int EDN_keyword_start = 1;
259
+ static const int EDN_keyword_first_final = 4;
260
+ static const int EDN_keyword_error = 0;
260
261
 
261
- static const int EDN_dispatch_en_main = 1;
262
+ static const int EDN_keyword_en_main = 1;
262
263
 
263
264
 
264
- #line 170 "edn_parser.rl"
265
+ #line 164 "edn_parser.rl"
265
266
 
266
267
 
267
268
 
268
- const char* edn::Parser::EDN_parse_tagged(const char *p, const char *pe, Rice::Object& o, bool& discard)
269
+ const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Object& o)
269
270
  {
270
271
  int cs;
271
- Rice::String str;
272
272
 
273
273
 
274
274
  #line 275 "edn_parser.cc"
275
275
  {
276
- cs = EDN_dispatch_start;
276
+ cs = EDN_keyword_start;
277
277
  }
278
278
 
279
- #line 179 "edn_parser.rl"
279
+ #line 172 "edn_parser.rl"
280
280
  p_save = p;
281
281
 
282
282
  #line 283 "edn_parser.cc"
@@ -286,7 +286,7 @@ const char* edn::Parser::EDN_parse_tagged(const char *p, const char *pe, Rice::O
286
286
  switch ( cs )
287
287
  {
288
288
  case 1:
289
- if ( (*p) == 35 )
289
+ if ( (*p) == 58 )
290
290
  goto st2;
291
291
  goto st0;
292
292
  st0:
@@ -296,381 +296,89 @@ st2:
296
296
  if ( ++p == pe )
297
297
  goto _test_eof2;
298
298
  case 2:
299
- switch( (*p) ) {
300
- case 95: goto st15;
301
- case 105: goto st3;
302
- case 117: goto st9;
303
- }
304
- goto st0;
305
- st15:
306
- if ( ++p == pe )
307
- goto _test_eof15;
308
- case 15:
309
- switch( (*p) ) {
310
- case 32: goto st17;
311
- case 43: goto st0;
312
- case 58: goto st0;
313
- }
314
- if ( (*p) < 48 ) {
315
- if ( (*p) > 13 ) {
316
- if ( 45 <= (*p) && (*p) <= 46 )
317
- goto st17;
318
- } else if ( (*p) >= 9 )
319
- goto tr17;
320
- } else if ( (*p) > 57 ) {
321
- if ( (*p) > 90 ) {
322
- if ( 97 <= (*p) && (*p) <= 122 )
323
- goto st17;
324
- } else if ( (*p) >= 65 )
325
- goto st17;
326
- } else
327
- goto st17;
328
- goto tr16;
329
- tr16:
330
- #line 162 "edn_parser.rl"
331
- { p--; {p++; cs = 16; goto _out;} }
332
- goto st16;
333
- st16:
334
- if ( ++p == pe )
335
- goto _test_eof16;
336
- case 16:
337
- #line 338 "edn_parser.cc"
338
- switch( (*p) ) {
339
- case 32: goto st0;
340
- case 43: goto st0;
341
- }
342
- if ( (*p) < 48 ) {
343
- if ( 45 <= (*p) && (*p) <= 46 )
344
- goto st0;
345
- } else if ( (*p) > 58 ) {
346
- if ( (*p) > 90 ) {
347
- if ( 97 <= (*p) && (*p) <= 122 )
348
- goto st0;
349
- } else if ( (*p) >= 65 )
350
- goto st0;
351
- } else
352
- goto st0;
353
- goto tr16;
354
- tr17:
355
- #line 162 "edn_parser.rl"
356
- { p--; {p++; cs = 17; goto _out;} }
357
- goto st17;
358
- st17:
359
- if ( ++p == pe )
360
- goto _test_eof17;
361
- case 17:
362
- #line 363 "edn_parser.cc"
363
- switch( (*p) ) {
364
- case 32: goto st0;
365
- case 43: goto st0;
366
- case 58: goto st0;
367
- }
368
- if ( (*p) < 48 ) {
369
- if ( 45 <= (*p) && (*p) <= 46 )
370
- goto st17;
371
- } else if ( (*p) > 57 ) {
372
- if ( (*p) > 90 ) {
373
- if ( 97 <= (*p) && (*p) <= 122 )
374
- goto st17;
375
- } else if ( (*p) >= 65 )
376
- goto st17;
377
- } else
378
- goto st17;
379
- goto tr16;
380
- st3:
381
- if ( ++p == pe )
382
- goto _test_eof3;
383
- case 3:
384
- if ( (*p) == 110 )
299
+ if ( (*p) == 95 )
300
+ goto st4;
301
+ if ( (*p) > 90 ) {
302
+ if ( 97 <= (*p) && (*p) <= 122 )
303
+ goto st4;
304
+ } else if ( (*p) >= 65 )
385
305
  goto st4;
386
306
  goto st0;
387
307
  st4:
388
308
  if ( ++p == pe )
389
309
  goto _test_eof4;
390
310
  case 4:
391
- if ( (*p) == 115 )
392
- goto st5;
393
- goto st0;
311
+ switch( (*p) ) {
312
+ case 39: goto st0;
313
+ case 45: goto st4;
314
+ case 47: goto st3;
315
+ case 95: goto st4;
316
+ }
317
+ if ( (*p) < 65 ) {
318
+ if ( 48 <= (*p) && (*p) <= 57 )
319
+ goto st4;
320
+ } else if ( (*p) > 90 ) {
321
+ if ( 97 <= (*p) && (*p) <= 122 )
322
+ goto st4;
323
+ } else
324
+ goto st4;
325
+ goto tr4;
326
+ tr4:
327
+ #line 159 "edn_parser.rl"
328
+ { p--; {p++; cs = 5; goto _out;} }
329
+ goto st5;
394
330
  st5:
395
331
  if ( ++p == pe )
396
332
  goto _test_eof5;
397
333
  case 5:
398
- if ( (*p) == 116 )
334
+ #line 335 "edn_parser.cc"
335
+ goto st0;
336
+ st3:
337
+ if ( ++p == pe )
338
+ goto _test_eof3;
339
+ case 3:
340
+ if ( (*p) == 95 )
341
+ goto st6;
342
+ if ( (*p) > 90 ) {
343
+ if ( 97 <= (*p) && (*p) <= 122 )
344
+ goto st6;
345
+ } else if ( (*p) >= 65 )
399
346
  goto st6;
400
347
  goto st0;
401
348
  st6:
402
349
  if ( ++p == pe )
403
350
  goto _test_eof6;
404
351
  case 6:
405
- if ( (*p) == 32 )
406
- goto st7;
407
- goto st0;
408
- st7:
409
- if ( ++p == pe )
410
- goto _test_eof7;
411
- case 7:
412
- if ( (*p) == 34 )
413
- goto st8;
414
- goto st0;
415
- st8:
416
- if ( ++p == pe )
417
- goto _test_eof8;
418
- case 8:
419
- switch( (*p) ) {
420
- case 34: goto st16;
421
- case 43: goto st8;
422
- case 84: goto st8;
423
- case 90: goto st8;
424
- }
425
- if ( (*p) > 46 ) {
426
- if ( 48 <= (*p) && (*p) <= 58 )
427
- goto st8;
428
- } else if ( (*p) >= 45 )
429
- goto st8;
430
- goto st0;
431
- st9:
432
- if ( ++p == pe )
433
- goto _test_eof9;
434
- case 9:
435
- if ( (*p) == 117 )
436
- goto st10;
437
- goto st0;
438
- st10:
439
- if ( ++p == pe )
440
- goto _test_eof10;
441
- case 10:
442
- if ( (*p) == 105 )
443
- goto st11;
444
- goto st0;
445
- st11:
446
- if ( ++p == pe )
447
- goto _test_eof11;
448
- case 11:
449
- if ( (*p) == 100 )
450
- goto st12;
451
- goto st0;
452
- st12:
453
- if ( ++p == pe )
454
- goto _test_eof12;
455
- case 12:
456
- if ( (*p) == 32 )
457
- goto st13;
458
- goto st0;
459
- st13:
460
- if ( ++p == pe )
461
- goto _test_eof13;
462
- case 13:
463
- if ( (*p) == 34 )
464
- goto st14;
465
- goto st0;
466
- st14:
467
- if ( ++p == pe )
468
- goto _test_eof14;
469
- case 14:
470
352
  switch( (*p) ) {
471
- case 34: goto st16;
472
- case 45: goto st14;
353
+ case 39: goto st0;
354
+ case 45: goto st6;
355
+ case 47: goto st0;
356
+ case 95: goto st6;
473
357
  }
474
- if ( (*p) > 57 ) {
475
- if ( 97 <= (*p) && (*p) <= 102 )
476
- goto st14;
477
- } else if ( (*p) >= 48 )
478
- goto st14;
479
- goto st0;
358
+ if ( (*p) < 65 ) {
359
+ if ( 48 <= (*p) && (*p) <= 57 )
360
+ goto st6;
361
+ } else if ( (*p) > 90 ) {
362
+ if ( 97 <= (*p) && (*p) <= 122 )
363
+ goto st6;
364
+ } else
365
+ goto st6;
366
+ goto tr4;
480
367
  }
481
368
  _test_eof2: cs = 2; goto _test_eof;
482
- _test_eof15: cs = 15; goto _test_eof;
483
- _test_eof16: cs = 16; goto _test_eof;
484
- _test_eof17: cs = 17; goto _test_eof;
485
- _test_eof3: cs = 3; goto _test_eof;
486
369
  _test_eof4: cs = 4; goto _test_eof;
487
370
  _test_eof5: cs = 5; goto _test_eof;
371
+ _test_eof3: cs = 3; goto _test_eof;
488
372
  _test_eof6: cs = 6; goto _test_eof;
489
- _test_eof7: cs = 7; goto _test_eof;
490
- _test_eof8: cs = 8; goto _test_eof;
491
- _test_eof9: cs = 9; goto _test_eof;
492
- _test_eof10: cs = 10; goto _test_eof;
493
- _test_eof11: cs = 11; goto _test_eof;
494
- _test_eof12: cs = 12; goto _test_eof;
495
- _test_eof13: cs = 13; goto _test_eof;
496
- _test_eof14: cs = 14; goto _test_eof;
497
373
 
498
374
  _test_eof: {}
499
375
  _out: {}
500
376
  }
501
377
 
502
- #line 181 "edn_parser.rl"
503
-
504
- if (cs >= EDN_dispatch_first_final) {
505
-
506
- //is it a discard? if so, just drop the following token
507
- if (*(p_save + 1) == '_')
508
- {
509
- discard = true;
510
- return p + 1;
511
- }
378
+ #line 174 "edn_parser.rl"
512
379
 
513
- std::size_t len = p - p_save;
514
- std::string buf;
515
- buf.reserve(len);
516
-
517
- if (len > 10)
518
- {
519
- // there's enough room to be #inst or #uuid, copy the
520
- // string portion
521
- if (std::strncmp(p_save + 1, "inst", 4) == 0) {
522
- buf.append(p_save + 7, len - 8);
523
- } else if (std::strncmp(p_save + 1, "uuid", 4) == 0) {
524
- buf.append(p_save + 7, len - 8);
525
- }
526
-
527
- o = Rice::String(buf);
528
- return p;
529
- }
530
-
531
- // tagged element
532
- o = Rice::String(buf);
533
- return p;
534
- }
535
- else if (cs == EDN_dispatch_error) {
536
- error(*p);
537
- return pe;
538
- }
539
- else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
540
- return NULL;
541
- }
542
-
543
-
544
-
545
- // ============================================================
546
- // keyword parsing
547
- //
548
-
549
- #line 550 "edn_parser.cc"
550
- static const int EDN_keyword_start = 1;
551
- static const int EDN_keyword_first_final = 4;
552
- static const int EDN_keyword_error = 0;
553
-
554
- static const int EDN_keyword_en_main = 1;
555
-
556
-
557
- #line 237 "edn_parser.rl"
558
-
559
-
560
-
561
- const char* edn::Parser::EDN_parse_keyword(const char *p, const char *pe, Rice::Object& o)
562
- {
563
- int cs;
564
-
565
-
566
- #line 567 "edn_parser.cc"
567
- {
568
- cs = EDN_keyword_start;
569
- }
570
-
571
- #line 245 "edn_parser.rl"
572
- p_save = p;
573
-
574
- #line 575 "edn_parser.cc"
575
- {
576
- if ( p == pe )
577
- goto _test_eof;
578
- switch ( cs )
579
- {
580
- case 1:
581
- if ( (*p) == 58 )
582
- goto st2;
583
- goto st0;
584
- st0:
585
- cs = 0;
586
- goto _out;
587
- st2:
588
- if ( ++p == pe )
589
- goto _test_eof2;
590
- case 2:
591
- if ( (*p) == 95 )
592
- goto st4;
593
- if ( (*p) > 90 ) {
594
- if ( 97 <= (*p) && (*p) <= 122 )
595
- goto st4;
596
- } else if ( (*p) >= 65 )
597
- goto st4;
598
- goto st0;
599
- st4:
600
- if ( ++p == pe )
601
- goto _test_eof4;
602
- case 4:
603
- switch( (*p) ) {
604
- case 39: goto st0;
605
- case 45: goto st4;
606
- case 47: goto st3;
607
- case 95: goto st4;
608
- }
609
- if ( (*p) < 65 ) {
610
- if ( 48 <= (*p) && (*p) <= 57 )
611
- goto st4;
612
- } else if ( (*p) > 90 ) {
613
- if ( 97 <= (*p) && (*p) <= 122 )
614
- goto st4;
615
- } else
616
- goto st4;
617
- goto tr4;
618
- tr4:
619
- #line 232 "edn_parser.rl"
620
- { p--; {p++; cs = 5; goto _out;} }
621
- goto st5;
622
- st5:
623
- if ( ++p == pe )
624
- goto _test_eof5;
625
- case 5:
626
- #line 627 "edn_parser.cc"
627
- goto st0;
628
- st3:
629
- if ( ++p == pe )
630
- goto _test_eof3;
631
- case 3:
632
- if ( (*p) == 95 )
633
- goto st6;
634
- if ( (*p) > 90 ) {
635
- if ( 97 <= (*p) && (*p) <= 122 )
636
- goto st6;
637
- } else if ( (*p) >= 65 )
638
- goto st6;
639
- goto st0;
640
- st6:
641
- if ( ++p == pe )
642
- goto _test_eof6;
643
- case 6:
644
- switch( (*p) ) {
645
- case 39: goto st0;
646
- case 45: goto st6;
647
- case 47: goto st0;
648
- case 95: goto st6;
649
- }
650
- if ( (*p) < 65 ) {
651
- if ( 48 <= (*p) && (*p) <= 57 )
652
- goto st6;
653
- } else if ( (*p) > 90 ) {
654
- if ( 97 <= (*p) && (*p) <= 122 )
655
- goto st6;
656
- } else
657
- goto st6;
658
- goto tr4;
659
- }
660
- _test_eof2: cs = 2; goto _test_eof;
661
- _test_eof4: cs = 4; goto _test_eof;
662
- _test_eof5: cs = 5; goto _test_eof;
663
- _test_eof3: cs = 3; goto _test_eof;
664
- _test_eof6: cs = 6; goto _test_eof;
665
-
666
- _test_eof: {}
667
- _out: {}
668
- }
669
-
670
- #line 247 "edn_parser.rl"
671
-
672
- if (cs >= EDN_keyword_first_final) {
673
- uint32_t len = p - p_save - 1; // don't include leading ':' because Rice::Symbol will handle it
380
+ if (cs >= EDN_keyword_first_final) {
381
+ uint32_t len = p - p_save - 1; // don't include leading ':' because Rice::Symbol will handle it
674
382
  std::string buf;
675
383
  buf.append(p_save + 1, len);
676
384
  o = Rice::Symbol(buf);
@@ -690,7 +398,7 @@ case 6:
690
398
  // string parsing
691
399
  //
692
400
 
693
- #line 694 "edn_parser.cc"
401
+ #line 402 "edn_parser.cc"
694
402
  static const int EDN_string_start = 1;
695
403
  static const int EDN_string_first_final = 8;
696
404
  static const int EDN_string_error = 0;
@@ -698,86 +406,11 @@ static const int EDN_string_error = 0;
698
406
  static const int EDN_string_en_main = 1;
699
407
 
700
408
 
701
- #line 292 "edn_parser.rl"
409
+ #line 219 "edn_parser.rl"
702
410
 
703
411
 
704
412
 
705
- //
706
- // copies the string data, unescaping any present values that need to be replaced
707
- //
708
- bool edn::Parser::EDN_parse_byte_stream(const char *p, const char *pe, Rice::String& s)
709
- {
710
- if (pe > p) {
711
- std::string buf;
712
- std::size_t len = pe - p;
713
-
714
- // pre-allocate storage needed
715
- buf.reserve(len);
716
-
717
- const char* cp = p;
718
- std::size_t pos = 0;
719
- char c, replacement;
720
-
721
- while (cp < pe)
722
- {
723
- // append any other character that is not the escaping slash
724
- if (*cp != '\\') {
725
- buf.replace(pos++, 1, 1, *cp++);
726
- continue;
727
- }
728
-
729
- // looking at a '\' - check what it escapes if there's a
730
- // following character
731
- if (++cp == pe)
732
- break;
733
-
734
- c = *cp++;
735
- replacement = '?';
736
-
737
- switch (c)
738
- {
739
- case 't':
740
- replacement = '\t';
741
- break;
742
- case 'n':
743
- replacement = '\n';
744
- break;
745
- case 'r':
746
- replacement = '\r';
747
- break;
748
- case '\"':
749
- replacement = '\"';
750
- break;
751
- case '\\':
752
- replacement = '\\';
753
- break;
754
- /* TODO: add support for this!
755
- case 'u':
756
- replacement = '\u';
757
- break;
758
- */
759
- default:
760
- std::cerr << "value must be unescaped but case is unhandled: '" << c << "'" << std::endl;
761
- break;
762
- }
763
-
764
- // substitute the escaped walue
765
- if (replacement != '?')
766
- buf.replace(pos++, 1, 1, replacement);
767
- }
768
-
769
- // utf-8 encode
770
- VALUE vs = Rice::protect( rb_str_new2, buf.c_str() );
771
- VALUE s_utf8 = Rice::protect( rb_enc_associate, vs, rb_utf8_encoding() );
772
- s = Rice::String(s_utf8);
773
- return true;
774
- }
775
-
776
- return false;
777
- }
778
-
779
-
780
- const char* edn::Parser::EDN_parse_string(const char *p, const char *pe, Rice::Object& o)
413
+ const char* edn::Parser::parse_string(const char *p, const char *pe, Rice::Object& o)
781
414
  {
782
415
  static const char* EDN_TYPE = "string";
783
416
  int cs;
@@ -785,15 +418,15 @@ const char* edn::Parser::EDN_parse_string(const char *p, const char *pe, Rice::O
785
418
 
786
419
  Rice::String s;
787
420
 
788
- #line 789 "edn_parser.cc"
421
+ #line 422 "edn_parser.cc"
789
422
  {
790
423
  cs = EDN_string_start;
791
424
  }
792
425
 
793
- #line 378 "edn_parser.rl"
426
+ #line 230 "edn_parser.rl"
794
427
  p_save = p;
795
428
 
796
- #line 797 "edn_parser.cc"
429
+ #line 430 "edn_parser.cc"
797
430
  {
798
431
  if ( p == pe )
799
432
  goto _test_eof;
@@ -804,7 +437,7 @@ case 1:
804
437
  goto st2;
805
438
  goto st0;
806
439
  tr2:
807
- #line 41 "edn_parser.rl"
440
+ #line 42 "edn_parser.rl"
808
441
  {
809
442
  std::stringstream s;
810
443
  s << "unterminated " << EDN_TYPE;
@@ -812,7 +445,7 @@ tr2:
812
445
  {p = (( pe))-1;}
813
446
  }
814
447
  goto st0;
815
- #line 816 "edn_parser.cc"
448
+ #line 449 "edn_parser.cc"
816
449
  st0:
817
450
  cs = 0;
818
451
  goto _out;
@@ -828,23 +461,23 @@ case 2:
828
461
  goto tr2;
829
462
  goto st2;
830
463
  tr3:
831
- #line 274 "edn_parser.rl"
464
+ #line 201 "edn_parser.rl"
832
465
  {
833
- if (!EDN_parse_byte_stream(p_save + 1, p, s)) {
466
+ if (!parse_byte_stream(p_save + 1, p, s)) {
834
467
  p--;
835
468
  {p++; cs = 8; goto _out;}
836
469
  } else {
837
470
  {p = (( p + 1))-1;}
838
471
  }
839
472
  }
840
- #line 283 "edn_parser.rl"
473
+ #line 210 "edn_parser.rl"
841
474
  { p--; {p++; cs = 8; goto _out;} }
842
475
  goto st8;
843
476
  st8:
844
477
  if ( ++p == pe )
845
478
  goto _test_eof8;
846
479
  case 8:
847
- #line 848 "edn_parser.cc"
480
+ #line 481 "edn_parser.cc"
848
481
  goto st0;
849
482
  st3:
850
483
  if ( ++p == pe )
@@ -921,7 +554,7 @@ case 7:
921
554
  {
922
555
  switch ( cs ) {
923
556
  case 2:
924
- #line 41 "edn_parser.rl"
557
+ #line 42 "edn_parser.rl"
925
558
  {
926
559
  std::stringstream s;
927
560
  s << "unterminated " << EDN_TYPE;
@@ -929,14 +562,14 @@ case 7:
929
562
  {p = (( pe))-1;}
930
563
  }
931
564
  break;
932
- #line 933 "edn_parser.cc"
565
+ #line 566 "edn_parser.cc"
933
566
  }
934
567
  }
935
568
 
936
569
  _out: {}
937
570
  }
938
571
 
939
- #line 380 "edn_parser.rl"
572
+ #line 232 "edn_parser.rl"
940
573
 
941
574
  if (cs >= EDN_string_first_final) {
942
575
  o = s;
@@ -953,31 +586,31 @@ case 7:
953
586
  // decimal parsing grammar
954
587
  //
955
588
 
956
- #line 957 "edn_parser.cc"
589
+ #line 590 "edn_parser.cc"
957
590
  static const int EDN_decimal_start = 1;
958
591
  static const int EDN_decimal_first_final = 8;
959
592
 
960
593
  static const int EDN_decimal_en_main = 1;
961
594
 
962
595
 
963
- #line 410 "edn_parser.rl"
596
+ #line 262 "edn_parser.rl"
964
597
 
965
598
 
966
599
 
967
- const char* edn::Parser::EDN_parse_decimal(const char *p, const char *pe, Rice::Object& o)
600
+ const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Object& o)
968
601
  {
969
602
  int cs;
970
603
 
971
604
 
972
- #line 973 "edn_parser.cc"
605
+ #line 606 "edn_parser.cc"
973
606
  {
974
607
  cs = EDN_decimal_start;
975
608
  }
976
609
 
977
- #line 418 "edn_parser.rl"
610
+ #line 270 "edn_parser.rl"
978
611
  p_save = p;
979
612
 
980
- #line 981 "edn_parser.cc"
613
+ #line 614 "edn_parser.cc"
981
614
  {
982
615
  if ( p == pe )
983
616
  goto _test_eof;
@@ -1036,14 +669,14 @@ case 8:
1036
669
  goto st0;
1037
670
  goto tr9;
1038
671
  tr9:
1039
- #line 401 "edn_parser.rl"
672
+ #line 253 "edn_parser.rl"
1040
673
  { p--; {p++; cs = 9; goto _out;} }
1041
674
  goto st9;
1042
675
  st9:
1043
676
  if ( ++p == pe )
1044
677
  goto _test_eof9;
1045
678
  case 9:
1046
- #line 1047 "edn_parser.cc"
679
+ #line 680 "edn_parser.cc"
1047
680
  goto st0;
1048
681
  st5:
1049
682
  if ( ++p == pe )
@@ -1121,7 +754,7 @@ case 7:
1121
754
  _out: {}
1122
755
  }
1123
756
 
1124
- #line 420 "edn_parser.rl"
757
+ #line 272 "edn_parser.rl"
1125
758
 
1126
759
  if (cs >= EDN_decimal_first_final) {
1127
760
  double value;
@@ -1137,30 +770,30 @@ case 7:
1137
770
  // integer parsing grammar
1138
771
  //
1139
772
 
1140
- #line 1141 "edn_parser.cc"
773
+ #line 774 "edn_parser.cc"
1141
774
  static const int EDN_integer_start = 1;
1142
775
  static const int EDN_integer_first_final = 3;
1143
776
 
1144
777
  static const int EDN_integer_en_main = 1;
1145
778
 
1146
779
 
1147
- #line 442 "edn_parser.rl"
780
+ #line 294 "edn_parser.rl"
1148
781
 
1149
782
 
1150
- const char* edn::Parser::EDN_parse_integer(const char *p, const char *pe, Rice::Object& o)
783
+ const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Object& o)
1151
784
  {
1152
785
  int cs;
1153
786
 
1154
787
 
1155
- #line 1156 "edn_parser.cc"
788
+ #line 789 "edn_parser.cc"
1156
789
  {
1157
790
  cs = EDN_integer_start;
1158
791
  }
1159
792
 
1160
- #line 449 "edn_parser.rl"
793
+ #line 301 "edn_parser.rl"
1161
794
  p_save = p;
1162
795
 
1163
- #line 1164 "edn_parser.cc"
796
+ #line 797 "edn_parser.cc"
1164
797
  {
1165
798
  if ( p == pe )
1166
799
  goto _test_eof;
@@ -1196,14 +829,14 @@ case 3:
1196
829
  goto st0;
1197
830
  goto tr4;
1198
831
  tr4:
1199
- #line 439 "edn_parser.rl"
832
+ #line 291 "edn_parser.rl"
1200
833
  { p--; {p++; cs = 4; goto _out;} }
1201
834
  goto st4;
1202
835
  st4:
1203
836
  if ( ++p == pe )
1204
837
  goto _test_eof4;
1205
838
  case 4:
1206
- #line 1207 "edn_parser.cc"
839
+ #line 840 "edn_parser.cc"
1207
840
  goto st0;
1208
841
  st5:
1209
842
  if ( ++p == pe )
@@ -1224,7 +857,7 @@ case 5:
1224
857
  _out: {}
1225
858
  }
1226
859
 
1227
- #line 451 "edn_parser.rl"
860
+ #line 303 "edn_parser.rl"
1228
861
 
1229
862
  if (cs >= EDN_integer_first_final) {
1230
863
  int value;
@@ -1241,13 +874,13 @@ case 5:
1241
874
  // vectors and lists since they're both represented as vectors in ruby
1242
875
  //
1243
876
 
1244
- #line 503 "edn_parser.rl"
877
+ #line 355 "edn_parser.rl"
1245
878
 
1246
879
 
1247
880
  //
1248
881
  // vector-specific machine
1249
882
 
1250
- #line 1251 "edn_parser.cc"
883
+ #line 884 "edn_parser.cc"
1251
884
  static const int EDN_vector_start = 1;
1252
885
  static const int EDN_vector_first_final = 4;
1253
886
  static const int EDN_vector_error = 0;
@@ -1255,14 +888,14 @@ static const int EDN_vector_error = 0;
1255
888
  static const int EDN_vector_en_main = 1;
1256
889
 
1257
890
 
1258
- #line 517 "edn_parser.rl"
891
+ #line 369 "edn_parser.rl"
1259
892
 
1260
893
 
1261
894
 
1262
895
  //
1263
896
  // vector parsing
1264
897
  //
1265
- const char* edn::Parser::EDN_parse_vector(const char *p, const char *pe, Rice::Object& o)
898
+ const char* edn::Parser::parse_vector(const char *p, const char *pe, Rice::Object& o)
1266
899
  {
1267
900
  static const char* EDN_TYPE = "vector";
1268
901
 
@@ -1270,14 +903,14 @@ const char* edn::Parser::EDN_parse_vector(const char *p, const char *pe, Rice::O
1270
903
  Rice::Array arr;
1271
904
 
1272
905
 
1273
- #line 1274 "edn_parser.cc"
906
+ #line 907 "edn_parser.cc"
1274
907
  {
1275
908
  cs = EDN_vector_start;
1276
909
  }
1277
910
 
1278
- #line 531 "edn_parser.rl"
911
+ #line 383 "edn_parser.rl"
1279
912
 
1280
- #line 1281 "edn_parser.cc"
913
+ #line 914 "edn_parser.cc"
1281
914
  {
1282
915
  if ( p == pe )
1283
916
  goto _test_eof;
@@ -1288,7 +921,7 @@ case 1:
1288
921
  goto st2;
1289
922
  goto st0;
1290
923
  tr2:
1291
- #line 41 "edn_parser.rl"
924
+ #line 42 "edn_parser.rl"
1292
925
  {
1293
926
  std::stringstream s;
1294
927
  s << "unterminated " << EDN_TYPE;
@@ -1296,19 +929,19 @@ tr2:
1296
929
  {p = (( pe))-1;}
1297
930
  }
1298
931
  goto st0;
1299
- #line 1300 "edn_parser.cc"
932
+ #line 933 "edn_parser.cc"
1300
933
  st0:
1301
934
  cs = 0;
1302
935
  goto _out;
1303
936
  tr3:
1304
- #line 21 "edn_parser.rl"
937
+ #line 22 "edn_parser.rl"
1305
938
  { line_number++; }
1306
939
  goto st2;
1307
940
  tr4:
1308
- #line 470 "edn_parser.rl"
941
+ #line 322 "edn_parser.rl"
1309
942
  {
1310
943
  Rice::Object v;
1311
- const char *np = EDN_parse_value(p, pe, v);
944
+ const char *np = parse_value(p, pe, v);
1312
945
  if (np == NULL) {
1313
946
  p--; {p++; cs = 2; goto _out;}
1314
947
  } else {
@@ -1318,11 +951,11 @@ tr4:
1318
951
  }
1319
952
  goto st2;
1320
953
  tr5:
1321
- #line 481 "edn_parser.rl"
954
+ #line 333 "edn_parser.rl"
1322
955
  {
1323
956
  bool discard = false;
1324
957
  Rice::Object v;
1325
- const char *np = EDN_parse_tagged(p, pe, v, discard);
958
+ const char *np = parse_tagged(p, pe, v, discard);
1326
959
  if (np == NULL) {
1327
960
  p--; {p++; cs = 2; goto _out;}
1328
961
  } else {
@@ -1337,7 +970,7 @@ st2:
1337
970
  if ( ++p == pe )
1338
971
  goto _test_eof2;
1339
972
  case 2:
1340
- #line 1341 "edn_parser.cc"
973
+ #line 974 "edn_parser.cc"
1341
974
  switch( (*p) ) {
1342
975
  case 10: goto tr3;
1343
976
  case 32: goto st2;
@@ -1370,14 +1003,14 @@ case 3:
1370
1003
  goto tr3;
1371
1004
  goto st3;
1372
1005
  tr7:
1373
- #line 495 "edn_parser.rl"
1006
+ #line 347 "edn_parser.rl"
1374
1007
  { p--; {p++; cs = 4; goto _out;} }
1375
1008
  goto st4;
1376
1009
  st4:
1377
1010
  if ( ++p == pe )
1378
1011
  goto _test_eof4;
1379
1012
  case 4:
1380
- #line 1381 "edn_parser.cc"
1013
+ #line 1014 "edn_parser.cc"
1381
1014
  goto st0;
1382
1015
  }
1383
1016
  _test_eof2: cs = 2; goto _test_eof;
@@ -1389,7 +1022,7 @@ case 4:
1389
1022
  {
1390
1023
  switch ( cs ) {
1391
1024
  case 2:
1392
- #line 41 "edn_parser.rl"
1025
+ #line 42 "edn_parser.rl"
1393
1026
  {
1394
1027
  std::stringstream s;
1395
1028
  s << "unterminated " << EDN_TYPE;
@@ -1397,14 +1030,14 @@ case 4:
1397
1030
  {p = (( pe))-1;}
1398
1031
  }
1399
1032
  break;
1400
- #line 1401 "edn_parser.cc"
1033
+ #line 1034 "edn_parser.cc"
1401
1034
  }
1402
1035
  }
1403
1036
 
1404
1037
  _out: {}
1405
1038
  }
1406
1039
 
1407
- #line 532 "edn_parser.rl"
1040
+ #line 384 "edn_parser.rl"
1408
1041
 
1409
1042
  if (cs >= EDN_vector_first_final) {
1410
1043
  o = arr;
@@ -1424,7 +1057,7 @@ case 4:
1424
1057
  // list parsing machine
1425
1058
  //
1426
1059
 
1427
- #line 1428 "edn_parser.cc"
1060
+ #line 1061 "edn_parser.cc"
1428
1061
  static const int EDN_list_start = 1;
1429
1062
  static const int EDN_list_first_final = 6;
1430
1063
  static const int EDN_list_error = 0;
@@ -1432,13 +1065,13 @@ static const int EDN_list_error = 0;
1432
1065
  static const int EDN_list_en_main = 1;
1433
1066
 
1434
1067
 
1435
- #line 561 "edn_parser.rl"
1068
+ #line 413 "edn_parser.rl"
1436
1069
 
1437
1070
 
1438
1071
  //
1439
1072
  // list parsing
1440
1073
  //
1441
- const char* edn::Parser::EDN_parse_list(const char *p, const char *pe, Rice::Object& o)
1074
+ const char* edn::Parser::parse_list(const char *p, const char *pe, Rice::Object& o)
1442
1075
  {
1443
1076
  static const char* EDN_TYPE = "list";
1444
1077
 
@@ -1446,14 +1079,14 @@ const char* edn::Parser::EDN_parse_list(const char *p, const char *pe, Rice::Obj
1446
1079
  Rice::Array arr;
1447
1080
 
1448
1081
 
1449
- #line 1450 "edn_parser.cc"
1082
+ #line 1083 "edn_parser.cc"
1450
1083
  {
1451
1084
  cs = EDN_list_start;
1452
1085
  }
1453
1086
 
1454
- #line 574 "edn_parser.rl"
1087
+ #line 426 "edn_parser.rl"
1455
1088
 
1456
- #line 1457 "edn_parser.cc"
1089
+ #line 1090 "edn_parser.cc"
1457
1090
  {
1458
1091
  if ( p == pe )
1459
1092
  goto _test_eof;
@@ -1464,7 +1097,7 @@ case 1:
1464
1097
  goto st2;
1465
1098
  goto st0;
1466
1099
  tr2:
1467
- #line 41 "edn_parser.rl"
1100
+ #line 42 "edn_parser.rl"
1468
1101
  {
1469
1102
  std::stringstream s;
1470
1103
  s << "unterminated " << EDN_TYPE;
@@ -1472,19 +1105,19 @@ tr2:
1472
1105
  {p = (( pe))-1;}
1473
1106
  }
1474
1107
  goto st0;
1475
- #line 1476 "edn_parser.cc"
1108
+ #line 1109 "edn_parser.cc"
1476
1109
  st0:
1477
1110
  cs = 0;
1478
1111
  goto _out;
1479
1112
  tr3:
1480
- #line 21 "edn_parser.rl"
1113
+ #line 22 "edn_parser.rl"
1481
1114
  { line_number++; }
1482
1115
  goto st2;
1483
1116
  st2:
1484
1117
  if ( ++p == pe )
1485
1118
  goto _test_eof2;
1486
1119
  case 2:
1487
- #line 1488 "edn_parser.cc"
1120
+ #line 1121 "edn_parser.cc"
1488
1121
  switch( (*p) ) {
1489
1122
  case 10: goto tr3;
1490
1123
  case 32: goto st2;
@@ -1509,14 +1142,14 @@ case 2:
1509
1142
  goto tr4;
1510
1143
  goto tr2;
1511
1144
  tr8:
1512
- #line 21 "edn_parser.rl"
1145
+ #line 22 "edn_parser.rl"
1513
1146
  { line_number++; }
1514
1147
  goto st3;
1515
1148
  tr4:
1516
- #line 470 "edn_parser.rl"
1149
+ #line 322 "edn_parser.rl"
1517
1150
  {
1518
1151
  Rice::Object v;
1519
- const char *np = EDN_parse_value(p, pe, v);
1152
+ const char *np = parse_value(p, pe, v);
1520
1153
  if (np == NULL) {
1521
1154
  p--; {p++; cs = 3; goto _out;}
1522
1155
  } else {
@@ -1526,11 +1159,11 @@ tr4:
1526
1159
  }
1527
1160
  goto st3;
1528
1161
  tr9:
1529
- #line 481 "edn_parser.rl"
1162
+ #line 333 "edn_parser.rl"
1530
1163
  {
1531
1164
  bool discard = false;
1532
1165
  Rice::Object v;
1533
- const char *np = EDN_parse_tagged(p, pe, v, discard);
1166
+ const char *np = parse_tagged(p, pe, v, discard);
1534
1167
  if (np == NULL) {
1535
1168
  p--; {p++; cs = 3; goto _out;}
1536
1169
  } else {
@@ -1545,7 +1178,7 @@ st3:
1545
1178
  if ( ++p == pe )
1546
1179
  goto _test_eof3;
1547
1180
  case 3:
1548
- #line 1549 "edn_parser.cc"
1181
+ #line 1182 "edn_parser.cc"
1549
1182
  switch( (*p) ) {
1550
1183
  case 10: goto tr8;
1551
1184
  case 32: goto st3;
@@ -1571,14 +1204,14 @@ case 3:
1571
1204
  goto tr4;
1572
1205
  goto tr2;
1573
1206
  tr5:
1574
- #line 495 "edn_parser.rl"
1207
+ #line 347 "edn_parser.rl"
1575
1208
  { p--; {p++; cs = 6; goto _out;} }
1576
1209
  goto st6;
1577
1210
  st6:
1578
1211
  if ( ++p == pe )
1579
1212
  goto _test_eof6;
1580
1213
  case 6:
1581
- #line 1582 "edn_parser.cc"
1214
+ #line 1215 "edn_parser.cc"
1582
1215
  goto st0;
1583
1216
  st4:
1584
1217
  if ( ++p == pe )
@@ -1607,7 +1240,7 @@ case 5:
1607
1240
  switch ( cs ) {
1608
1241
  case 2:
1609
1242
  case 3:
1610
- #line 41 "edn_parser.rl"
1243
+ #line 42 "edn_parser.rl"
1611
1244
  {
1612
1245
  std::stringstream s;
1613
1246
  s << "unterminated " << EDN_TYPE;
@@ -1615,14 +1248,14 @@ case 5:
1615
1248
  {p = (( pe))-1;}
1616
1249
  }
1617
1250
  break;
1618
- #line 1619 "edn_parser.cc"
1251
+ #line 1252 "edn_parser.cc"
1619
1252
  }
1620
1253
  }
1621
1254
 
1622
1255
  _out: {}
1623
1256
  }
1624
1257
 
1625
- #line 575 "edn_parser.rl"
1258
+ #line 427 "edn_parser.rl"
1626
1259
 
1627
1260
  if (cs >= EDN_list_first_final) {
1628
1261
  o = arr;
@@ -1642,7 +1275,7 @@ case 5:
1642
1275
  // hash parsing
1643
1276
  //
1644
1277
 
1645
- #line 1646 "edn_parser.cc"
1278
+ #line 1279 "edn_parser.cc"
1646
1279
  static const int EDN_map_start = 1;
1647
1280
  static const int EDN_map_first_final = 6;
1648
1281
  static const int EDN_map_error = 0;
@@ -1650,11 +1283,11 @@ static const int EDN_map_error = 0;
1650
1283
  static const int EDN_map_en_main = 1;
1651
1284
 
1652
1285
 
1653
- #line 634 "edn_parser.rl"
1286
+ #line 486 "edn_parser.rl"
1654
1287
 
1655
1288
 
1656
1289
 
1657
- const char* edn::Parser::EDN_parse_map(const char *p, const char *pe, Rice::Object& o)
1290
+ const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object& o)
1658
1291
  {
1659
1292
  static const char* EDN_TYPE = "map";
1660
1293
 
@@ -1663,15 +1296,15 @@ const char* edn::Parser::EDN_parse_map(const char *p, const char *pe, Rice::Obje
1663
1296
  Rice::Object k, v;
1664
1297
 
1665
1298
 
1666
- #line 1667 "edn_parser.cc"
1299
+ #line 1300 "edn_parser.cc"
1667
1300
  {
1668
1301
  cs = EDN_map_start;
1669
1302
  }
1670
1303
 
1671
- #line 646 "edn_parser.rl"
1304
+ #line 498 "edn_parser.rl"
1672
1305
  p_save = p;
1673
1306
 
1674
- #line 1675 "edn_parser.cc"
1307
+ #line 1308 "edn_parser.cc"
1675
1308
  {
1676
1309
  if ( p == pe )
1677
1310
  goto _test_eof;
@@ -1682,7 +1315,7 @@ case 1:
1682
1315
  goto st2;
1683
1316
  goto st0;
1684
1317
  tr2:
1685
- #line 41 "edn_parser.rl"
1318
+ #line 42 "edn_parser.rl"
1686
1319
  {
1687
1320
  std::stringstream s;
1688
1321
  s << "unterminated " << EDN_TYPE;
@@ -1691,24 +1324,24 @@ tr2:
1691
1324
  }
1692
1325
  goto st0;
1693
1326
  tr7:
1694
- #line 619 "edn_parser.rl"
1327
+ #line 471 "edn_parser.rl"
1695
1328
  {
1696
1329
  error("map pair not found");
1697
1330
  {p = (( pe))-1;}
1698
1331
  }
1699
1332
  goto st0;
1700
- #line 1701 "edn_parser.cc"
1333
+ #line 1334 "edn_parser.cc"
1701
1334
  st0:
1702
1335
  cs = 0;
1703
1336
  goto _out;
1704
1337
  tr3:
1705
- #line 21 "edn_parser.rl"
1338
+ #line 22 "edn_parser.rl"
1706
1339
  { line_number++; }
1707
1340
  goto st2;
1708
1341
  tr10:
1709
- #line 608 "edn_parser.rl"
1342
+ #line 460 "edn_parser.rl"
1710
1343
  {
1711
- const char *np = EDN_parse_value(p, pe, v);
1344
+ const char *np = parse_value(p, pe, v);
1712
1345
  if (np == NULL) {
1713
1346
  p--; {p++; cs = 2; goto _out;}
1714
1347
  } else {
@@ -1721,7 +1354,7 @@ st2:
1721
1354
  if ( ++p == pe )
1722
1355
  goto _test_eof2;
1723
1356
  case 2:
1724
- #line 1725 "edn_parser.cc"
1357
+ #line 1358 "edn_parser.cc"
1725
1358
  switch( (*p) ) {
1726
1359
  case 10: goto tr3;
1727
1360
  case 32: goto st2;
@@ -1746,13 +1379,13 @@ case 2:
1746
1379
  goto tr4;
1747
1380
  goto tr2;
1748
1381
  tr9:
1749
- #line 21 "edn_parser.rl"
1382
+ #line 22 "edn_parser.rl"
1750
1383
  { line_number++; }
1751
1384
  goto st3;
1752
1385
  tr4:
1753
- #line 599 "edn_parser.rl"
1386
+ #line 451 "edn_parser.rl"
1754
1387
  {
1755
- const char *np = EDN_parse_value(p, pe, k);
1388
+ const char *np = parse_value(p, pe, k);
1756
1389
  if (np == NULL) {
1757
1390
  p--; {p++; cs = 3; goto _out;}
1758
1391
  } else {
@@ -1764,7 +1397,7 @@ st3:
1764
1397
  if ( ++p == pe )
1765
1398
  goto _test_eof3;
1766
1399
  case 3:
1767
- #line 1768 "edn_parser.cc"
1400
+ #line 1401 "edn_parser.cc"
1768
1401
  switch( (*p) ) {
1769
1402
  case 10: goto tr9;
1770
1403
  case 32: goto st3;
@@ -1802,14 +1435,14 @@ case 5:
1802
1435
  goto tr3;
1803
1436
  goto st5;
1804
1437
  tr6:
1805
- #line 624 "edn_parser.rl"
1438
+ #line 476 "edn_parser.rl"
1806
1439
  { p--; {p++; cs = 6; goto _out;} }
1807
1440
  goto st6;
1808
1441
  st6:
1809
1442
  if ( ++p == pe )
1810
1443
  goto _test_eof6;
1811
1444
  case 6:
1812
- #line 1813 "edn_parser.cc"
1445
+ #line 1446 "edn_parser.cc"
1813
1446
  goto st0;
1814
1447
  }
1815
1448
  _test_eof2: cs = 2; goto _test_eof;
@@ -1823,7 +1456,7 @@ case 6:
1823
1456
  {
1824
1457
  switch ( cs ) {
1825
1458
  case 2:
1826
- #line 41 "edn_parser.rl"
1459
+ #line 42 "edn_parser.rl"
1827
1460
  {
1828
1461
  std::stringstream s;
1829
1462
  s << "unterminated " << EDN_TYPE;
@@ -1832,20 +1465,20 @@ case 6:
1832
1465
  }
1833
1466
  break;
1834
1467
  case 3:
1835
- #line 619 "edn_parser.rl"
1468
+ #line 471 "edn_parser.rl"
1836
1469
  {
1837
1470
  error("map pair not found");
1838
1471
  {p = (( pe))-1;}
1839
1472
  }
1840
1473
  break;
1841
- #line 1842 "edn_parser.cc"
1474
+ #line 1475 "edn_parser.cc"
1842
1475
  }
1843
1476
  }
1844
1477
 
1845
1478
  _out: {}
1846
1479
  }
1847
1480
 
1848
- #line 648 "edn_parser.rl"
1481
+ #line 500 "edn_parser.rl"
1849
1482
 
1850
1483
  if (cs >= EDN_map_first_final) {
1851
1484
  o = map;
@@ -1860,18 +1493,313 @@ case 6:
1860
1493
 
1861
1494
 
1862
1495
 
1496
+ // ============================================================
1497
+ // tagged element parsing - any of #uuid, #inst, #{, #(some symbol)
1498
+ // discard (#_ <ident>) is handled by the top-level machine
1499
+ //
1500
+ // NOTE: this is not fully implemented yet
1501
+ //
1502
+
1503
+ #line 1504 "edn_parser.cc"
1504
+ static const int EDN_dispatch_start = 1;
1505
+ static const int EDN_dispatch_first_final = 15;
1506
+ static const int EDN_dispatch_error = 0;
1507
+
1508
+ static const int EDN_dispatch_en_main = 1;
1509
+
1510
+
1511
+ #line 538 "edn_parser.rl"
1512
+
1513
+
1514
+
1515
+ const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Object& o, bool& discard)
1516
+ {
1517
+ int cs;
1518
+ Rice::String str;
1519
+
1520
+
1521
+ #line 1522 "edn_parser.cc"
1522
+ {
1523
+ cs = EDN_dispatch_start;
1524
+ }
1525
+
1526
+ #line 547 "edn_parser.rl"
1527
+ p_save = p;
1528
+
1529
+ #line 1530 "edn_parser.cc"
1530
+ {
1531
+ if ( p == pe )
1532
+ goto _test_eof;
1533
+ switch ( cs )
1534
+ {
1535
+ case 1:
1536
+ if ( (*p) == 35 )
1537
+ goto st2;
1538
+ goto st0;
1539
+ st0:
1540
+ cs = 0;
1541
+ goto _out;
1542
+ st2:
1543
+ if ( ++p == pe )
1544
+ goto _test_eof2;
1545
+ case 2:
1546
+ switch( (*p) ) {
1547
+ case 95: goto st15;
1548
+ case 105: goto st3;
1549
+ case 117: goto st9;
1550
+ }
1551
+ goto st0;
1552
+ st15:
1553
+ if ( ++p == pe )
1554
+ goto _test_eof15;
1555
+ case 15:
1556
+ switch( (*p) ) {
1557
+ case 32: goto st17;
1558
+ case 43: goto st0;
1559
+ case 58: goto st0;
1560
+ }
1561
+ if ( (*p) < 48 ) {
1562
+ if ( (*p) > 13 ) {
1563
+ if ( 45 <= (*p) && (*p) <= 46 )
1564
+ goto st17;
1565
+ } else if ( (*p) >= 9 )
1566
+ goto tr17;
1567
+ } else if ( (*p) > 57 ) {
1568
+ if ( (*p) > 90 ) {
1569
+ if ( 97 <= (*p) && (*p) <= 122 )
1570
+ goto st17;
1571
+ } else if ( (*p) >= 65 )
1572
+ goto st17;
1573
+ } else
1574
+ goto st17;
1575
+ goto tr16;
1576
+ tr16:
1577
+ #line 530 "edn_parser.rl"
1578
+ { p--; {p++; cs = 16; goto _out;} }
1579
+ goto st16;
1580
+ st16:
1581
+ if ( ++p == pe )
1582
+ goto _test_eof16;
1583
+ case 16:
1584
+ #line 1585 "edn_parser.cc"
1585
+ switch( (*p) ) {
1586
+ case 32: goto st0;
1587
+ case 43: goto st0;
1588
+ }
1589
+ if ( (*p) < 48 ) {
1590
+ if ( 45 <= (*p) && (*p) <= 46 )
1591
+ goto st0;
1592
+ } else if ( (*p) > 58 ) {
1593
+ if ( (*p) > 90 ) {
1594
+ if ( 97 <= (*p) && (*p) <= 122 )
1595
+ goto st0;
1596
+ } else if ( (*p) >= 65 )
1597
+ goto st0;
1598
+ } else
1599
+ goto st0;
1600
+ goto tr16;
1601
+ tr17:
1602
+ #line 530 "edn_parser.rl"
1603
+ { p--; {p++; cs = 17; goto _out;} }
1604
+ goto st17;
1605
+ st17:
1606
+ if ( ++p == pe )
1607
+ goto _test_eof17;
1608
+ case 17:
1609
+ #line 1610 "edn_parser.cc"
1610
+ switch( (*p) ) {
1611
+ case 32: goto st0;
1612
+ case 43: goto st0;
1613
+ case 58: goto st0;
1614
+ }
1615
+ if ( (*p) < 48 ) {
1616
+ if ( 45 <= (*p) && (*p) <= 46 )
1617
+ goto st17;
1618
+ } else if ( (*p) > 57 ) {
1619
+ if ( (*p) > 90 ) {
1620
+ if ( 97 <= (*p) && (*p) <= 122 )
1621
+ goto st17;
1622
+ } else if ( (*p) >= 65 )
1623
+ goto st17;
1624
+ } else
1625
+ goto st17;
1626
+ goto tr16;
1627
+ st3:
1628
+ if ( ++p == pe )
1629
+ goto _test_eof3;
1630
+ case 3:
1631
+ if ( (*p) == 110 )
1632
+ goto st4;
1633
+ goto st0;
1634
+ st4:
1635
+ if ( ++p == pe )
1636
+ goto _test_eof4;
1637
+ case 4:
1638
+ if ( (*p) == 115 )
1639
+ goto st5;
1640
+ goto st0;
1641
+ st5:
1642
+ if ( ++p == pe )
1643
+ goto _test_eof5;
1644
+ case 5:
1645
+ if ( (*p) == 116 )
1646
+ goto st6;
1647
+ goto st0;
1648
+ st6:
1649
+ if ( ++p == pe )
1650
+ goto _test_eof6;
1651
+ case 6:
1652
+ if ( (*p) == 32 )
1653
+ goto st7;
1654
+ goto st0;
1655
+ st7:
1656
+ if ( ++p == pe )
1657
+ goto _test_eof7;
1658
+ case 7:
1659
+ if ( (*p) == 34 )
1660
+ goto st8;
1661
+ goto st0;
1662
+ st8:
1663
+ if ( ++p == pe )
1664
+ goto _test_eof8;
1665
+ case 8:
1666
+ switch( (*p) ) {
1667
+ case 34: goto st16;
1668
+ case 43: goto st8;
1669
+ case 84: goto st8;
1670
+ case 90: goto st8;
1671
+ }
1672
+ if ( (*p) > 46 ) {
1673
+ if ( 48 <= (*p) && (*p) <= 58 )
1674
+ goto st8;
1675
+ } else if ( (*p) >= 45 )
1676
+ goto st8;
1677
+ goto st0;
1678
+ st9:
1679
+ if ( ++p == pe )
1680
+ goto _test_eof9;
1681
+ case 9:
1682
+ if ( (*p) == 117 )
1683
+ goto st10;
1684
+ goto st0;
1685
+ st10:
1686
+ if ( ++p == pe )
1687
+ goto _test_eof10;
1688
+ case 10:
1689
+ if ( (*p) == 105 )
1690
+ goto st11;
1691
+ goto st0;
1692
+ st11:
1693
+ if ( ++p == pe )
1694
+ goto _test_eof11;
1695
+ case 11:
1696
+ if ( (*p) == 100 )
1697
+ goto st12;
1698
+ goto st0;
1699
+ st12:
1700
+ if ( ++p == pe )
1701
+ goto _test_eof12;
1702
+ case 12:
1703
+ if ( (*p) == 32 )
1704
+ goto st13;
1705
+ goto st0;
1706
+ st13:
1707
+ if ( ++p == pe )
1708
+ goto _test_eof13;
1709
+ case 13:
1710
+ if ( (*p) == 34 )
1711
+ goto st14;
1712
+ goto st0;
1713
+ st14:
1714
+ if ( ++p == pe )
1715
+ goto _test_eof14;
1716
+ case 14:
1717
+ switch( (*p) ) {
1718
+ case 34: goto st16;
1719
+ case 45: goto st14;
1720
+ }
1721
+ if ( (*p) > 57 ) {
1722
+ if ( 97 <= (*p) && (*p) <= 102 )
1723
+ goto st14;
1724
+ } else if ( (*p) >= 48 )
1725
+ goto st14;
1726
+ goto st0;
1727
+ }
1728
+ _test_eof2: cs = 2; goto _test_eof;
1729
+ _test_eof15: cs = 15; goto _test_eof;
1730
+ _test_eof16: cs = 16; goto _test_eof;
1731
+ _test_eof17: cs = 17; goto _test_eof;
1732
+ _test_eof3: cs = 3; goto _test_eof;
1733
+ _test_eof4: cs = 4; goto _test_eof;
1734
+ _test_eof5: cs = 5; goto _test_eof;
1735
+ _test_eof6: cs = 6; goto _test_eof;
1736
+ _test_eof7: cs = 7; goto _test_eof;
1737
+ _test_eof8: cs = 8; goto _test_eof;
1738
+ _test_eof9: cs = 9; goto _test_eof;
1739
+ _test_eof10: cs = 10; goto _test_eof;
1740
+ _test_eof11: cs = 11; goto _test_eof;
1741
+ _test_eof12: cs = 12; goto _test_eof;
1742
+ _test_eof13: cs = 13; goto _test_eof;
1743
+ _test_eof14: cs = 14; goto _test_eof;
1744
+
1745
+ _test_eof: {}
1746
+ _out: {}
1747
+ }
1748
+
1749
+ #line 549 "edn_parser.rl"
1750
+
1751
+ if (cs >= EDN_dispatch_first_final) {
1752
+
1753
+ //is it a discard? if so, just drop the following token
1754
+ if (*(p_save + 1) == '_')
1755
+ {
1756
+ discard = true;
1757
+ return p + 1;
1758
+ }
1759
+
1760
+ std::size_t len = p - p_save;
1761
+ std::string buf;
1762
+ buf.reserve(len);
1763
+
1764
+ if (len > 10)
1765
+ {
1766
+ // there's enough room to be #inst or #uuid, copy the
1767
+ // string portion
1768
+ if (std::strncmp(p_save + 1, "inst", 4) == 0) {
1769
+ buf.append(p_save + 7, len - 8);
1770
+ } else if (std::strncmp(p_save + 1, "uuid", 4) == 0) {
1771
+ buf.append(p_save + 7, len - 8);
1772
+ }
1773
+
1774
+ o = Rice::String(buf);
1775
+ return p;
1776
+ }
1777
+
1778
+ // tagged element
1779
+ o = Rice::String(buf);
1780
+ return p;
1781
+ }
1782
+ else if (cs == EDN_dispatch_error) {
1783
+ error(*p);
1784
+ return pe;
1785
+ }
1786
+ else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
1787
+ return NULL;
1788
+ }
1789
+
1790
+
1863
1791
  // ============================================================
1864
1792
  // main parsing machine
1865
1793
  //
1866
1794
 
1867
- #line 1868 "edn_parser.cc"
1795
+ #line 1796 "edn_parser.cc"
1868
1796
  static const int EDN_start = 1;
1869
1797
  static const int EDN_error = 0;
1870
1798
 
1871
1799
  static const int EDN_en_main = 1;
1872
1800
 
1873
1801
 
1874
- #line 691 "edn_parser.rl"
1802
+ #line 619 "edn_parser.rl"
1875
1803
 
1876
1804
 
1877
1805
  //
@@ -1887,31 +1815,31 @@ Rice::Object edn::Parser::parse(const char* buf, std::size_t len)
1887
1815
  line_number = 1;
1888
1816
 
1889
1817
 
1890
- #line 1891 "edn_parser.cc"
1818
+ #line 1819 "edn_parser.cc"
1891
1819
  {
1892
1820
  cs = EDN_start;
1893
1821
  }
1894
1822
 
1895
- #line 706 "edn_parser.rl"
1823
+ #line 634 "edn_parser.rl"
1896
1824
  p = &buf[0];
1897
1825
  pe = p + len;
1898
1826
  eof = pe; // eof defined in Parser class
1899
1827
 
1900
- #line 1901 "edn_parser.cc"
1828
+ #line 1829 "edn_parser.cc"
1901
1829
  {
1902
1830
  if ( p == pe )
1903
1831
  goto _test_eof;
1904
1832
  switch ( cs )
1905
1833
  {
1906
1834
  tr2:
1907
- #line 21 "edn_parser.rl"
1835
+ #line 22 "edn_parser.rl"
1908
1836
  { line_number++; }
1909
1837
  goto st1;
1910
1838
  st1:
1911
1839
  if ( ++p == pe )
1912
1840
  goto _test_eof1;
1913
1841
  case 1:
1914
- #line 1915 "edn_parser.cc"
1842
+ #line 1843 "edn_parser.cc"
1915
1843
  switch( (*p) ) {
1916
1844
  case 10: goto tr2;
1917
1845
  case 32: goto st1;
@@ -1928,27 +1856,27 @@ st0:
1928
1856
  cs = 0;
1929
1857
  goto _out;
1930
1858
  tr8:
1931
- #line 21 "edn_parser.rl"
1859
+ #line 22 "edn_parser.rl"
1932
1860
  { line_number++; }
1933
1861
  goto st4;
1934
1862
  tr3:
1935
- #line 681 "edn_parser.rl"
1863
+ #line 609 "edn_parser.rl"
1936
1864
  {
1937
- const char *np = EDN_parse_list(p, pe, result);
1865
+ const char *np = parse_list(p, pe, result);
1938
1866
  if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
1939
1867
  }
1940
1868
  goto st4;
1941
1869
  tr5:
1942
- #line 671 "edn_parser.rl"
1870
+ #line 599 "edn_parser.rl"
1943
1871
  {
1944
- const char* np = EDN_parse_vector(p, pe, result);
1872
+ const char* np = parse_vector(p, pe, result);
1945
1873
  if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
1946
1874
  }
1947
1875
  goto st4;
1948
1876
  tr6:
1949
- #line 676 "edn_parser.rl"
1877
+ #line 604 "edn_parser.rl"
1950
1878
  {
1951
- const char *np = EDN_parse_map(p, pe, result);
1879
+ const char *np = parse_map(p, pe, result);
1952
1880
  if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
1953
1881
  }
1954
1882
  goto st4;
@@ -1956,7 +1884,7 @@ st4:
1956
1884
  if ( ++p == pe )
1957
1885
  goto _test_eof4;
1958
1886
  case 4:
1959
- #line 1960 "edn_parser.cc"
1887
+ #line 1888 "edn_parser.cc"
1960
1888
  switch( (*p) ) {
1961
1889
  case 10: goto tr8;
1962
1890
  case 32: goto st4;
@@ -1990,7 +1918,7 @@ case 3:
1990
1918
  _out: {}
1991
1919
  }
1992
1920
 
1993
- #line 710 "edn_parser.rl"
1921
+ #line 638 "edn_parser.rl"
1994
1922
 
1995
1923
  if (cs == EDN_error) {
1996
1924
  error(*p);