edn_turbo 0.2.0 → 0.2.1

data/ext/edn_turbo/edn_parser.h

@@ -20,6 +20,8 @@ namespace edn
     extern VALUE EDNT_MAKE_EDN_SYMBOL;
     extern VALUE EDNT_MAKE_SET_METHOD;
     extern VALUE EDNT_TAGGED_ELEM;
+    extern VALUE EDNT_STR_INT_TO_BIGNUM;
+    extern VALUE EDNT_STR_DBL_TO_BIGNUM;
 
     //
     // C-extension EDN Parser class representation
@@ -34,24 +36,25 @@ namespace edn
 
         Rice::Object parse(const char* s, std::size_t len);
 
-        const char* parse_decimal(const char *p, const char *pe, Rice::Object& o);
-        const char* parse_integer(const char *p, const char *pe, Rice::Object& o);
-        const char* parse_symbol (const char *p, const char *pe, std::string& s);
-        const char* parse_keyword(const char *p, const char *pe, Rice::Object& o);
-        const char* parse_string (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_value  (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_vector (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_map    (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_list   (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_set    (const char *p, const char *pe, Rice::Object& o);
-        const char* parse_tagged (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_value   (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_operator(const char *p, const char *pe, Rice::Object& o);
+        const char* parse_esc_char(const char *p, const char *pe, Rice::Object& o);
+        const char* parse_symbol  (const char *p, const char *pe, std::string& s);
+        const char* parse_keyword (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_string  (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_decimal (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_integer (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_vector  (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_list    (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_set     (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_map     (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_tagged  (const char *p, const char *pe, Rice::Object& o);
+        const char* parse_discard (const char *p, const char *pe);
         const char* parse_dispatch(const char *p, const char *pe, Rice::Object& o);
 
-        const char* parse_discard(const char *p, const char *pe);
-
-        static bool parse_byte_stream(const char *p, const char *pe, Rice::String& s);
-        static bool parse_escaped_char(char c, Rice::String& s);
-        static bool unicode_to_utf8(const char *s, std::size_t len, std::string& rslt);
+        static bool parse_byte_stream (const char *p, const char *pe, Rice::String& s);
+        static bool parse_escaped_char(const char *p, const char *pe, Rice::Object& s);
+        static bool unicode_to_utf8   (const char *s, std::size_t len, std::string& rslt);
 
         static Rice::Object make_edn_symbol(const std::string& name);
         static Rice::Object make_ruby_set(const Rice::Array& elems);
@@ -64,13 +67,17 @@ namespace edn
         // utility method to convert a primitive in string form to a
         // ruby type
         template <class T>
-        static Rice::Object buftotype(const char* p, long len, T& val) {
+        static Rice::Object buftotype(const char* p, std::size_t len) {
+            T val;
             std::string buf;
             buf.append(p, len);
             std::istringstream(buf) >> val;
             return to_ruby<T>(val);
         }
 
+        static Rice::Object integer_to_ruby(const char* str, std::size_t len);
+        static Rice::Object float_to_ruby(const char* str, std::size_t len);
+
     public:
         Parser() : line_number(1), p_save(NULL), eof(NULL) { }
 

data/ext/edn_turbo/edn_parser.rl

@@ -26,34 +26,26 @@
         comment        = ';' cr_neg* counter;
         ignore         = ws | comment;
 
-        operators      = [/\.\*!_\?$%&<>\=\-\+];
-        symbol_chars   = [a-zA-Z0-9\#:] | operators;
+        operators      = [/\.\*!_\?$%&<>\=+\-];
+        symbol_start   = alpha;
+        symbol_chars   = symbol_start | digit | [\#:_\-\.];
 
-        symbol_first_c = symbol_chars - [0-9\#\:]; # non-numeric, no '#' or ':'
-
-        k_nil          = 'nil';
-        k_true         = 'true';
-        k_false        = 'false';
         begin_dispatch = '#';
         begin_keyword  = ':';
         begin_char     = '\\';
         begin_value    = alnum | [:\"\{\[\(\\\#] | operators;
-# TODO: support - and + symbols. Currently conflicting with numeric values
-        begin_symbol   = symbol_first_c - ('-'|'+');
+        begin_symbol   = symbol_start;
         begin_vector   = '[';
-        end_vector     = ']';
         begin_map      = '{';
         begin_list     = '(';
-        end_list       = ')';
         string_delim   = '"';
-        begin_number   = digit | '-';
-
-        symbol_name    = [\-\+\.]? symbol_first_c (symbol_chars)*;
+        begin_number   = digit;
 
-        symbol         = (operators | (symbol_name ('/' symbol_name)?));
+        symbol_name    = symbol_start (symbol_chars)*;
+        symbol         = (symbol_name ('/' symbol_name)?);
 
         # int / decimal rules
-        integer        = '-'? ('0' | [1-9] digit*);
+        integer        = ('0' | [1-9] digit*);
         exp            = ([Ee] [+\-]? digit+);
 
 
@@ -61,7 +53,7 @@
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
             error(__FUNCTION__, s.str());
-            exit(-1);
+            fhold; fbreak;
         }
 }%%
 
@@ -75,6 +67,31 @@
 
     write data;
 
+    action parse_dispatch {
+        const char *np = parse_dispatch(fpc + 1, pe, o);
+        if (np == NULL) { fhold; fbreak; } else fexec np;
+    }
+
+    action parse_char {
+        const char *np = parse_esc_char(fpc, pe, o);
+        if (np == NULL) { fhold; fbreak; } else fexec np;
+    }
+
+    action parse_string {
+        const char *np = parse_string(fpc, pe, o);
+        if (np == NULL) { fhold; fbreak; } else fexec np;
+    }
+
+    action parse_keyword {
+        const char *np = parse_keyword(fpc, pe, o);
+        if (np == NULL) { fhold; fbreak; } else fexec np;
+    }
+
+    action parse_operator {
+        const char *np = parse_operator(fpc, pe, o);
+        if (np == NULL) { fhold; fbreak; } else fexec np;
+    }
+
     action parse_symbol {
         std::string sym;
         const char *np = parse_symbol(fpc, pe, sym);
@@ -89,26 +106,6 @@
         }
     }
 
-    action parse_keyword {
-        const char *np = parse_keyword(fpc, pe, o);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
-    }
-
-    action parse_char {
-        Rice::String s;
-
-        if (!parse_escaped_char(*fpc, s)) {
-            fhold; fbreak;
-        } else {
-            o = s;
-        }
-    }
-
-    action parse_string {
-        const char *np = parse_string(fpc, pe, o);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
-    }
-
     action parse_number {
         // try to parse a decimal first
         const char *np = parse_decimal(fpc, pe, o);
@@ -143,19 +140,15 @@
         if (np == NULL) { fhold; fbreak; } else fexec np;
     }
 
-    action parse_dispatch {
-        const char *np = parse_dispatch(fpc + 1, pe, o);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
-    }
-
     action exit { fhold; fbreak; }
 
     main := (
              begin_dispatch >parse_dispatch |
-             begin_char (alnum|punct) >parse_char |
+             begin_char >parse_char |
              string_delim >parse_string |
-             begin_symbol >parse_symbol |
              begin_keyword >parse_keyword |
+             operators >parse_operator |
+             begin_symbol >parse_symbol |
              begin_number >parse_number |
              begin_vector >parse_vector |
              begin_list >parse_list |
@@ -166,7 +159,7 @@
 
 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;
 
     %% write init;
@@ -185,6 +178,133 @@ const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object
 
 
 
+// ============================================================
+// operator parsing
+//
+%%{
+    machine EDN_operator;
+    include EDN_common;
+
+    write data;
+
+    action parse_symbol {
+        // parse a symbol including the leading operator (-, +, .)
+        std::string sym;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { fhold; fbreak; } else {
+            o = Parser::make_edn_symbol(sym);
+            fexec np;
+        }
+    }
+
+    action parse_number {
+        // parse a number with the leading symbol - this is slightly
+        // different than the one within EDN_value since it includes
+        // the leading - or +
+        //
+        // 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) {
+            fexec np;
+            fhold;
+            fbreak;
+        }
+        else {
+            error(__FUNCTION__, *p);
+            fexec pe;
+        }
+    }
+
+    action parse_operator {
+        // stand-alone operators (-, +, /, ... etc)
+        std::string sym;
+        sym += *(fpc - 1);
+        o = Parser::make_edn_symbol(sym);
+    }
+
+    action exit { fhold; fbreak; }
+
+    main := (
+             ('-'|'+'|'.') alpha >parse_symbol |
+             ('-'|'+') begin_number >parse_number |
+             operators ignore* >parse_operator
+             ) ^(operators|alpha|digit)? @exit;
+}%%
+
+
+const char* edn::Parser::parse_operator(const char *p, const char *pe, Rice::Object& o)
+{
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    int cs;
+    std::string op;
+
+    %% write init;
+    p_save = p;
+    %% write exec;
+
+    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
+//
+%%{
+    machine EDN_escaped_char;
+    include EDN_common;
+
+    write data;
+
+    valid_chars = alpha;
+
+    action exit { fhold; fbreak; }
+
+    main := (
+             begin_char valid_chars+ ignore*
+             ) (^(valid_chars | '\\')? @exit);
+}%%
+
+
+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;
+
+    %% write init;
+    p_save = p;
+    %% write exec;
+
+    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
 //
@@ -197,14 +317,15 @@ const char *edn::Parser::parse_value(const char *p, const char *pe, Rice::Object
     action exit { fhold; fbreak; }
 
     main := (
-             symbol
-             ) ignore* (^symbol_chars? @exit);
+             operators? symbol |
+             operators
+             ) ignore* (^(symbol_chars | operators)? @exit);
 }%%
 
 
 const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string& s)
 {
-    //std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
     int cs;
 
     %% write init;
@@ -237,8 +358,8 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string
     machine EDN_keyword;
     include EDN_common;
 
-    keyword_chars = symbol_chars;
-    keyword_start = symbol_first_c | '#'; # keywords can have '#' after ':'
+    keyword_chars = symbol_chars | operators;
+    keyword_start = symbol_start | [\#\./];
 
     keyword_name    = keyword_start (keyword_chars)*;
 
@@ -253,6 +374,7 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, std::string
 const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Object& o)
 {
     int cs;
+    //    std::cerr << __FUNCTION__ << "   -  p: '" << p << "'" << std::endl;
 
     %% write init;
     p_save = p;
@@ -285,7 +407,7 @@ const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Obje
     write data;
 
     action parse_string {
-        if (!parse_byte_stream(p_save + 1, p, s)) {
+        if (!Parser::parse_byte_stream(p_save + 1, p, s)) {
             fhold;
             fbreak;
         } else {
@@ -299,9 +421,8 @@ const char* edn::Parser::parse_keyword(const char *p, const char *pe, Rice::Obje
                           (^([\"\\] | 0..0x1f) |
                            '\\'[\"\\/bfnrt] |
                            '\\u'[0-9a-fA-F]{4} |
-                           '\\'^([\"\\/bfnrtu]|0..0x1f))* %parse_string)
-            string_delim @err(close_err)
-            @exit;
+                           '\\'^([\"\\/bfnrtu]|0..0x1f))* %parse_string
+                          ) :>> string_delim @err(close_err) @exit;
 }%%
 
 
@@ -339,11 +460,10 @@ const char* edn::Parser::parse_string(const char *p, const char *pe, Rice::Objec
 
     action exit { fhold; fbreak; }
 
-    main := (
-             (integer '.' digit* (exp? [M]?)) |
-             (integer exp)
-             )
-        (^[0-9Ee.+\-M]? @exit );
+    main := ('-'|'+')? (
+                        (integer '.' digit* (exp? [M]?)) |
+                        (integer exp)
+                        ) (^[0-9Ee.+\-M]? @exit );
 }%%
 
 
@@ -356,8 +476,7 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Obje
     %% write exec;
 
     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
@@ -376,7 +495,9 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, Rice::Obje
 
     action exit { fhold; fbreak; }
 
-    main := (integer [M|N]?) (^[0-9MN]? @exit);
+    main := (
+             ('-'|'+')? (integer [MN]?)
+             ) (^[0-9MN+\-]? @exit);
 }%%
 
 const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Object& o)
@@ -388,8 +509,7 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Obje
     %% write exec;
 
     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
@@ -439,10 +559,14 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, Rice::Obje
     machine EDN_vector;
     include EDN_sequence_common;
 
+    end_vector     = ']';
+
     write data;
 
-    main := begin_vector ignore* sequence? end_vector @err(close_err)
-            @exit;
+    main := begin_vector (
+                          ignore* sequence? :>> end_vector
+                          )
+                          @err(close_err) @exit;
 }%%
 
 
@@ -481,10 +605,13 @@ const char* edn::Parser::parse_vector(const char *p, const char *pe, Rice::Objec
     machine EDN_list;
     include EDN_sequence_common;
 
+    end_list       = ')';
+
     write data;
 
-    main := begin_list ignore* sequence? end_list @err(close_err)
-            @exit;
+    main := begin_list (
+                        ignore* sequence? :>> end_list
+                        ) @err(close_err) @exit;
 }%%
 
 //
@@ -526,7 +653,9 @@ const char* edn::Parser::parse_list(const char *p, const char *pe, Rice::Object&
     begin_set    = '{';
     end_set      = '}';
 
-    main := begin_set ignore* sequence? end_set @err(close_err) @exit;
+    main := begin_set (
+                       ignore* sequence? :>> end_set
+                       ) @err(close_err) @exit;
 }%%
 
 //
@@ -544,7 +673,7 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, Rice::Object&
     %% write exec;
 
     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) {
@@ -574,7 +703,9 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, Rice::Object&
         fexec pe;
     }
 
-    main := begin_map ignore* (sequence)? :>> end_map @err(close_err) @exit;
+    main := begin_map (
+                       ignore* (sequence)? :>> end_map
+                       ) @err(close_err) @exit;
 }%%
 
 
@@ -620,14 +751,9 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object&
     machine EDN_tagged;
     include EDN_common;
 
-#    inst = (string_delim [0-9\-\+:\.TZ]* string_delim);
+#    inst = (string_delim [0-9+\-:\.TZ]* string_delim);
 #    uuid = (string_delim [a-f0-9\-]* string_delim);
 
-    # tags
-    tagged_symbol = alpha [a-zA-z0-9]*;
-    built_in_tag  = tagged_symbol;
-    user_tag      = tagged_symbol '/' tagged_symbol;
-
     write data;
 
     action parse_symbol {
@@ -647,7 +773,7 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, Rice::Object&
 
 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;
 
@@ -657,7 +783,7 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Objec
     %% write exec;
 
     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;
     }
@@ -689,9 +815,9 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, Rice::Objec
         fhold; fbreak;
     }
 
-    main := '_' ignore* (
-                         begin_value >discard_value
-                         ) @exit;
+    main := begin_discard ignore* (
+                                   begin_value >discard_value
+                                   ) @exit;
 }%%
 
 
@@ -728,19 +854,16 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     write data;
 
     action parse_discard {
-        //        std::cerr << "--- DISPATCH DISCARD: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_discard(fpc, pe);
         if (np == NULL) { fhold; fbreak; } else fexec np;
     }
 
     action parse_set {
-        //        std::cerr << "--- DISPATCH SET: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_set(fpc, pe, o);
         if (np == NULL) { fhold; fbreak; } else fexec np;
     }
 
     action parse_tagged {
-        //        std::cerr << "--- DISPATCH TAGGED: fpc is '" << fpc << "'" << std::endl;
         const char *np = parse_tagged(fpc, pe, o);
         if (np == NULL) { fhold; fbreak; } else fexec np;
     }

data/ext/edn_turbo/edn_parser_def.cc

@@ -1,5 +1,7 @@
 #include <iostream>
+#include <iomanip>
 #include <string>
+#include <limits>
 
 #include <rice/String.hpp>
 #include <rice/Array.hpp>
@@ -11,6 +13,47 @@
 
 namespace edn
 {
+    template <typename T>
+    static std::size_t get_max_chars(T)
+    {
+        std::stringstream s;
+        s << std::fixed << std::numeric_limits<T>::max();
+        return s.str().length();
+    }
+
+    static const std::size_t LL_max_chars = get_max_chars<>((long long) 1);
+    static const std::size_t LD_max_chars = get_max_chars<>((long double) 1);
+
+    //
+    // convert to int.. if string rep has more digits than long can
+    // hold, call into ruby to get a big num
+    Rice::Object Parser::integer_to_ruby(const char* str, std::size_t len)
+    {
+        if (len < LL_max_chars)
+        {
+            return buftotype<long>(str, len);
+        }
+
+        // value is outside of range of long type. Use ruby to convert it
+        VALUE rb_s = Rice::protect(rb_str_new2, str);
+        return Rice::protect(rb_funcall, rb_mEDNT, EDNT_STR_INT_TO_BIGNUM, 1, rb_s);
+    }
+
+    //
+    // as above.. TODO: check exponential
+    Rice::Object Parser::float_to_ruby(const char* str, std::size_t len)
+    {
+        if (len < LD_max_chars)
+        {
+            return buftotype<double>(str, len);
+        }
+
+        // value is outside of range of long type. Use ruby to convert it
+        VALUE rb_s = Rice::protect(rb_str_new2, str);
+        return Rice::protect(rb_funcall, rb_mEDNT, EDNT_STR_DBL_TO_BIGNUM, 1, rb_s);
+    }
+
+
     //
     // copies the string data, unescaping any present values that need to be replaced
     //
@@ -18,9 +61,8 @@ namespace edn
     {
         if (p_end > p_start) {
             std::string buf;
-            std::size_t len = p_end - p_start;
 
-            if (unicode_to_utf8(p_start, len, buf))
+            if (unicode_to_utf8(p_start, p_end - p_start, buf))
             {
                 // utf-8 encode
                 VALUE vs = Rice::protect( rb_str_new2, buf.c_str() );
@@ -34,22 +76,27 @@ namespace edn
     }
 
     //
-    // handles things like \c, \n
+    // handles things like \c, \newline
     //
-    bool Parser::parse_escaped_char(char c, Rice::String& s)
+    bool Parser::parse_escaped_char(const char *p, const char *pe, Rice::Object& o)
     {
-        char str[2] = { c, 0 };
-
-        switch (c) {
-          case 'n': str[0] = '\n'; break;
-          case 't': str[0] = '\t'; break;
-          case 'r': str[0] = '\r'; break;
-          case 'v': str[0] = '\v'; break;
-          case 'f': str[0] = '\f'; break;
-          default: break;
+        std::string buf;
+        std::size_t len = pe - p;
+        buf.append(p, len);
+
+        if (len > 1) {
+            if      (buf == "newline") buf = "\\n";
+            else if (buf == "tab") buf = "\\t";
+            else if (buf == "return") buf = "\\r";
+            else if (buf == "space") buf = " ";
+            else if (buf == "formfeed") buf = "\\f";
+            else if (buf == "backspace") buf = "\\b";
+            // TODO: is this supported?
+            else if (buf == "verticaltab") buf = "\\v";
+            else return false;
         }
 
-        s = str;
+        o = Rice::String(buf);
         return true;
     }