edn_turbo 0.1.0 → 0.1.1

data/ext/edn_turbo/edn_parser.cc

@@ -3,9 +3,6 @@
 #include <iostream>
 #include <string>
 
-#include <ruby/ruby.h>
-#include <ruby/encoding.h>
-
 #include <rice/Hash.hpp>
 #include <rice/Array.hpp>
 #include <rice/to_from_ruby.hpp>
@@ -15,9 +12,13 @@
 //
 // EDN spec at: https://github.com/edn-format/edn
 //
+//
+// many thanks to Florian Frank for json-ruby which was essential in
+// helping me learn about ragel
+//
 
 
-#line 47 "edn_parser.rl"
+#line 48 "edn_parser.rl"
 
 
 // ============================================================
@@ -25,7 +26,7 @@
 //
 
 
-#line 29 "edn_parser.cc"
+#line 30 "edn_parser.cc"
 static const int EDN_value_start = 1;
 static const int EDN_value_first_final = 11;
 static const int EDN_value_error = 0;
@@ -33,23 +34,23 @@ static const int EDN_value_error = 0;
 static const int EDN_value_en_main = 1;
 
 
-#line 126 "edn_parser.rl"
+#line 127 "edn_parser.rl"
 
 
 
-const char *edn::Parser::EDN_parse_value(const char *p, const char *pe, Rice::Object& o)
+const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
 
 
-#line 46 "edn_parser.cc"
+#line 47 "edn_parser.cc"
 	{
 	cs = EDN_value_start;
 	}
 
-#line 134 "edn_parser.rl"
+#line 135 "edn_parser.rl"
 
-#line 53 "edn_parser.cc"
+#line 54 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -74,27 +75,27 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 74 "edn_parser.rl"
+#line 75 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_string(p, pe, o);
+        const char *np = parse_string(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
     }
 	goto st11;
 tr2:
-#line 103 "edn_parser.rl"
+#line 104 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_list(p, pe, o);
+        const char *np = parse_list(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
     }
 	goto st11;
 tr3:
-#line 79 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{
         // try to parse a decimal first
-        const char *np = EDN_parse_decimal(p, pe, o);
+        const char *np = parse_decimal(p, pe, o);
         if (np == NULL) {
             // if we can't, try to parse it as an int
-            np = EDN_parse_integer(p, pe, o);
+            np = parse_integer(p, pe, o);
         }
 
         if (np) {
@@ -109,40 +110,40 @@ tr3:
     }
 	goto st11;
 tr4:
-#line 69 "edn_parser.rl"
+#line 70 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_keyword(p, pe, o);
+        const char *np = parse_keyword(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
     }
 	goto st11;
 tr5:
-#line 98 "edn_parser.rl"
+#line 99 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_vector(p, pe, o);
+        const char *np = parse_vector(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
     }
 	goto st11;
 tr9:
-#line 108 "edn_parser.rl"
+#line 109 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_map(p, pe, o);
+        const char *np = parse_map(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 11; goto _out;} } else {p = (( np))-1;}
     }
 	goto st11;
 tr13:
-#line 62 "edn_parser.rl"
+#line 63 "edn_parser.rl"
 	{
         o = Qfalse;
     }
 	goto st11;
 tr15:
-#line 59 "edn_parser.rl"
+#line 60 "edn_parser.rl"
 	{
         o = Qnil;
     }
 	goto st11;
 tr18:
-#line 65 "edn_parser.rl"
+#line 66 "edn_parser.rl"
 	{
         o = Qtrue;
     }
@@ -151,9 +152,9 @@ st11:
 	if ( ++p == pe )
 		goto _test_eof11;
 case 11:
-#line 113 "edn_parser.rl"
+#line 114 "edn_parser.rl"
 	{ p--; {p++; cs = 11; goto _out;} }
-#line 157 "edn_parser.cc"
+#line 158 "edn_parser.cc"
 	goto st0;
 st2:
 	if ( ++p == pe )
@@ -234,7 +235,7 @@ case 10:
 	_out: {}
 	}
 
-#line 135 "edn_parser.rl"
+#line 136 "edn_parser.rl"
 
     if (cs >= EDN_value_first_final) {
         return p;
@@ -248,35 +249,34 @@ case 10:
 }
 
 
+
 // ============================================================
-// tagged element parsing - any of #uuid, #inst, #{, #(some symbol)
-// discard (#_ <ident>) is handled by the top-level machine
+// keyword parsing
 //
 
-#line 257 "edn_parser.cc"
-static const int EDN_dispatch_start = 1;
-static const int EDN_dispatch_first_final = 15;
-static const int EDN_dispatch_error = 0;
+#line 258 "edn_parser.cc"
+static const int EDN_keyword_start = 1;
+static const int EDN_keyword_first_final = 4;
+static const int EDN_keyword_error = 0;
 
-static const int EDN_dispatch_en_main = 1;
+static const int EDN_keyword_en_main = 1;
 
 
-#line 170 "edn_parser.rl"
+#line 164 "edn_parser.rl"
 
 
 
-const char* edn::Parser::EDN_parse_tagged(const char *p, const char *pe, Rice::Object& o, bool& discard)
+const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
-    Rice::String str;
 
 
 #line 275 "edn_parser.cc"
 	{
-	cs = EDN_dispatch_start;
+	cs = EDN_keyword_start;
 	}
 
-#line 179 "edn_parser.rl"
+#line 172 "edn_parser.rl"
     p_save = p;
 
 #line 283 "edn_parser.cc"
@@ -286,7 +286,7 @@ const char* edn::Parser::EDN_parse_tagged(const char *p, const char *pe, Rice::O
 	switch ( cs )
 	{
 case 1:
-	if ( (*p) == 35 )
+	if ( (*p) == 58 )
 		goto st2;
 	goto st0;
 st0:
@@ -296,381 +296,89 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	switch( (*p) ) {
-		case 95: goto st15;
-		case 105: goto st3;
-		case 117: goto st9;
-	}
-	goto st0;
-st15:
-	if ( ++p == pe )
-		goto _test_eof15;
-case 15:
-	switch( (*p) ) {
-		case 32: goto st17;
-		case 43: goto st0;
-		case 58: goto st0;
-	}
-	if ( (*p) < 48 ) {
-		if ( (*p) > 13 ) {
-			if ( 45 <= (*p) && (*p) <= 46 )
-				goto st17;
-		} else if ( (*p) >= 9 )
-			goto tr17;
-	} else if ( (*p) > 57 ) {
-		if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st17;
-		} else if ( (*p) >= 65 )
-			goto st17;
-	} else
-		goto st17;
-	goto tr16;
-tr16:
-#line 162 "edn_parser.rl"
-	{ p--; {p++; cs = 16; goto _out;} }
-	goto st16;
-st16:
-	if ( ++p == pe )
-		goto _test_eof16;
-case 16:
-#line 338 "edn_parser.cc"
-	switch( (*p) ) {
-		case 32: goto st0;
-		case 43: goto st0;
-	}
-	if ( (*p) < 48 ) {
-		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st0;
-	} else if ( (*p) > 58 ) {
-		if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st0;
-		} else if ( (*p) >= 65 )
-			goto st0;
-	} else
-		goto st0;
-	goto tr16;
-tr17:
-#line 162 "edn_parser.rl"
-	{ p--; {p++; cs = 17; goto _out;} }
-	goto st17;
-st17:
-	if ( ++p == pe )
-		goto _test_eof17;
-case 17:
-#line 363 "edn_parser.cc"
-	switch( (*p) ) {
-		case 32: goto st0;
-		case 43: goto st0;
-		case 58: goto st0;
-	}
-	if ( (*p) < 48 ) {
-		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st17;
-	} else if ( (*p) > 57 ) {
-		if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st17;
-		} else if ( (*p) >= 65 )
-			goto st17;
-	} else
-		goto st17;
-	goto tr16;
-st3:
-	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
-	if ( (*p) == 110 )
+	if ( (*p) == 95 )
+		goto st4;
+	if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st4;
+	} else if ( (*p) >= 65 )
 		goto st4;
 	goto st0;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-	if ( (*p) == 115 )
-		goto st5;
-	goto st0;
+	switch( (*p) ) {
+		case 39: goto st0;
+		case 45: goto st4;
+		case 47: goto st3;
+		case 95: goto st4;
+	}
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto st4;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st4;
+	} else
+		goto st4;
+	goto tr4;
+tr4:
+#line 159 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-	if ( (*p) == 116 )
+#line 335 "edn_parser.cc"
+	goto st0;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) == 95 )
+		goto st6;
+	if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st6;
+	} else if ( (*p) >= 65 )
 		goto st6;
 	goto st0;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-	if ( (*p) == 32 )
-		goto st7;
-	goto st0;
-st7:
-	if ( ++p == pe )
-		goto _test_eof7;
-case 7:
-	if ( (*p) == 34 )
-		goto st8;
-	goto st0;
-st8:
-	if ( ++p == pe )
-		goto _test_eof8;
-case 8:
-	switch( (*p) ) {
-		case 34: goto st16;
-		case 43: goto st8;
-		case 84: goto st8;
-		case 90: goto st8;
-	}
-	if ( (*p) > 46 ) {
-		if ( 48 <= (*p) && (*p) <= 58 )
-			goto st8;
-	} else if ( (*p) >= 45 )
-		goto st8;
-	goto st0;
-st9:
-	if ( ++p == pe )
-		goto _test_eof9;
-case 9:
-	if ( (*p) == 117 )
-		goto st10;
-	goto st0;
-st10:
-	if ( ++p == pe )
-		goto _test_eof10;
-case 10:
-	if ( (*p) == 105 )
-		goto st11;
-	goto st0;
-st11:
-	if ( ++p == pe )
-		goto _test_eof11;
-case 11:
-	if ( (*p) == 100 )
-		goto st12;
-	goto st0;
-st12:
-	if ( ++p == pe )
-		goto _test_eof12;
-case 12:
-	if ( (*p) == 32 )
-		goto st13;
-	goto st0;
-st13:
-	if ( ++p == pe )
-		goto _test_eof13;
-case 13:
-	if ( (*p) == 34 )
-		goto st14;
-	goto st0;
-st14:
-	if ( ++p == pe )
-		goto _test_eof14;
-case 14:
 	switch( (*p) ) {
-		case 34: goto st16;
-		case 45: goto st14;
+		case 39: goto st0;
+		case 45: goto st6;
+		case 47: goto st0;
+		case 95: goto st6;
 	}
-	if ( (*p) > 57 ) {
-		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st14;
-	} else if ( (*p) >= 48 )
-		goto st14;
-	goto st0;
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto st6;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st6;
+	} else
+		goto st6;
+	goto tr4;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
-	_test_eof15: cs = 15; goto _test_eof;
-	_test_eof16: cs = 16; goto _test_eof;
-	_test_eof17: cs = 17; goto _test_eof;
-	_test_eof3: cs = 3; goto _test_eof;
 	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof5: cs = 5; goto _test_eof;
+	_test_eof3: cs = 3; goto _test_eof;
 	_test_eof6: cs = 6; goto _test_eof;
-	_test_eof7: cs = 7; goto _test_eof;
-	_test_eof8: cs = 8; goto _test_eof;
-	_test_eof9: cs = 9; goto _test_eof;
-	_test_eof10: cs = 10; goto _test_eof;
-	_test_eof11: cs = 11; goto _test_eof;
-	_test_eof12: cs = 12; goto _test_eof;
-	_test_eof13: cs = 13; goto _test_eof;
-	_test_eof14: cs = 14; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 181 "edn_parser.rl"
-
-    if (cs >= EDN_dispatch_first_final) {
-
-        //is it a discard? if so, just drop the following token
-        if (*(p_save + 1) == '_')
-        {
-            discard = true;
-            return p + 1;
-        }
+#line 174 "edn_parser.rl"
 
-        std::size_t len = p - p_save;
-        std::string buf;
-        buf.reserve(len);
-
-        if (len > 10)
-        {
-            // there's enough room to be #inst or #uuid, copy the
-            // string portion
-            if (std::strncmp(p_save + 1, "inst", 4) == 0) {
-                buf.append(p_save + 7, len - 8);
-            } else if (std::strncmp(p_save + 1, "uuid", 4) == 0) {
-                buf.append(p_save + 7, len - 8);
-            }
-
-            o = Rice::String(buf);
-            return p;
-        }
-
-        // tagged element
-        o = Rice::String(buf);
-        return p;
-    }
-    else if (cs == EDN_dispatch_error) {
-        error(*p);
-        return pe;
-    }
-    else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
-    return NULL;
-}
-
-
-
-// ============================================================
-// keyword parsing
-//
-
-#line 550 "edn_parser.cc"
-static const int EDN_keyword_start = 1;
-static const int EDN_keyword_first_final = 4;
-static const int EDN_keyword_error = 0;
-
-static const int EDN_keyword_en_main = 1;
-
-
-#line 237 "edn_parser.rl"
-
-
-
-const char* edn::Parser::EDN_parse_keyword(const char *p, const char *pe, Rice::Object& o)
-{
-    int cs;
-
-
-#line 567 "edn_parser.cc"
-	{
-	cs = EDN_keyword_start;
-	}
-
-#line 245 "edn_parser.rl"
-    p_save = p;
-
-#line 575 "edn_parser.cc"
-	{
-	if ( p == pe )
-		goto _test_eof;
-	switch ( cs )
-	{
-case 1:
-	if ( (*p) == 58 )
-		goto st2;
-	goto st0;
-st0:
-cs = 0;
-	goto _out;
-st2:
-	if ( ++p == pe )
-		goto _test_eof2;
-case 2:
-	if ( (*p) == 95 )
-		goto st4;
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st4;
-	} else if ( (*p) >= 65 )
-		goto st4;
-	goto st0;
-st4:
-	if ( ++p == pe )
-		goto _test_eof4;
-case 4:
-	switch( (*p) ) {
-		case 39: goto st0;
-		case 45: goto st4;
-		case 47: goto st3;
-		case 95: goto st4;
-	}
-	if ( (*p) < 65 ) {
-		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st4;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st4;
-	} else
-		goto st4;
-	goto tr4;
-tr4:
-#line 232 "edn_parser.rl"
-	{ p--; {p++; cs = 5; goto _out;} }
-	goto st5;
-st5:
-	if ( ++p == pe )
-		goto _test_eof5;
-case 5:
-#line 627 "edn_parser.cc"
-	goto st0;
-st3:
-	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
-	if ( (*p) == 95 )
-		goto st6;
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st6;
-	} else if ( (*p) >= 65 )
-		goto st6;
-	goto st0;
-st6:
-	if ( ++p == pe )
-		goto _test_eof6;
-case 6:
-	switch( (*p) ) {
-		case 39: goto st0;
-		case 45: goto st6;
-		case 47: goto st0;
-		case 95: goto st6;
-	}
-	if ( (*p) < 65 ) {
-		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st6;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st6;
-	} else
-		goto st6;
-	goto tr4;
-	}
-	_test_eof2: cs = 2; goto _test_eof;
-	_test_eof4: cs = 4; goto _test_eof;
-	_test_eof5: cs = 5; goto _test_eof;
-	_test_eof3: cs = 3; goto _test_eof;
-	_test_eof6: cs = 6; goto _test_eof;
-
-	_test_eof: {}
-	_out: {}
-	}
-
-#line 247 "edn_parser.rl"
-
-    if (cs >= EDN_keyword_first_final) {
-        uint32_t len = p - p_save - 1; // don't include leading ':' because Rice::Symbol will handle it
+    if (cs >= EDN_keyword_first_final) {
+        uint32_t len = p - p_save - 1; // don't include leading ':' because Rice::Symbol will handle it
         std::string buf;
         buf.append(p_save + 1, len);
         o = Rice::Symbol(buf);
@@ -690,7 +398,7 @@ case 6:
 // string parsing
 //
 
-#line 694 "edn_parser.cc"
+#line 402 "edn_parser.cc"
 static const int EDN_string_start = 1;
 static const int EDN_string_first_final = 8;
 static const int EDN_string_error = 0;
@@ -698,86 +406,11 @@ static const int EDN_string_error = 0;
 static const int EDN_string_en_main = 1;
 
 
-#line 292 "edn_parser.rl"
+#line 219 "edn_parser.rl"
 
 
 
-//
-// copies the string data, unescaping any present values that need to be replaced
-//
-bool edn::Parser::EDN_parse_byte_stream(const char *p, const char *pe, Rice::String& s)
-{
-    if (pe > p) {
-        std::string buf;
-        std::size_t len = pe - p;
-
-        // pre-allocate storage needed
-        buf.reserve(len);
-
-        const char* cp = p;
-        std::size_t pos = 0;
-        char c, replacement;
-
-        while (cp < pe)
-        {
-            // append any other character that is not the escaping slash
-            if (*cp != '\\') {
-                buf.replace(pos++, 1, 1, *cp++);
-                continue;
-            }
-
-            // looking at a '\' - check what it escapes if there's a
-            // following character
-            if (++cp == pe)
-                break;
-
-            c = *cp++;
-            replacement = '?';
-
-            switch (c)
-            {
-              case 't':
-                  replacement = '\t';
-                  break;
-              case 'n':
-                  replacement = '\n';
-                  break;
-              case 'r':
-                  replacement = '\r';
-                  break;
-              case '\"':
-                  replacement = '\"';
-                  break;
-              case '\\':
-                  replacement = '\\';
-                  break;
-                  /* TODO: add support for this!
-              case 'u':
-                  replacement = '\u';
-                  break;
-                  */
-              default:
-                  std::cerr << "value must be unescaped but case is unhandled: '" << c << "'" << std::endl;
-                  break;
-            }
-
-            // substitute the escaped walue
-            if (replacement != '?')
-                buf.replace(pos++, 1, 1, replacement);
-        }
-
-        // utf-8 encode
-        VALUE vs = Rice::protect( rb_str_new2, buf.c_str() );
-        VALUE s_utf8 = Rice::protect( rb_enc_associate, vs, rb_utf8_encoding() );
-        s = Rice::String(s_utf8);
-        return true;
-    }
-
-    return false;
-}
-
-
-const char* edn::Parser::EDN_parse_string(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_string(const char *p, const char *pe, Rice::Object& o)
 {
     static const char* EDN_TYPE = "string";
     int cs;
@@ -785,15 +418,15 @@ const char* edn::Parser::EDN_parse_string(const char *p, const char *pe, Rice::O
 
     Rice::String s;
 
-#line 789 "edn_parser.cc"
+#line 422 "edn_parser.cc"
 	{
 	cs = EDN_string_start;
 	}
 
-#line 378 "edn_parser.rl"
+#line 230 "edn_parser.rl"
     p_save = p;
 
-#line 797 "edn_parser.cc"
+#line 430 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -804,7 +437,7 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -812,7 +445,7 @@ tr2:
             {p = (( pe))-1;}
         }
 	goto st0;
-#line 816 "edn_parser.cc"
+#line 449 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -828,23 +461,23 @@ case 2:
 		goto tr2;
 	goto st2;
 tr3:
-#line 274 "edn_parser.rl"
+#line 201 "edn_parser.rl"
 	{
-        if (!EDN_parse_byte_stream(p_save + 1, p, s)) {
+        if (!parse_byte_stream(p_save + 1, p, s)) {
             p--;
             {p++; cs = 8; goto _out;}
         } else {
             {p = (( p + 1))-1;}
         }
     }
-#line 283 "edn_parser.rl"
+#line 210 "edn_parser.rl"
 	{ p--; {p++; cs = 8; goto _out;} }
 	goto st8;
 st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 848 "edn_parser.cc"
+#line 481 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -921,7 +554,7 @@ case 7:
 	{
 	switch ( cs ) {
 	case 2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -929,14 +562,14 @@ case 7:
             {p = (( pe))-1;}
         }
 	break;
-#line 933 "edn_parser.cc"
+#line 566 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 380 "edn_parser.rl"
+#line 232 "edn_parser.rl"
 
     if (cs >= EDN_string_first_final) {
         o = s;
@@ -953,31 +586,31 @@ case 7:
 // decimal parsing grammar
 //
 
-#line 957 "edn_parser.cc"
+#line 590 "edn_parser.cc"
 static const int EDN_decimal_start = 1;
 static const int EDN_decimal_first_final = 8;
 
 static const int EDN_decimal_en_main = 1;
 
 
-#line 410 "edn_parser.rl"
+#line 262 "edn_parser.rl"
 
 
 
-const char* edn::Parser::EDN_parse_decimal(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
 
 
-#line 973 "edn_parser.cc"
+#line 606 "edn_parser.cc"
 	{
 	cs = EDN_decimal_start;
 	}
 
-#line 418 "edn_parser.rl"
+#line 270 "edn_parser.rl"
     p_save = p;
 
-#line 981 "edn_parser.cc"
+#line 614 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1036,14 +669,14 @@ case 8:
 		goto st0;
 	goto tr9;
 tr9:
-#line 401 "edn_parser.rl"
+#line 253 "edn_parser.rl"
 	{ p--; {p++; cs = 9; goto _out;} }
 	goto st9;
 st9:
 	if ( ++p == pe )
 		goto _test_eof9;
 case 9:
-#line 1047 "edn_parser.cc"
+#line 680 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -1121,7 +754,7 @@ case 7:
 	_out: {}
 	}
 
-#line 420 "edn_parser.rl"
+#line 272 "edn_parser.rl"
 
     if (cs >= EDN_decimal_first_final) {
         double value;
@@ -1137,30 +770,30 @@ case 7:
 // integer parsing grammar
 //
 
-#line 1141 "edn_parser.cc"
+#line 774 "edn_parser.cc"
 static const int EDN_integer_start = 1;
 static const int EDN_integer_first_final = 3;
 
 static const int EDN_integer_en_main = 1;
 
 
-#line 442 "edn_parser.rl"
+#line 294 "edn_parser.rl"
 
 
-const char* edn::Parser::EDN_parse_integer(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
 
 
-#line 1156 "edn_parser.cc"
+#line 789 "edn_parser.cc"
 	{
 	cs = EDN_integer_start;
 	}
 
-#line 449 "edn_parser.rl"
+#line 301 "edn_parser.rl"
     p_save = p;
 
-#line 1164 "edn_parser.cc"
+#line 797 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1196,14 +829,14 @@ case 3:
 		goto st0;
 	goto tr4;
 tr4:
-#line 439 "edn_parser.rl"
+#line 291 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1207 "edn_parser.cc"
+#line 840 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -1224,7 +857,7 @@ case 5:
 	_out: {}
 	}
 
-#line 451 "edn_parser.rl"
+#line 303 "edn_parser.rl"
 
     if (cs >= EDN_integer_first_final) {
         int value;
@@ -1241,13 +874,13 @@ case 5:
 // vectors and lists since they're both represented as vectors in ruby
 //
 
-#line 503 "edn_parser.rl"
+#line 355 "edn_parser.rl"
 
 
 //
 // vector-specific machine
 
-#line 1251 "edn_parser.cc"
+#line 884 "edn_parser.cc"
 static const int EDN_vector_start = 1;
 static const int EDN_vector_first_final = 4;
 static const int EDN_vector_error = 0;
@@ -1255,14 +888,14 @@ static const int EDN_vector_error = 0;
 static const int EDN_vector_en_main = 1;
 
 
-#line 517 "edn_parser.rl"
+#line 369 "edn_parser.rl"
 
 
 
 //
 // vector parsing
 //
-const char* edn::Parser::EDN_parse_vector(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_vector(const char *p, const char *pe, Rice::Object& o)
 {
     static const char* EDN_TYPE = "vector";
 
@@ -1270,14 +903,14 @@ const char* edn::Parser::EDN_parse_vector(const char *p, const char *pe, Rice::O
     Rice::Array arr;
 
 
-#line 1274 "edn_parser.cc"
+#line 907 "edn_parser.cc"
 	{
 	cs = EDN_vector_start;
 	}
 
-#line 531 "edn_parser.rl"
+#line 383 "edn_parser.rl"
 
-#line 1281 "edn_parser.cc"
+#line 914 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1288,7 +921,7 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1296,19 +929,19 @@ tr2:
             {p = (( pe))-1;}
         }
 	goto st0;
-#line 1300 "edn_parser.cc"
+#line 933 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr3:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 470 "edn_parser.rl"
+#line 322 "edn_parser.rl"
 	{
         Rice::Object v;
-        const char *np = EDN_parse_value(p, pe, v);
+        const char *np = parse_value(p, pe, v);
         if (np == NULL) {
             p--; {p++; cs = 2; goto _out;}
         } else {
@@ -1318,11 +951,11 @@ tr4:
     }
 	goto st2;
 tr5:
-#line 481 "edn_parser.rl"
+#line 333 "edn_parser.rl"
 	{
         bool discard = false;
         Rice::Object v;
-        const char *np = EDN_parse_tagged(p, pe, v, discard);
+        const char *np = parse_tagged(p, pe, v, discard);
         if (np == NULL) {
             p--; {p++; cs = 2; goto _out;}
         } else {
@@ -1337,7 +970,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1341 "edn_parser.cc"
+#line 974 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1370,14 +1003,14 @@ case 3:
 		goto tr3;
 	goto st3;
 tr7:
-#line 495 "edn_parser.rl"
+#line 347 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1381 "edn_parser.cc"
+#line 1014 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1389,7 +1022,7 @@ case 4:
 	{
 	switch ( cs ) {
 	case 2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1397,14 +1030,14 @@ case 4:
             {p = (( pe))-1;}
         }
 	break;
-#line 1401 "edn_parser.cc"
+#line 1034 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 532 "edn_parser.rl"
+#line 384 "edn_parser.rl"
 
     if (cs >= EDN_vector_first_final) {
         o = arr;
@@ -1424,7 +1057,7 @@ case 4:
 // list parsing machine
 //
 
-#line 1428 "edn_parser.cc"
+#line 1061 "edn_parser.cc"
 static const int EDN_list_start = 1;
 static const int EDN_list_first_final = 6;
 static const int EDN_list_error = 0;
@@ -1432,13 +1065,13 @@ static const int EDN_list_error = 0;
 static const int EDN_list_en_main = 1;
 
 
-#line 561 "edn_parser.rl"
+#line 413 "edn_parser.rl"
 
 
 //
 // list parsing
 //
-const char* edn::Parser::EDN_parse_list(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_list(const char *p, const char *pe, Rice::Object& o)
 {
     static const char* EDN_TYPE = "list";
 
@@ -1446,14 +1079,14 @@ const char* edn::Parser::EDN_parse_list(const char *p, const char *pe, Rice::Obj
     Rice::Array arr;
 
 
-#line 1450 "edn_parser.cc"
+#line 1083 "edn_parser.cc"
 	{
 	cs = EDN_list_start;
 	}
 
-#line 574 "edn_parser.rl"
+#line 426 "edn_parser.rl"
 
-#line 1457 "edn_parser.cc"
+#line 1090 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1464,7 +1097,7 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1472,19 +1105,19 @@ tr2:
             {p = (( pe))-1;}
         }
 	goto st0;
-#line 1476 "edn_parser.cc"
+#line 1109 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr3:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1488 "edn_parser.cc"
+#line 1121 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1509,14 +1142,14 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr8:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st3;
 tr4:
-#line 470 "edn_parser.rl"
+#line 322 "edn_parser.rl"
 	{
         Rice::Object v;
-        const char *np = EDN_parse_value(p, pe, v);
+        const char *np = parse_value(p, pe, v);
         if (np == NULL) {
             p--; {p++; cs = 3; goto _out;}
         } else {
@@ -1526,11 +1159,11 @@ tr4:
     }
 	goto st3;
 tr9:
-#line 481 "edn_parser.rl"
+#line 333 "edn_parser.rl"
 	{
         bool discard = false;
         Rice::Object v;
-        const char *np = EDN_parse_tagged(p, pe, v, discard);
+        const char *np = parse_tagged(p, pe, v, discard);
         if (np == NULL) {
             p--; {p++; cs = 3; goto _out;}
         } else {
@@ -1545,7 +1178,7 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 1549 "edn_parser.cc"
+#line 1182 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr8;
 		case 32: goto st3;
@@ -1571,14 +1204,14 @@ case 3:
 		goto tr4;
 	goto tr2;
 tr5:
-#line 495 "edn_parser.rl"
+#line 347 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1582 "edn_parser.cc"
+#line 1215 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -1607,7 +1240,7 @@ case 5:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1615,14 +1248,14 @@ case 5:
             {p = (( pe))-1;}
         }
 	break;
-#line 1619 "edn_parser.cc"
+#line 1252 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 575 "edn_parser.rl"
+#line 427 "edn_parser.rl"
 
     if (cs >= EDN_list_first_final) {
         o = arr;
@@ -1642,7 +1275,7 @@ case 5:
 // hash parsing
 //
 
-#line 1646 "edn_parser.cc"
+#line 1279 "edn_parser.cc"
 static const int EDN_map_start = 1;
 static const int EDN_map_first_final = 6;
 static const int EDN_map_error = 0;
@@ -1650,11 +1283,11 @@ static const int EDN_map_error = 0;
 static const int EDN_map_en_main = 1;
 
 
-#line 634 "edn_parser.rl"
+#line 486 "edn_parser.rl"
 
 
 
-const char* edn::Parser::EDN_parse_map(const char *p, const char *pe, Rice::Object& o)
+const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object& o)
 {
     static const char* EDN_TYPE = "map";
 
@@ -1663,15 +1296,15 @@ const char* edn::Parser::EDN_parse_map(const char *p, const char *pe, Rice::Obje
     Rice::Object k, v;
 
 
-#line 1667 "edn_parser.cc"
+#line 1300 "edn_parser.cc"
 	{
 	cs = EDN_map_start;
 	}
 
-#line 646 "edn_parser.rl"
+#line 498 "edn_parser.rl"
     p_save = p;
 
-#line 1675 "edn_parser.cc"
+#line 1308 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1682,7 +1315,7 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1691,24 +1324,24 @@ tr2:
         }
 	goto st0;
 tr7:
-#line 619 "edn_parser.rl"
+#line 471 "edn_parser.rl"
 	{
         error("map pair not found");
         {p = (( pe))-1;}
     }
 	goto st0;
-#line 1701 "edn_parser.cc"
+#line 1334 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr3:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr10:
-#line 608 "edn_parser.rl"
+#line 460 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_value(p, pe, v);
+        const char *np = parse_value(p, pe, v);
         if (np == NULL) {
             p--; {p++; cs = 2; goto _out;}
         } else {
@@ -1721,7 +1354,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1725 "edn_parser.cc"
+#line 1358 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1746,13 +1379,13 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr9:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st3;
 tr4:
-#line 599 "edn_parser.rl"
+#line 451 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_value(p, pe, k);
+        const char *np = parse_value(p, pe, k);
         if (np == NULL) {
             p--; {p++; cs = 3; goto _out;}
         } else {
@@ -1764,7 +1397,7 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 1768 "edn_parser.cc"
+#line 1401 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr9;
 		case 32: goto st3;
@@ -1802,14 +1435,14 @@ case 5:
 		goto tr3;
 	goto st5;
 tr6:
-#line 624 "edn_parser.rl"
+#line 476 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1813 "edn_parser.cc"
+#line 1446 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1823,7 +1456,7 @@ case 6:
 	{
 	switch ( cs ) {
 	case 2:
-#line 41 "edn_parser.rl"
+#line 42 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1832,20 +1465,20 @@ case 6:
         }
 	break;
 	case 3:
-#line 619 "edn_parser.rl"
+#line 471 "edn_parser.rl"
 	{
         error("map pair not found");
         {p = (( pe))-1;}
     }
 	break;
-#line 1842 "edn_parser.cc"
+#line 1475 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 648 "edn_parser.rl"
+#line 500 "edn_parser.rl"
 
     if (cs >= EDN_map_first_final) {
         o = map;
@@ -1860,18 +1493,313 @@ case 6:
 
 
 
+// ============================================================
+// tagged element parsing - any of #uuid, #inst, #{, #(some symbol)
+// discard (#_ <ident>) is handled by the top-level machine
+//
+// NOTE: this is not fully implemented yet
+//
+
+#line 1504 "edn_parser.cc"
+static const int EDN_dispatch_start = 1;
+static const int EDN_dispatch_first_final = 15;
+static const int EDN_dispatch_error = 0;
+
+static const int EDN_dispatch_en_main = 1;
+
+
+#line 538 "edn_parser.rl"
+
+
+
+const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Object& o, bool& discard)
+{
+    int cs;
+    Rice::String str;
+
+
+#line 1522 "edn_parser.cc"
+	{
+	cs = EDN_dispatch_start;
+	}
+
+#line 547 "edn_parser.rl"
+    p_save = p;
+
+#line 1530 "edn_parser.cc"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+case 1:
+	if ( (*p) == 35 )
+		goto st2;
+	goto st0;
+st0:
+cs = 0;
+	goto _out;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	switch( (*p) ) {
+		case 95: goto st15;
+		case 105: goto st3;
+		case 117: goto st9;
+	}
+	goto st0;
+st15:
+	if ( ++p == pe )
+		goto _test_eof15;
+case 15:
+	switch( (*p) ) {
+		case 32: goto st17;
+		case 43: goto st0;
+		case 58: goto st0;
+	}
+	if ( (*p) < 48 ) {
+		if ( (*p) > 13 ) {
+			if ( 45 <= (*p) && (*p) <= 46 )
+				goto st17;
+		} else if ( (*p) >= 9 )
+			goto tr17;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st17;
+		} else if ( (*p) >= 65 )
+			goto st17;
+	} else
+		goto st17;
+	goto tr16;
+tr16:
+#line 530 "edn_parser.rl"
+	{ p--; {p++; cs = 16; goto _out;} }
+	goto st16;
+st16:
+	if ( ++p == pe )
+		goto _test_eof16;
+case 16:
+#line 1585 "edn_parser.cc"
+	switch( (*p) ) {
+		case 32: goto st0;
+		case 43: goto st0;
+	}
+	if ( (*p) < 48 ) {
+		if ( 45 <= (*p) && (*p) <= 46 )
+			goto st0;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st0;
+		} else if ( (*p) >= 65 )
+			goto st0;
+	} else
+		goto st0;
+	goto tr16;
+tr17:
+#line 530 "edn_parser.rl"
+	{ p--; {p++; cs = 17; goto _out;} }
+	goto st17;
+st17:
+	if ( ++p == pe )
+		goto _test_eof17;
+case 17:
+#line 1610 "edn_parser.cc"
+	switch( (*p) ) {
+		case 32: goto st0;
+		case 43: goto st0;
+		case 58: goto st0;
+	}
+	if ( (*p) < 48 ) {
+		if ( 45 <= (*p) && (*p) <= 46 )
+			goto st17;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st17;
+		} else if ( (*p) >= 65 )
+			goto st17;
+	} else
+		goto st17;
+	goto tr16;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) == 110 )
+		goto st4;
+	goto st0;
+st4:
+	if ( ++p == pe )
+		goto _test_eof4;
+case 4:
+	if ( (*p) == 115 )
+		goto st5;
+	goto st0;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+	if ( (*p) == 116 )
+		goto st6;
+	goto st0;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+	if ( (*p) == 32 )
+		goto st7;
+	goto st0;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+	if ( (*p) == 34 )
+		goto st8;
+	goto st0;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+	switch( (*p) ) {
+		case 34: goto st16;
+		case 43: goto st8;
+		case 84: goto st8;
+		case 90: goto st8;
+	}
+	if ( (*p) > 46 ) {
+		if ( 48 <= (*p) && (*p) <= 58 )
+			goto st8;
+	} else if ( (*p) >= 45 )
+		goto st8;
+	goto st0;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+	if ( (*p) == 117 )
+		goto st10;
+	goto st0;
+st10:
+	if ( ++p == pe )
+		goto _test_eof10;
+case 10:
+	if ( (*p) == 105 )
+		goto st11;
+	goto st0;
+st11:
+	if ( ++p == pe )
+		goto _test_eof11;
+case 11:
+	if ( (*p) == 100 )
+		goto st12;
+	goto st0;
+st12:
+	if ( ++p == pe )
+		goto _test_eof12;
+case 12:
+	if ( (*p) == 32 )
+		goto st13;
+	goto st0;
+st13:
+	if ( ++p == pe )
+		goto _test_eof13;
+case 13:
+	if ( (*p) == 34 )
+		goto st14;
+	goto st0;
+st14:
+	if ( ++p == pe )
+		goto _test_eof14;
+case 14:
+	switch( (*p) ) {
+		case 34: goto st16;
+		case 45: goto st14;
+	}
+	if ( (*p) > 57 ) {
+		if ( 97 <= (*p) && (*p) <= 102 )
+			goto st14;
+	} else if ( (*p) >= 48 )
+		goto st14;
+	goto st0;
+	}
+	_test_eof2: cs = 2; goto _test_eof;
+	_test_eof15: cs = 15; goto _test_eof;
+	_test_eof16: cs = 16; goto _test_eof;
+	_test_eof17: cs = 17; goto _test_eof;
+	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof4: cs = 4; goto _test_eof;
+	_test_eof5: cs = 5; goto _test_eof;
+	_test_eof6: cs = 6; goto _test_eof;
+	_test_eof7: cs = 7; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof9: cs = 9; goto _test_eof;
+	_test_eof10: cs = 10; goto _test_eof;
+	_test_eof11: cs = 11; goto _test_eof;
+	_test_eof12: cs = 12; goto _test_eof;
+	_test_eof13: cs = 13; goto _test_eof;
+	_test_eof14: cs = 14; goto _test_eof;
+
+	_test_eof: {}
+	_out: {}
+	}
+
+#line 549 "edn_parser.rl"
+
+    if (cs >= EDN_dispatch_first_final) {
+
+        //is it a discard? if so, just drop the following token
+        if (*(p_save + 1) == '_')
+        {
+            discard = true;
+            return p + 1;
+        }
+
+        std::size_t len = p - p_save;
+        std::string buf;
+        buf.reserve(len);
+
+        if (len > 10)
+        {
+            // there's enough room to be #inst or #uuid, copy the
+            // string portion
+            if (std::strncmp(p_save + 1, "inst", 4) == 0) {
+                buf.append(p_save + 7, len - 8);
+            } else if (std::strncmp(p_save + 1, "uuid", 4) == 0) {
+                buf.append(p_save + 7, len - 8);
+            }
+
+            o = Rice::String(buf);
+            return p;
+        }
+
+        // tagged element
+        o = Rice::String(buf);
+        return p;
+    }
+    else if (cs == EDN_dispatch_error) {
+        error(*p);
+        return pe;
+    }
+    else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
+    return NULL;
+}
+
+
 // ============================================================
 // main parsing machine
 //
 
-#line 1868 "edn_parser.cc"
+#line 1796 "edn_parser.cc"
 static const int EDN_start = 1;
 static const int EDN_error = 0;
 
 static const int EDN_en_main = 1;
 
 
-#line 691 "edn_parser.rl"
+#line 619 "edn_parser.rl"
 
 
 //
@@ -1887,31 +1815,31 @@ Rice::Object edn::Parser::parse(const char* buf, std::size_t len)
     line_number = 1;
 
 
-#line 1891 "edn_parser.cc"
+#line 1819 "edn_parser.cc"
 	{
 	cs = EDN_start;
 	}
 
-#line 706 "edn_parser.rl"
+#line 634 "edn_parser.rl"
     p = &buf[0];
     pe = p + len;
     eof = pe; // eof defined in Parser class
 
-#line 1901 "edn_parser.cc"
+#line 1829 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
 	switch ( cs )
 	{
 tr2:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st1;
 st1:
 	if ( ++p == pe )
 		goto _test_eof1;
 case 1:
-#line 1915 "edn_parser.cc"
+#line 1843 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr2;
 		case 32: goto st1;
@@ -1928,27 +1856,27 @@ st0:
 cs = 0;
 	goto _out;
 tr8:
-#line 21 "edn_parser.rl"
+#line 22 "edn_parser.rl"
 	{ line_number++; }
 	goto st4;
 tr3:
-#line 681 "edn_parser.rl"
+#line 609 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_list(p, pe, result);
+        const char *np = parse_list(p, pe, result);
         if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
     }
 	goto st4;
 tr5:
-#line 671 "edn_parser.rl"
+#line 599 "edn_parser.rl"
 	{
-        const char* np = EDN_parse_vector(p, pe, result);
+        const char* np = parse_vector(p, pe, result);
         if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
     }
 	goto st4;
 tr6:
-#line 676 "edn_parser.rl"
+#line 604 "edn_parser.rl"
 	{
-        const char *np = EDN_parse_map(p, pe, result);
+        const char *np = parse_map(p, pe, result);
         if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {p = (( np))-1;}
     }
 	goto st4;
@@ -1956,7 +1884,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1960 "edn_parser.cc"
+#line 1888 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr8;
 		case 32: goto st4;
@@ -1990,7 +1918,7 @@ case 3:
 	_out: {}
 	}
 
-#line 710 "edn_parser.rl"
+#line 638 "edn_parser.rl"
 
     if (cs == EDN_error) {
         error(*p);