edn_turbo 0.2.0 → 0.2.1

data/ext/edn_turbo/edn_parser.cc

@@ -19,7 +19,7 @@
 //
 
 
-#line 66 "edn_parser.rl"
+#line 61 "edn_parser.rl"
 
 
 // ============================================================
@@ -29,19 +29,19 @@
 
 #line 31 "edn_parser.cc"
 static const int EDN_value_start = 1;
-static const int EDN_value_first_final = 3;
+static const int EDN_value_first_final = 2;
 static const int EDN_value_error = 0;
 
 static const int EDN_value_en_main = 1;
 
 
-#line 164 "edn_parser.rl"
+#line 160 "edn_parser.rl"
 
 
 
 const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object& o)
 {
-    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    //std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
     int cs;
 
 
@@ -50,7 +50,7 @@ const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object
 	cs = EDN_value_start;
 	}
 
-#line 173 "edn_parser.rl"
+#line 169 "edn_parser.rl"
 
 #line 56 "edn_parser.cc"
 	{
@@ -63,19 +63,20 @@ case 1:
 		case 34: goto tr2;
 		case 35: goto tr3;
 		case 40: goto tr4;
-		case 42: goto tr0;
-		case 45: goto tr5;
 		case 58: goto tr6;
-		case 91: goto tr7;
-		case 92: goto st2;
+		case 91: goto tr8;
+		case 92: goto tr9;
 		case 95: goto tr0;
-		case 123: goto tr9;
+		case 123: goto tr10;
 	}
 	if ( (*p) < 48 ) {
-		if ( (*p) > 38 ) {
-			if ( 46 <= (*p) && (*p) <= 47 )
+		if ( (*p) < 42 ) {
+			if ( 33 <= (*p) && (*p) <= 38 )
 				goto tr0;
-		} else if ( (*p) >= 33 )
+		} else if ( (*p) > 43 ) {
+			if ( 45 <= (*p) && (*p) <= 47 )
+				goto tr0;
+		} else
 			goto tr0;
 	} else if ( (*p) > 57 ) {
 		if ( (*p) < 65 ) {
@@ -83,9 +84,9 @@ case 1:
 				goto tr0;
 		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr0;
+				goto tr7;
 		} else
-			goto tr0;
+			goto tr7;
 	} else
 		goto tr5;
 	goto st0;
@@ -93,42 +94,33 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 78 "edn_parser.rl"
+#line 93 "edn_parser.rl"
 	{
-        std::string sym;
-        const char *np = parse_symbol(p, pe, sym);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {
-            if      (sym == "true")  { o = Qtrue; }
-            else if (sym == "false") { o = Qfalse; }
-            else if (sym == "nil")   { o = Qnil; }
-            else {
-                o = Parser::make_edn_symbol(sym);
-            }
-            {p = (( np))-1;}
-        }
+        const char *np = parse_operator(p, pe, o);
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr2:
-#line 107 "edn_parser.rl"
+#line 83 "edn_parser.rl"
 	{
         const char *np = parse_string(p, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr3:
-#line 146 "edn_parser.rl"
+#line 73 "edn_parser.rl"
 	{
         const char *np = parse_dispatch(p + 1, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr4:
 #line 136 "edn_parser.rl"
 	{
         const char *np = parse_list(p, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr5:
 #line 112 "edn_parser.rl"
 	{
@@ -142,71 +134,74 @@ tr5:
         if (np) {
             {p = (( np))-1;}
             p--;
-            {p++; cs = 3; goto _out;}
+            {p++; cs = 2; goto _out;}
         }
         else {
             error(__FUNCTION__, *p);
             {p = (( pe))-1;}
         }
     }
-	goto st3;
+	goto st2;
 tr6:
-#line 92 "edn_parser.rl"
+#line 88 "edn_parser.rl"
 	{
         const char *np = parse_keyword(p, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr7:
+#line 98 "edn_parser.rl"
+	{
+        std::string sym;
+        const char *np = parse_symbol(p, pe, sym);
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
+            if      (sym == "true")  { o = Qtrue; }
+            else if (sym == "false") { o = Qfalse; }
+            else if (sym == "nil")   { o = Qnil; }
+            else {
+                o = Parser::make_edn_symbol(sym);
+            }
+            {p = (( np))-1;}
+        }
+    }
+	goto st2;
+tr8:
 #line 131 "edn_parser.rl"
 	{
         const char *np = parse_vector(p, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr9:
-#line 141 "edn_parser.rl"
+#line 78 "edn_parser.rl"
 	{
-        const char *np = parse_map(p, pe, o);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
+        const char *np = parse_esc_char(p, pe, o);
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
+	goto st2;
 tr10:
-#line 97 "edn_parser.rl"
+#line 141 "edn_parser.rl"
 	{
-        Rice::String s;
-
-        if (!parse_escaped_char(*p, s)) {
-            p--; {p++; cs = 3; goto _out;}
-        } else {
-            o = s;
-        }
+        const char *np = parse_map(p, pe, o);
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-	goto st3;
-st3:
-	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
-#line 151 "edn_parser.rl"
-	{ p--; {p++; cs = 3; goto _out;} }
-#line 193 "edn_parser.cc"
-	goto st0;
+	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	if ( 33 <= (*p) && (*p) <= 126 )
-		goto tr10;
+#line 146 "edn_parser.rl"
+	{ p--; {p++; cs = 2; goto _out;} }
+#line 196 "edn_parser.cc"
 	goto st0;
 	}
-	_test_eof3: cs = 3; goto _test_eof;
 	_test_eof2: cs = 2; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 174 "edn_parser.rl"
+#line 170 "edn_parser.rl"
 
     if (cs >= EDN_value_first_final) {
         return p;
@@ -222,36 +217,37 @@ case 2:
 
 
 // ============================================================
-// symbol parsing
+// operator parsing
 //
 
-#line 229 "edn_parser.cc"
-static const int EDN_symbol_start = 1;
-static const int EDN_symbol_first_final = 3;
-static const int EDN_symbol_error = 0;
+#line 224 "edn_parser.cc"
+static const int EDN_operator_start = 1;
+static const int EDN_operator_first_final = 3;
+static const int EDN_operator_error = 0;
 
-static const int EDN_symbol_en_main = 1;
+static const int EDN_operator_en_main = 1;
 
 
-#line 202 "edn_parser.rl"
+#line 237 "edn_parser.rl"
 
 
 
-const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string& s)
+const char* edn::Parser::parse_operator(const char *p, const char *pe, Rice::Object& o)
 {
-    //std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
     int cs;
+    std::string op;
 
 
-#line 247 "edn_parser.cc"
+#line 243 "edn_parser.cc"
 	{
-	cs = EDN_symbol_start;
+	cs = EDN_operator_start;
 	}
 
-#line 211 "edn_parser.rl"
+#line 247 "edn_parser.rl"
     p_save = p;
 
-#line 255 "edn_parser.cc"
+#line 251 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -260,24 +256,17 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string
 case 1:
 	switch( (*p) ) {
 		case 33: goto st3;
+		case 42: goto st3;
+		case 43: goto st7;
+		case 45: goto st7;
+		case 46: goto st9;
+		case 47: goto st3;
 		case 95: goto st3;
 	}
-	if ( (*p) < 45 ) {
-		if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st3;
-		} else if ( (*p) >= 36 )
-			goto st3;
-	} else if ( (*p) > 47 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st3;
-		} else if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st3;
-		} else
+	if ( (*p) > 38 ) {
+		if ( 60 <= (*p) && (*p) <= 63 )
 			goto st3;
-	} else
+	} else if ( (*p) >= 36 )
 		goto st3;
 	goto st0;
 st0:
@@ -288,111 +277,745 @@ st3:
 		goto _test_eof3;
 case 3:
 	switch( (*p) ) {
-		case 10: goto tr6;
-		case 32: goto tr5;
-		case 33: goto st3;
-		case 44: goto tr5;
-		case 59: goto tr7;
-		case 95: goto st3;
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 44: goto tr7;
+		case 59: goto tr9;
+		case 95: goto st0;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 35 <= (*p) && (*p) <= 38 )
-				goto st3;
+			if ( 36 <= (*p) && (*p) <= 38 )
+				goto st0;
 		} else if ( (*p) >= 9 )
-			goto tr5;
-	} else if ( (*p) > 63 ) {
-		if ( (*p) > 90 ) {
+			goto tr7;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st3;
-		} else if ( (*p) >= 65 )
-			goto st3;
+				goto st0;
+		} else
+			goto st0;
 	} else
-		goto st3;
-	goto tr4;
-tr4:
-#line 197 "edn_parser.rl"
+		goto st0;
+	goto tr6;
+tr6:
+#line 223 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::OP '" << *(fpc-1) << "', pe: '" << *pe << "'" << std::endl;
+        std::string sym;
+        sym += *(p - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+#line 230 "edn_parser.rl"
+	{ p--; {p++; cs = 4; goto _out;} }
+	goto st4;
+tr10:
+#line 230 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 322 "edn_parser.cc"
+#line 325 "edn_parser.cc"
 	goto st0;
-tr3:
+tr5:
 #line 23 "edn_parser.rl"
 	{ line_number++; }
 	goto st5;
-tr5:
-#line 197 "edn_parser.rl"
+tr7:
+#line 223 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::OP '" << *(fpc-1) << "', pe: '" << *pe << "'" << std::endl;
+        std::string sym;
+        sym += *(p - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+#line 230 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
-tr6:
+tr8:
+#line 223 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::OP '" << *(fpc-1) << "', pe: '" << *pe << "'" << std::endl;
+        std::string sym;
+        sym += *(p - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+#line 23 "edn_parser.rl"
+	{ line_number++; }
+#line 230 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
+tr11:
+#line 230 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
+tr12:
 #line 23 "edn_parser.rl"
 	{ line_number++; }
-#line 197 "edn_parser.rl"
+#line 230 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 342 "edn_parser.cc"
+#line 369 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr6;
-		case 32: goto tr5;
+		case 10: goto tr12;
+		case 32: goto tr11;
 		case 33: goto st0;
-		case 44: goto tr5;
-		case 59: goto tr7;
+		case 44: goto tr11;
+		case 59: goto tr13;
 		case 95: goto st0;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 35 <= (*p) && (*p) <= 38 )
+			if ( 36 <= (*p) && (*p) <= 38 )
 				goto st0;
 		} else if ( (*p) >= 9 )
-			goto tr5;
-	} else if ( (*p) > 63 ) {
-		if ( (*p) > 90 ) {
+			goto tr11;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st0;
+		} else
+			goto st0;
+	} else
+		goto st0;
+	goto tr10;
+tr9:
+#line 223 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::OP '" << *(fpc-1) << "', pe: '" << *pe << "'" << std::endl;
+        std::string sym;
+        sym += *(p - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+#line 230 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+tr13:
+#line 230 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+#line 415 "edn_parser.cc"
+	if ( (*p) == 10 )
+		goto tr5;
+	goto st2;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	if ( (*p) == 10 )
+		goto tr5;
+	goto st2;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 44: goto tr7;
+		case 59: goto tr9;
+		case 95: goto st0;
+	}
+	if ( (*p) < 48 ) {
+		if ( (*p) < 36 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto tr7;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 47 )
+				goto st0;
+		} else
+			goto st0;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto tr15;
+		} else
+			goto tr15;
+	} else
+		goto tr14;
+	goto tr6;
+tr14:
+#line 203 "edn_parser.rl"
+	{
+        //std::cerr << "PARSE OP::NUM '" << (fpc - 1) << "'" << std::endl;
+        // try to parse a decimal first
+        const char *np = parse_decimal(p_save, pe, o);
+        if (np == NULL) {
+            // if we can't, try to parse it as an int
+            np = parse_integer(p_save, pe, o);
+        }
+
+        if (np) {
+            {p = (( np))-1;}
+            p--;
+            {p++; cs = 8; goto _out;}
+        }
+        else {
+            error(__FUNCTION__, *p);
+            {p = (( pe))-1;}
+        }
+    }
+	goto st8;
+tr15:
+#line 193 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::SYM '" << (fpc - 1) << "'" << std::endl;
+        std::string sym;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else {
+            o = Parser::make_edn_symbol(sym);
+            {p = (( np))-1;}
+        }
+    }
+	goto st8;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+#line 497 "edn_parser.cc"
+	switch( (*p) ) {
+		case 33: goto st0;
+		case 95: goto st0;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st0;
+		} else if ( (*p) >= 36 )
+			goto st0;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st0;
+		} else
+			goto st0;
+	} else
+		goto st0;
+	goto tr10;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 44: goto tr7;
+		case 59: goto tr9;
+		case 95: goto st0;
+	}
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 36 <= (*p) && (*p) <= 38 )
+				goto st0;
+		} else if ( (*p) >= 9 )
+			goto tr7;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto tr15;
+		} else
+			goto tr15;
+	} else
+		goto st0;
+	goto tr6;
+	}
+	_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_eof2: cs = 2; 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_eof: {}
+	if ( p == eof )
+	{
+	switch ( cs ) {
+	case 3:
+	case 7:
+	case 9:
+#line 223 "edn_parser.rl"
+	{
+        //        std::cerr << "PARSE OP::OP '" << *(fpc-1) << "', pe: '" << *pe << "'" << std::endl;
+        std::string sym;
+        sym += *(p - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+	break;
+#line 575 "edn_parser.cc"
+	}
+	}
+
+	_out: {}
+	}
+
+#line 249 "edn_parser.rl"
+
+    if (cs >= EDN_operator_first_final) {
+        return p;
+    }
+    else if (cs == EDN_operator_error) {
+        error(__FUNCTION__, *p);
+        return pe;
+    }
+    else if (cs == EDN_operator_en_main) {} // silence ragel warning
+    return NULL;
+}
+
+
+
+// ============================================================
+// escaped char parsing
+//
+
+#line 601 "edn_parser.cc"
+static const int EDN_escaped_char_start = 1;
+static const int EDN_escaped_char_first_final = 4;
+static const int EDN_escaped_char_error = 0;
+
+static const int EDN_escaped_char_en_main = 1;
+
+
+#line 279 "edn_parser.rl"
+
+
+
+const char* edn::Parser::parse_esc_char(const char *p, const char *pe, Rice::Object& o)
+{
+    //std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    int cs;
+
+
+#line 619 "edn_parser.cc"
+	{
+	cs = EDN_escaped_char_start;
+	}
+
+#line 288 "edn_parser.rl"
+    p_save = p;
+
+#line 627 "edn_parser.cc"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+case 1:
+	if ( (*p) == 92 )
+		goto st2;
+	goto st0;
+st0:
+cs = 0;
+	goto _out;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	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 10: goto tr7;
+		case 32: goto tr6;
+		case 44: goto tr6;
+		case 59: goto tr8;
+		case 92: goto st0;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr6;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st4;
+	} else
+		goto st4;
+	goto tr5;
+tr5:
+#line 274 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+#line 678 "edn_parser.cc"
+	goto st0;
+tr4:
+#line 23 "edn_parser.rl"
+	{ line_number++; }
+	goto st6;
+tr6:
+#line 274 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+tr7:
+#line 23 "edn_parser.rl"
+	{ line_number++; }
+#line 274 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+#line 698 "edn_parser.cc"
+	switch( (*p) ) {
+		case 10: goto tr7;
+		case 32: goto tr6;
+		case 44: goto tr6;
+		case 59: goto tr8;
+		case 92: goto st0;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr6;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st0;
+	} else
+		goto st0;
+	goto tr5;
+tr8:
+#line 274 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+#line 723 "edn_parser.cc"
+	if ( (*p) == 10 )
+		goto tr4;
+	goto st3;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) == 10 )
+		goto tr4;
+	goto st3;
+	}
+	_test_eof2: cs = 2; 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_eof3: cs = 3; goto _test_eof;
+
+	_test_eof: {}
+	_out: {}
+	}
+
+#line 290 "edn_parser.rl"
+
+    if (cs >= EDN_escaped_char_first_final) {
+        if (!Parser::parse_escaped_char(p_save + 1, p, o)) {
+            return pe;
+        }
+        return p;
+    }
+    else if (cs == EDN_escaped_char_error) {
+        error(__FUNCTION__, *p);
+        return pe;
+    }
+    else if (cs == EDN_escaped_char_en_main) {} // silence ragel warning
+    return NULL;
+}
+
+
+
+
+// ============================================================
+// symbol parsing
+//
+
+#line 769 "edn_parser.cc"
+static const int EDN_symbol_start = 1;
+static const int EDN_symbol_first_final = 4;
+static const int EDN_symbol_error = 0;
+
+static const int EDN_symbol_en_main = 1;
+
+
+#line 323 "edn_parser.rl"
+
+
+
+const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string& s)
+{
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    int cs;
+
+
+#line 787 "edn_parser.cc"
+	{
+	cs = EDN_symbol_start;
+	}
+
+#line 332 "edn_parser.rl"
+    p_save = p;
+
+#line 795 "edn_parser.cc"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+case 1:
+	switch( (*p) ) {
+		case 33: goto st4;
+		case 95: goto st4;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st4;
+		} else if ( (*p) >= 36 )
+			goto st4;
+	} else if ( (*p) > 47 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st4;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st8;
+		} else
+			goto st8;
+	} else
+		goto st4;
+	goto st0;
+st0:
+cs = 0;
+	goto _out;
+st4:
+	if ( ++p == pe )
+		goto _test_eof4;
+case 4:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 44: goto tr7;
+		case 59: goto tr9;
+		case 95: goto st0;
+	}
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 38 )
+				goto st0;
+		} else if ( (*p) >= 9 )
+			goto tr7;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st8;
+		} else if ( (*p) >= 65 )
+			goto st8;
+	} else
+		goto st0;
+	goto tr6;
+tr6:
+#line 317 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+#line 862 "edn_parser.cc"
+	goto st0;
+tr4:
+#line 23 "edn_parser.rl"
+	{ line_number++; }
+	goto st6;
+tr7:
+#line 317 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+tr8:
+#line 23 "edn_parser.rl"
+	{ line_number++; }
+#line 317 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+#line 882 "edn_parser.cc"
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 44: goto tr7;
+		case 59: goto tr9;
+		case 95: goto st0;
+	}
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 38 )
+				goto st0;
+		} else if ( (*p) >= 9 )
+			goto tr7;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st0;
+		} else if ( (*p) >= 65 )
+			goto st0;
+	} else
+		goto st0;
+	goto tr6;
+tr9:
+#line 317 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+#line 914 "edn_parser.cc"
+	if ( (*p) == 10 )
+		goto tr4;
+	goto st2;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	if ( (*p) == 10 )
+		goto tr4;
+	goto st2;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 35: goto st8;
+		case 44: goto tr7;
+		case 47: goto st3;
+		case 59: goto tr9;
+		case 95: goto st8;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) < 36 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto tr7;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st0;
+		} else
+			goto st0;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st8;
+		} else
+			goto st8;
+	} else
+		goto st8;
+	goto tr6;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st9;
+	} else if ( (*p) >= 65 )
+		goto st9;
+	goto st0;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st0;
+		case 35: goto st9;
+		case 44: goto tr7;
+		case 47: goto st0;
+		case 59: goto tr9;
+		case 95: goto st9;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) < 36 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto tr7;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st0;
+		} else
+			goto st0;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st0;
+		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st0;
-		} else if ( (*p) >= 65 )
-			goto st0;
+				goto st9;
+		} else
+			goto st9;
 	} else
-		goto st0;
-	goto tr4;
-tr7:
-#line 197 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
-st6:
-	if ( ++p == pe )
-		goto _test_eof6;
-case 6:
-#line 374 "edn_parser.cc"
-	if ( (*p) == 10 )
-		goto tr3;
-	goto st2;
-st2:
-	if ( ++p == pe )
-		goto _test_eof2;
-case 2:
-	if ( (*p) == 10 )
-		goto tr3;
-	goto st2;
+		goto st9;
+	goto tr6;
 	}
-	_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_eof2: cs = 2; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof9: cs = 9; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 213 "edn_parser.rl"
+#line 334 "edn_parser.rl"
 
     if (cs >= EDN_symbol_first_final) {
         uint32_t len = p - p_save;
@@ -417,7 +1040,7 @@ case 2:
 // keyword parsing
 //
 
-#line 421 "edn_parser.cc"
+#line 1044 "edn_parser.cc"
 static const int EDN_keyword_start = 1;
 static const int EDN_keyword_first_final = 3;
 static const int EDN_keyword_error = 0;
@@ -425,24 +1048,25 @@ static const int EDN_keyword_error = 0;
 static const int EDN_keyword_en_main = 1;
 
 
-#line 250 "edn_parser.rl"
+#line 371 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
 
 
-#line 438 "edn_parser.cc"
+#line 1062 "edn_parser.cc"
 	{
 	cs = EDN_keyword_start;
 	}
 
-#line 258 "edn_parser.rl"
+#line 380 "edn_parser.rl"
     p_save = p;
 
-#line 446 "edn_parser.cc"
+#line 1070 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -459,24 +1083,13 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	switch( (*p) ) {
-		case 33: goto st3;
-		case 95: goto st3;
-	}
-	if ( (*p) < 45 ) {
-		if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st3;
-		} else if ( (*p) >= 35 )
+	if ( (*p) == 35 )
+		goto st3;
+	if ( (*p) < 65 ) {
+		if ( 46 <= (*p) && (*p) <= 47 )
 			goto st3;
-	} else if ( (*p) > 47 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st3;
-		} else if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st3;
-		} else
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
 			goto st3;
 	} else
 		goto st3;
@@ -508,14 +1121,14 @@ case 3:
 		goto st3;
 	goto tr3;
 tr3:
-#line 247 "edn_parser.rl"
+#line 368 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 519 "edn_parser.cc"
+#line 1132 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -526,7 +1139,7 @@ case 4:
 	_out: {}
 	}
 
-#line 260 "edn_parser.rl"
+#line 382 "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
@@ -549,7 +1162,7 @@ case 4:
 // string parsing
 //
 
-#line 553 "edn_parser.cc"
+#line 1166 "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;
@@ -557,7 +1170,7 @@ static const int EDN_string_error = 0;
 static const int EDN_string_en_main = 1;
 
 
-#line 305 "edn_parser.rl"
+#line 426 "edn_parser.rl"
 
 
 
@@ -570,15 +1183,15 @@ const char* edn::Parser::parse_string(const char *p, const char *pe, Rice::Objec
 
     Rice::String s;
 
-#line 574 "edn_parser.cc"
+#line 1187 "edn_parser.cc"
 	{
 	cs = EDN_string_start;
 	}
 
-#line 317 "edn_parser.rl"
+#line 438 "edn_parser.rl"
     p_save = p;
 
-#line 582 "edn_parser.cc"
+#line 1195 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -589,15 +1202,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 601 "edn_parser.cc"
+#line 1214 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -613,23 +1226,23 @@ case 2:
 		goto tr2;
 	goto st2;
 tr3:
-#line 287 "edn_parser.rl"
+#line 409 "edn_parser.rl"
 	{
-        if (!parse_byte_stream(p_save + 1, p, s)) {
+        if (!Parser::parse_byte_stream(p_save + 1, p, s)) {
             p--;
             {p++; cs = 8; goto _out;}
         } else {
             {p = (( p + 1))-1;}
         }
     }
-#line 296 "edn_parser.rl"
+#line 418 "edn_parser.rl"
 	{ p--; {p++; cs = 8; goto _out;} }
 	goto st8;
 st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 633 "edn_parser.cc"
+#line 1246 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -706,22 +1319,22 @@ case 7:
 	{
 	switch ( cs ) {
 	case 2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 718 "edn_parser.cc"
+#line 1331 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 319 "edn_parser.rl"
+#line 440 "edn_parser.rl"
 
     if (cs >= EDN_string_first_final) {
         o = s;
@@ -738,14 +1351,14 @@ case 7:
 // decimal parsing grammar
 //
 
-#line 742 "edn_parser.cc"
+#line 1355 "edn_parser.cc"
 static const int EDN_decimal_start = 1;
 static const int EDN_decimal_first_final = 9;
 
 static const int EDN_decimal_en_main = 1;
 
 
-#line 347 "edn_parser.rl"
+#line 467 "edn_parser.rl"
 
 
 
@@ -754,15 +1367,15 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Obje
     int cs;
 
 
-#line 758 "edn_parser.cc"
+#line 1371 "edn_parser.cc"
 	{
 	cs = EDN_decimal_start;
 	}
 
-#line 355 "edn_parser.rl"
+#line 475 "edn_parser.rl"
     p_save = p;
 
-#line 766 "edn_parser.cc"
+#line 1379 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -770,6 +1383,7 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Obje
 	{
 case 1:
 	switch( (*p) ) {
+		case 43: goto st2;
 		case 45: goto st2;
 		case 48: goto st3;
 	}
@@ -815,14 +1429,14 @@ case 9:
 		goto st0;
 	goto tr10;
 tr10:
-#line 340 "edn_parser.rl"
+#line 461 "edn_parser.rl"
 	{ p--; {p++; cs = 10; goto _out;} }
 	goto st10;
 st10:
 	if ( ++p == pe )
 		goto _test_eof10;
 case 10:
-#line 826 "edn_parser.cc"
+#line 1440 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -938,11 +1552,10 @@ case 8:
 	_out: {}
 	}
 
-#line 357 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 
     if (cs >= EDN_decimal_first_final) {
-        double value;
-        o = Parser::buftotype<double>(p_save, p - p_save, value);
+        o = Parser::float_to_ruby(p_save, p - p_save);
         return p + 1;
     }
     else if (cs == EDN_decimal_en_main) {} // silence ragel warning
@@ -954,14 +1567,14 @@ case 8:
 // integer parsing grammar
 //
 
-#line 958 "edn_parser.cc"
+#line 1571 "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 380 "edn_parser.rl"
+#line 501 "edn_parser.rl"
 
 
 const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Object& o)
@@ -969,15 +1582,15 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Obje
     int cs;
 
 
-#line 973 "edn_parser.cc"
+#line 1586 "edn_parser.cc"
 	{
 	cs = EDN_integer_start;
 	}
 
-#line 387 "edn_parser.rl"
+#line 508 "edn_parser.rl"
     p_save = p;
 
-#line 981 "edn_parser.cc"
+#line 1594 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -985,6 +1598,7 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Obje
 	{
 case 1:
 	switch( (*p) ) {
+		case 43: goto st2;
 		case 45: goto st2;
 		case 48: goto st3;
 	}
@@ -1007,8 +1621,10 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-	if ( (*p) == 124 )
-		goto tr6;
+	switch( (*p) ) {
+		case 43: goto st0;
+		case 45: goto st0;
+	}
 	if ( (*p) > 57 ) {
 		if ( 77 <= (*p) && (*p) <= 78 )
 			goto st5;
@@ -1016,24 +1632,23 @@ case 3:
 		goto st0;
 	goto tr4;
 tr4:
-#line 377 "edn_parser.rl"
+#line 496 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1027 "edn_parser.cc"
+#line 1643 "edn_parser.cc"
 	goto st0;
-tr6:
-#line 377 "edn_parser.rl"
-	{ p--; {p++; cs = 5; goto _out;} }
-	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1037 "edn_parser.cc"
+	switch( (*p) ) {
+		case 43: goto st0;
+		case 45: goto st0;
+	}
 	if ( (*p) > 57 ) {
 		if ( 77 <= (*p) && (*p) <= 78 )
 			goto st0;
@@ -1044,8 +1659,10 @@ st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-	if ( (*p) == 124 )
-		goto tr6;
+	switch( (*p) ) {
+		case 43: goto st0;
+		case 45: goto st0;
+	}
 	if ( (*p) > 57 ) {
 		if ( 77 <= (*p) && (*p) <= 78 )
 			goto st5;
@@ -1063,11 +1680,10 @@ case 6:
 	_out: {}
 	}
 
-#line 389 "edn_parser.rl"
+#line 510 "edn_parser.rl"
 
     if (cs >= EDN_integer_first_final) {
-        int value;
-        o = Parser::buftotype<int>(p_save, p - p_save, value);
+        o = Parser::integer_to_ruby(p_save, p - p_save);
         return p + 1;
     }
     else if (cs == EDN_integer_en_main) {} // silence ragel warning
@@ -1082,13 +1698,13 @@ case 6:
 // sets the same array is used)
 //
 
-#line 434 "edn_parser.rl"
+#line 554 "edn_parser.rl"
 
 
 //
 // vector-specific machine
 
-#line 1092 "edn_parser.cc"
+#line 1708 "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;
@@ -1096,7 +1712,7 @@ static const int EDN_vector_error = 0;
 static const int EDN_vector_en_main = 1;
 
 
-#line 446 "edn_parser.rl"
+#line 570 "edn_parser.rl"
 
 
 
@@ -1112,14 +1728,14 @@ const char* edn::Parser::parse_vector(const char *p, const char *pe, Rice::Objec
     Rice::Array arr;
 
 
-#line 1116 "edn_parser.cc"
+#line 1732 "edn_parser.cc"
 	{
 	cs = EDN_vector_start;
 	}
 
-#line 461 "edn_parser.rl"
+#line 585 "edn_parser.rl"
 
-#line 1123 "edn_parser.cc"
+#line 1739 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1130,15 +1746,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1142 "edn_parser.cc"
+#line 1758 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -1147,7 +1763,7 @@ tr3:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 410 "edn_parser.rl"
+#line 530 "edn_parser.rl"
 	{
         Rice::Object v;
         const char *np = parse_value(p, pe, v);
@@ -1171,7 +1787,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1175 "edn_parser.cc"
+#line 1791 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1204,14 +1820,14 @@ case 3:
 		goto tr3;
 	goto st3;
 tr6:
-#line 433 "edn_parser.rl"
+#line 553 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1215 "edn_parser.cc"
+#line 1831 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1223,22 +1839,23 @@ case 4:
 	{
 	switch ( cs ) {
 	case 2:
-#line 60 "edn_parser.rl"
+	case 3:
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 1235 "edn_parser.cc"
+#line 1852 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 462 "edn_parser.rl"
+#line 586 "edn_parser.rl"
 
     if (cs >= EDN_vector_first_final) {
         o = arr;
@@ -1258,7 +1875,7 @@ case 4:
 // list parsing machine
 //
 
-#line 1262 "edn_parser.cc"
+#line 1879 "edn_parser.cc"
 static const int EDN_list_start = 1;
 static const int EDN_list_first_final = 4;
 static const int EDN_list_error = 0;
@@ -1266,7 +1883,7 @@ static const int EDN_list_error = 0;
 static const int EDN_list_en_main = 1;
 
 
-#line 488 "edn_parser.rl"
+#line 615 "edn_parser.rl"
 
 
 //
@@ -1280,14 +1897,14 @@ const char* edn::Parser::parse_list(const char *p, const char *pe, Rice::Object&
     Rice::Array arr;
 
 
-#line 1284 "edn_parser.cc"
+#line 1901 "edn_parser.cc"
 	{
 	cs = EDN_list_start;
 	}
 
-#line 501 "edn_parser.rl"
+#line 628 "edn_parser.rl"
 
-#line 1291 "edn_parser.cc"
+#line 1908 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1298,15 +1915,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1310 "edn_parser.cc"
+#line 1927 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -1315,7 +1932,7 @@ tr3:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 410 "edn_parser.rl"
+#line 530 "edn_parser.rl"
 	{
         Rice::Object v;
         const char *np = parse_value(p, pe, v);
@@ -1339,7 +1956,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1343 "edn_parser.cc"
+#line 1960 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1364,14 +1981,14 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr5:
-#line 433 "edn_parser.rl"
+#line 553 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1375 "edn_parser.cc"
+#line 1992 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -1390,22 +2007,23 @@ case 3:
 	{
 	switch ( cs ) {
 	case 2:
-#line 60 "edn_parser.rl"
+	case 3:
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 1402 "edn_parser.cc"
+#line 2020 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 502 "edn_parser.rl"
+#line 629 "edn_parser.rl"
 
     if (cs >= EDN_list_first_final) {
         o = arr;
@@ -1425,7 +2043,7 @@ case 3:
 // set parsing machine
 //
 
-#line 1429 "edn_parser.cc"
+#line 2047 "edn_parser.cc"
 static const int EDN_set_start = 1;
 static const int EDN_set_first_final = 4;
 static const int EDN_set_error = 0;
@@ -1433,7 +2051,7 @@ static const int EDN_set_error = 0;
 static const int EDN_set_en_main = 1;
 
 
-#line 530 "edn_parser.rl"
+#line 659 "edn_parser.rl"
 
 
 //
@@ -1448,14 +2066,14 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, Rice::Object&
     Rice::Array arr; // store as a vector; then convert to a set once done
 
 
-#line 1452 "edn_parser.cc"
+#line 2070 "edn_parser.cc"
 	{
 	cs = EDN_set_start;
 	}
 
-#line 544 "edn_parser.rl"
+#line 673 "edn_parser.rl"
 
-#line 1459 "edn_parser.cc"
+#line 2077 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1466,15 +2084,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1478 "edn_parser.cc"
+#line 2096 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -1483,7 +2101,7 @@ tr3:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 410 "edn_parser.rl"
+#line 530 "edn_parser.rl"
 	{
         Rice::Object v;
         const char *np = parse_value(p, pe, v);
@@ -1507,7 +2125,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1511 "edn_parser.cc"
+#line 2129 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1540,14 +2158,14 @@ case 3:
 		goto tr3;
 	goto st3;
 tr6:
-#line 433 "edn_parser.rl"
+#line 553 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1551 "edn_parser.cc"
+#line 2169 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1559,25 +2177,26 @@ case 4:
 	{
 	switch ( cs ) {
 	case 2:
-#line 60 "edn_parser.rl"
+	case 3:
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 1571 "edn_parser.cc"
+#line 2190 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 545 "edn_parser.rl"
+#line 674 "edn_parser.rl"
 
     if (cs >= EDN_set_first_final) {
-        o = make_ruby_set(arr);
+        o = Parser::make_ruby_set(arr);
         return p + 1;
     }
     else if (cs == EDN_set_error) {
@@ -1594,7 +2213,7 @@ case 4:
 // hash parsing
 //
 
-#line 1598 "edn_parser.cc"
+#line 2217 "edn_parser.cc"
 static const int EDN_map_start = 1;
 static const int EDN_map_first_final = 4;
 static const int EDN_map_error = 0;
@@ -1602,7 +2221,7 @@ static const int EDN_map_error = 0;
 static const int EDN_map_en_main = 1;
 
 
-#line 578 "edn_parser.rl"
+#line 709 "edn_parser.rl"
 
 
 
@@ -1614,14 +2233,14 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object&
     int cs;
 
 
-#line 1618 "edn_parser.cc"
+#line 2237 "edn_parser.cc"
 	{
 	cs = EDN_map_start;
 	}
 
-#line 589 "edn_parser.rl"
+#line 720 "edn_parser.rl"
 
-#line 1625 "edn_parser.cc"
+#line 2244 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1632,15 +2251,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 60 "edn_parser.rl"
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1644 "edn_parser.cc"
+#line 2263 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -1649,7 +2268,7 @@ tr3:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 410 "edn_parser.rl"
+#line 530 "edn_parser.rl"
 	{
         Rice::Object v;
         const char *np = parse_value(p, pe, v);
@@ -1673,7 +2292,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1677 "edn_parser.cc"
+#line 2296 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -1706,14 +2325,14 @@ case 3:
 		goto tr3;
 	goto st3;
 tr6:
-#line 433 "edn_parser.rl"
+#line 553 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1717 "edn_parser.cc"
+#line 2336 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1725,22 +2344,23 @@ case 4:
 	{
 	switch ( cs ) {
 	case 2:
-#line 60 "edn_parser.rl"
+	case 3:
+#line 55 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 1737 "edn_parser.cc"
+#line 2357 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 590 "edn_parser.rl"
+#line 721 "edn_parser.rl"
 
     if (cs >= EDN_map_first_final) {
 
@@ -1771,68 +2391,52 @@ case 4:
 // tagged element parsing - #uuid, #inst, #{, #_
 //
 
-#line 1775 "edn_parser.cc"
+#line 2395 "edn_parser.cc"
 static const int EDN_tagged_start = 1;
-static const int EDN_tagged_first_final = 5;
+static const int EDN_tagged_first_final = 6;
 static const int EDN_tagged_error = 0;
 
 static const int EDN_tagged_en_main = 1;
 
 
-#line 645 "edn_parser.rl"
+#line 771 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Object& o)
 {
-    //    std::cerr << __FUNCTION__ << " p '" << p << "'" << std::endl;
+    //        std::cerr << __FUNCTION__ << " p '" << p << "'" << std::endl;
     std::string sym_name;
     Rice::Object object;
 
     int cs;
 
 
-#line 1796 "edn_parser.cc"
+#line 2416 "edn_parser.cc"
 	{
 	cs = EDN_tagged_start;
 	}
 
-#line 657 "edn_parser.rl"
+#line 783 "edn_parser.rl"
 
-#line 1803 "edn_parser.cc"
+#line 2423 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
 	switch ( cs )
 	{
 case 1:
-	switch( (*p) ) {
-		case 33: goto tr0;
-		case 95: goto tr0;
-	}
-	if ( (*p) < 45 ) {
-		if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr0;
-		} else if ( (*p) >= 36 )
-			goto tr0;
-	} else if ( (*p) > 47 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto tr0;
-		} else if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr0;
-		} else
+	if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
 			goto tr0;
-	} else
+	} else if ( (*p) >= 65 )
 		goto tr0;
 	goto st0;
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 633 "edn_parser.rl"
+#line 759 "edn_parser.rl"
 	{
         const char *np = parse_symbol(p, pe, sym_name);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else { {p = (( np))-1;} }
@@ -1842,34 +2446,41 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1846 "edn_parser.cc"
+#line 2450 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 34: goto tr5;
-		case 40: goto tr5;
+		case 35: goto tr5;
+		case 40: goto tr4;
 		case 44: goto st3;
+		case 47: goto tr6;
 		case 59: goto st4;
-		case 95: goto tr4;
-		case 123: goto tr5;
+		case 95: goto tr5;
+		case 123: goto tr4;
 	}
-	if ( (*p) < 42 ) {
-		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+	if ( (*p) < 45 ) {
+		if ( (*p) < 33 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto st3;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
 				goto tr4;
-		} else if ( (*p) >= 9 )
-			goto st3;
-	} else if ( (*p) > 63 ) {
-		if ( (*p) < 91 ) {
-			if ( 65 <= (*p) && (*p) <= 90 )
+		} else
+			goto tr4;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
 				goto tr4;
-		} else if ( (*p) > 92 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
+		} else if ( (*p) > 90 ) {
+			if ( (*p) > 92 ) {
+				if ( 97 <= (*p) && (*p) <= 122 )
+					goto tr5;
+			} else if ( (*p) >= 91 )
 				goto tr4;
 		} else
 			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
 	goto st0;
 tr3:
 #line 23 "edn_parser.rl"
@@ -1879,44 +2490,44 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 1883 "edn_parser.cc"
+#line 2494 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 40: goto tr5;
+		case 40: goto tr4;
 		case 44: goto st3;
 		case 59: goto st4;
-		case 95: goto tr5;
+		case 95: goto tr4;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
 			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr5;
+				goto tr4;
 		} else if ( (*p) >= 9 )
 			goto st3;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) > 92 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr5;
+				goto tr4;
 		} else if ( (*p) >= 65 )
-			goto tr5;
+			goto tr4;
 	} else
-		goto tr5;
+		goto tr4;
 	goto st0;
-tr5:
-#line 637 "edn_parser.rl"
+tr4:
+#line 763 "edn_parser.rl"
 	{
         const char *np = parse_value(p, pe, object);
-        if (np == NULL) { p--; {p++; cs = 5; goto _out;} } else { {p = (( np))-1;} }
+        if (np == NULL) { p--; {p++; cs = 6; goto _out;} } else { {p = (( np))-1;} }
     }
-#line 642 "edn_parser.rl"
-	{ p--; {p++; cs = 5; goto _out;} }
-	goto st5;
-st5:
+#line 768 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+st6:
 	if ( ++p == pe )
-		goto _test_eof5;
-case 5:
-#line 1920 "edn_parser.cc"
+		goto _test_eof6;
+case 6:
+#line 2531 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -1925,63 +2536,181 @@ case 4:
 	if ( (*p) == 10 )
 		goto tr3;
 	goto st4;
-tr4:
-#line 637 "edn_parser.rl"
+tr5:
+#line 763 "edn_parser.rl"
 	{
         const char *np = parse_value(p, pe, object);
-        if (np == NULL) { p--; {p++; cs = 6; goto _out;} } else { {p = (( np))-1;} }
+        if (np == NULL) { p--; {p++; cs = 7; goto _out;} } else { {p = (( np))-1;} }
     }
-#line 642 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
-st6:
+#line 768 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
 	if ( ++p == pe )
-		goto _test_eof6;
-case 6:
-#line 1942 "edn_parser.cc"
+		goto _test_eof7;
+case 7:
+#line 2553 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 34: goto tr5;
-		case 40: goto tr5;
+		case 35: goto tr5;
+		case 40: goto tr4;
 		case 44: goto st3;
+		case 47: goto tr6;
 		case 59: goto st4;
-		case 95: goto tr4;
-		case 123: goto tr5;
+		case 95: goto tr5;
+		case 123: goto tr4;
 	}
-	if ( (*p) < 42 ) {
-		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+	if ( (*p) < 45 ) {
+		if ( (*p) < 33 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto st3;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
 				goto tr4;
-		} else if ( (*p) >= 9 )
-			goto st3;
-	} else if ( (*p) > 63 ) {
-		if ( (*p) < 91 ) {
-			if ( 65 <= (*p) && (*p) <= 90 )
+		} else
+			goto tr4;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
 				goto tr4;
-		} else if ( (*p) > 92 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
+		} else if ( (*p) > 90 ) {
+			if ( (*p) > 92 ) {
+				if ( 97 <= (*p) && (*p) <= 122 )
+					goto tr5;
+			} else if ( (*p) >= 91 )
 				goto tr4;
 		} else
 			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
+	goto st0;
+tr6:
+#line 763 "edn_parser.rl"
+	{
+        const char *np = parse_value(p, pe, object);
+        if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else { {p = (( np))-1;} }
+    }
+#line 768 "edn_parser.rl"
+	{ p--; {p++; cs = 8; goto _out;} }
+	goto st8;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+#line 2602 "edn_parser.cc"
+	if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto st5;
+	} else if ( (*p) >= 65 )
+		goto st5;
+	goto st0;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+	switch( (*p) ) {
+		case 10: goto tr3;
+		case 32: goto st3;
+		case 35: goto tr8;
+		case 40: goto tr4;
+		case 44: goto st3;
+		case 47: goto tr4;
+		case 59: goto st4;
+		case 95: goto tr8;
+		case 123: goto tr4;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) < 33 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto st3;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto tr4;
+		} else
+			goto tr4;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto tr4;
+		} else if ( (*p) > 90 ) {
+			if ( (*p) > 92 ) {
+				if ( 97 <= (*p) && (*p) <= 122 )
+					goto tr8;
+			} else if ( (*p) >= 91 )
+				goto tr4;
+		} else
+			goto tr8;
+	} else
+		goto tr8;
+	goto st0;
+tr8:
+#line 763 "edn_parser.rl"
+	{
+        const char *np = parse_value(p, pe, object);
+        if (np == NULL) { p--; {p++; cs = 9; goto _out;} } else { {p = (( np))-1;} }
+    }
+#line 768 "edn_parser.rl"
+	{ p--; {p++; cs = 9; goto _out;} }
+	goto st9;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+#line 2661 "edn_parser.cc"
+	switch( (*p) ) {
+		case 10: goto tr3;
+		case 32: goto st3;
+		case 35: goto tr8;
+		case 40: goto tr4;
+		case 44: goto st3;
+		case 47: goto tr4;
+		case 59: goto st4;
+		case 95: goto tr8;
+		case 123: goto tr4;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) < 33 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto st3;
+		} else if ( (*p) > 38 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto tr4;
+		} else
+			goto tr4;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto tr4;
+		} else if ( (*p) > 90 ) {
+			if ( (*p) > 92 ) {
+				if ( 97 <= (*p) && (*p) <= 122 )
+					goto tr8;
+			} else if ( (*p) >= 91 )
+				goto tr4;
+		} else
+			goto tr8;
+	} else
+		goto tr8;
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
 	_test_eof3: cs = 3; goto _test_eof;
-	_test_eof5: cs = 5; goto _test_eof;
-	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof6: cs = 6; goto _test_eof;
+	_test_eof4: cs = 4; goto _test_eof;
+	_test_eof7: cs = 7; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof5: cs = 5; goto _test_eof;
+	_test_eof9: cs = 9; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 658 "edn_parser.rl"
+#line 784 "edn_parser.rl"
 
     if (cs >= EDN_tagged_first_final) {
-        //        std::cerr << __FUNCTION__ << " parse symbol name as '" << sym_name << "', value is: " << object << std::endl;
+        //std::cerr << __FUNCTION__ << " parse symbol name as '" << sym_name << "', value is: " << object << std::endl;
         o = Parser::tagged_element(sym_name, object);
         return p + 1;
     }
@@ -1997,7 +2726,7 @@ case 6:
 // discard
 //
 
-#line 2001 "edn_parser.cc"
+#line 2730 "edn_parser.cc"
 static const int EDN_discard_start = 1;
 static const int EDN_discard_first_final = 4;
 static const int EDN_discard_error = 0;
@@ -2005,7 +2734,7 @@ static const int EDN_discard_error = 0;
 static const int EDN_discard_en_main = 1;
 
 
-#line 695 "edn_parser.rl"
+#line 821 "edn_parser.rl"
 
 
 
@@ -2016,14 +2745,14 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     Rice::Object o;
 
 
-#line 2020 "edn_parser.cc"
+#line 2749 "edn_parser.cc"
 	{
 	cs = EDN_discard_start;
 	}
 
-#line 705 "edn_parser.rl"
+#line 831 "edn_parser.rl"
 
-#line 2027 "edn_parser.cc"
+#line 2756 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2044,7 +2773,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2048 "edn_parser.cc"
+#line 2777 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr2;
 		case 32: goto st2;
@@ -2069,12 +2798,12 @@ case 2:
 		goto tr3;
 	goto st0;
 tr3:
-#line 683 "edn_parser.rl"
+#line 809 "edn_parser.rl"
 	{
         const char *np = parse_value(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else { discard.push(o); {p = (( np))-1;} }
     }
-#line 688 "edn_parser.rl"
+#line 814 "edn_parser.rl"
 	{
         p--; {p++; cs = 4; goto _out;}
     }
@@ -2083,7 +2812,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2087 "edn_parser.cc"
+#line 2816 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -2101,7 +2830,7 @@ case 3:
 	_out: {}
 	}
 
-#line 706 "edn_parser.rl"
+#line 832 "edn_parser.rl"
 
     if (cs >= EDN_discard_first_final) {
         return p + 1;
@@ -2121,7 +2850,7 @@ case 3:
 // dispatch
 //
 
-#line 2125 "edn_parser.cc"
+#line 2854 "edn_parser.cc"
 static const int EDN_dispatch_start = 1;
 static const int EDN_dispatch_first_final = 2;
 static const int EDN_dispatch_error = 0;
@@ -2129,7 +2858,7 @@ static const int EDN_dispatch_error = 0;
 static const int EDN_dispatch_en_main = 1;
 
 
-#line 755 "edn_parser.rl"
+#line 878 "edn_parser.rl"
 
 
 
@@ -2139,14 +2868,14 @@ const char* edn::Parser::parse_dispatch(const char *p, const char *pe, Rice::Obj
     int cs;
 
 
-#line 2143 "edn_parser.cc"
+#line 2872 "edn_parser.cc"
 	{
 	cs = EDN_dispatch_start;
 	}
 
-#line 764 "edn_parser.rl"
+#line 887 "edn_parser.rl"
 
-#line 2150 "edn_parser.cc"
+#line 2879 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2167,40 +2896,37 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 742 "edn_parser.rl"
+#line 866 "edn_parser.rl"
 	{
-        //        std::cerr << "--- DISPATCH TAGGED: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_tagged(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 748 "edn_parser.rl"
+#line 871 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr2:
-#line 730 "edn_parser.rl"
+#line 856 "edn_parser.rl"
 	{
-        //        std::cerr << "--- DISPATCH DISCARD: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_discard(p, pe);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 748 "edn_parser.rl"
+#line 871 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr3:
-#line 736 "edn_parser.rl"
+#line 861 "edn_parser.rl"
 	{
-        //        std::cerr << "--- DISPATCH SET: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_set(p, pe, o);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 748 "edn_parser.rl"
+#line 871 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2204 "edn_parser.cc"
+#line 2930 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2209,7 +2935,7 @@ case 2:
 	_out: {}
 	}
 
-#line 765 "edn_parser.rl"
+#line 888 "edn_parser.rl"
 
     if (cs >= EDN_dispatch_first_final) {
         return p + 1;
@@ -2227,14 +2953,14 @@ case 2:
 // main parsing machine
 //
 
-#line 2231 "edn_parser.cc"
+#line 2957 "edn_parser.cc"
 static const int EDN_start = 2;
 static const int EDN_error = 0;
 
 static const int EDN_en_main = 2;
 
 
-#line 798 "edn_parser.rl"
+#line 921 "edn_parser.rl"
 
 
 //
@@ -2254,17 +2980,17 @@ Rice::Object edn::Parser::parse(const char* buf, std::size_t len)
         discard.pop();
 
 
-#line 2258 "edn_parser.cc"
+#line 2984 "edn_parser.cc"
 	{
 	cs = EDN_start;
 	}
 
-#line 817 "edn_parser.rl"
+#line 940 "edn_parser.rl"
     p = &buf[0];
     pe = p + len;
     eof = pe; // eof defined in Parser class
 
-#line 2268 "edn_parser.cc"
+#line 2994 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2275,7 +3001,7 @@ tr1:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 787 "edn_parser.rl"
+#line 910 "edn_parser.rl"
 	{
         const char* np = parse_value(p, pe, result);
         if (np == NULL) { {p = (( pe))-1;} {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
@@ -2285,7 +3011,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2289 "edn_parser.cc"
+#line 3015 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr1;
 		case 32: goto st2;
@@ -2327,7 +3053,7 @@ case 1:
 	_out: {}
 	}
 
-#line 821 "edn_parser.rl"
+#line 944 "edn_parser.rl"
 
     if (cs == EDN_error) {
         error(__FUNCTION__, *p);