Ditch gcc 4.6 support

4 files changed, 91 insertions, 91 deletions

diff --git a/src/sexpr/lexer.cpp b/src/sexpr/lexer.cpp
index 8c1c380..cc7087b 100644
--- a/src/sexpr/lexer.cpp
+++ b/src/sexpr/lexer.cpp
@@ -28,14 +28,14 @@ namespace sexpr
 {
     Lexeme Lexer::_adv()
     {
-        XString whitespace = " \t\n\r\v\f";
+        LString whitespace = " \t\n\r\v\f"_s;
         while (true)
         {
             if (!_in.get(_span.begin))
             {
                 if (!_depth.empty())
                 {
-                    _depth.back().error("Unmatched '('");
+                    _depth.back().error("Unmatched '('"_s);
                     return TOK_ERROR;
                 }
                 return TOK_EOF;
@@ -52,14 +52,14 @@ namespace sexpr
         switch (co)
         {
         case '(':
-            _string = "(";
+            _string = "("_s;
             _depth.push_back(_span.end);
             return TOK_OPEN;
         case ')':
-            _string = ")";
+            _string = ")"_s;
             if (_depth.empty())
             {
-                _span.end.error("Unmatched ')'");
+                _span.end.error("Unmatched ')'"_s);
                 return TOK_ERROR;
             }
             _depth.pop_back();
@@ -73,7 +73,7 @@ namespace sexpr
                 {
                     if (!_in.get(_span.end))
                     {
-                        _span.error("EOF in string literal");
+                        _span.error("EOF in string literal"_s);
                         return TOK_ERROR;
                     }
                     char ch = _span.end.ch();
@@ -89,7 +89,7 @@ namespace sexpr
 
                     if (!_in.get(_span.end))
                     {
-                        _span.end.error("EOF at backslash in string");
+                        _span.end.error("EOF at backslash in string"_s);
                         return TOK_ERROR;
                     }
                     ch = _span.end.ch();
@@ -97,7 +97,7 @@ namespace sexpr
                     switch (ch)
                     {
                     default:
-                        _span.end.error("Unknown backslash sequence");
+                        _span.end.error("Unknown backslash sequence"_s);
                         return TOK_ERROR;
                     case 'a': collect += '\a'; break;
                     case 'b': collect += '\b'; break;
@@ -117,7 +117,7 @@ namespace sexpr
                                 tmp *= 16;
                                 if (!_in.get(_span.end))
                                 {
-                                    _span.end.error("EOF after \\x in string");
+                                    _span.end.error("EOF after \\x in string"_s);
                                     return TOK_ERROR;
                                 }
                                 char cx = _span.end.ch();
@@ -130,7 +130,7 @@ namespace sexpr
                                     tmp += cx - 'a' + 10;
                                 else
                                 {
-                                    _span.end.error("Non-hex char after \\x");
+                                    _span.end.error("Non-hex char after \\x"_s);
                                     return TOK_ERROR;
                                 }
                             }
@@ -143,7 +143,7 @@ namespace sexpr
             }
         case '\'':
         case '\\':
-            _span.end.error("forbidden character");
+            _span.end.error("forbidden character"_s);
             return TOK_ERROR;
         default:
             // this includes integers - they are differentiated in parsing
@@ -168,7 +168,7 @@ namespace sexpr
                 }
                 _string = AString(collect);
                 if (!_string.is_print())
-                    _span.error("String is not entirely printable");
+                    _span.error("String is not entirely printable"_s);
                 return TOK_TOKEN;
             }
         }
@@ -178,23 +178,23 @@ namespace sexpr
     {
         switch (c)
         {
-        case '\a': return {"\\a"};
-        case '\b': return {"\\b"};
-        case '\e': return {"\\e"};
-        case '\f': return {"\\f"};
-        //case '\n': return {"\\n"};
-        case '\r': return {"\\r"};
-        case '\t': return {"\\t"};
-        case '\v': return {"\\v"};
-        case '\\': return {"\\\\"};
-        case '\"': return {"\\\""};
+        case '\a': return "\\a"_s;
+        case '\b': return "\\b"_s;
+        case '\e': return "\\e"_s;
+        case '\f': return "\\f"_s;
+        //case '\n': return "\\n"_s;
+        case '\r': return "\\r"_s;
+        case '\t': return "\\t"_s;
+        case '\v': return "\\v"_s;
+        case '\\': return "\\\\"_s;
+        case '\"': return "\\\""_s;
         default:
             if (c == '\n')
                 return c;
             if (' ' <= c && c <= '~')
                 return c;
             else
-                return STRNPRINTF(5, "\\x%02x", static_cast<uint8_t>(c));
+                return STRNPRINTF(5, "\\x%02x"_fmt, static_cast<uint8_t>(c));
         }
     }
     AString escape(XString s)
@@ -207,22 +207,22 @@ namespace sexpr
         return AString(m);
     }
 
-    ZString token_name(Lexeme tok)
+    LString token_name(Lexeme tok)
     {
         switch (tok)
         {
         case TOK_EOF:
-            return ZString("EOF");
+            return "EOF"_s;
         case TOK_OPEN:
-            return ZString("OPEN");
+            return "OPEN"_s;
         case TOK_CLOSE:
-            return ZString("CLOSE");
+            return "CLOSE"_s;
         case TOK_STRING:
-            return ZString("STRING");
+            return "STRING"_s;
         case TOK_TOKEN:
-            return ZString("TOKEN");
+            return "TOKEN"_s;
         default:
-            return ZString("ERROR");
+            return "ERROR"_s;
         }
     }
 } // namespace sexpr
diff --git a/src/sexpr/lexer.hpp b/src/sexpr/lexer.hpp
index 7bce620..84c9e1d 100644
--- a/src/sexpr/lexer.hpp
+++ b/src/sexpr/lexer.hpp
@@ -67,7 +67,7 @@ namespace sexpr
     VString<4> escape(char c);
     AString escape(XString s);
 
-    ZString token_name(Lexeme tok);
+    LString token_name(Lexeme tok);
 } // namespace sexpr
 
 #endif // TMWA_SEXPR_LEXER_HPP
diff --git a/src/sexpr/lexer_test.cpp b/src/sexpr/lexer_test.cpp
index ade79af..fbff0d8 100644
--- a/src/sexpr/lexer_test.cpp
+++ b/src/sexpr/lexer_test.cpp
@@ -40,69 +40,69 @@ io::FD string_pipe(ZString sz)
 
 TEST(sexpr, escape)
 {
-    EXPECT_EQ(sexpr::escape('\0'), "\\x00");
-    EXPECT_EQ(sexpr::escape('\x1f'), "\\x1f");
-    EXPECT_EQ(sexpr::escape('\x20'), " ");
-    EXPECT_EQ(sexpr::escape('\x7e'), "~");
-    EXPECT_EQ(sexpr::escape('\x7f'), "\\x7f");
-    EXPECT_EQ(sexpr::escape('\x80'), "\\x80");
-    EXPECT_EQ(sexpr::escape('\xff'), "\\xff");
-    EXPECT_EQ(sexpr::escape('\a'), "\\a");
-    EXPECT_EQ(sexpr::escape('\b'), "\\b");
-    EXPECT_EQ(sexpr::escape('\e'), "\\e");
-    EXPECT_EQ(sexpr::escape('\f'), "\\f");
-    //EXPECT_EQ(sexpr::escape('\n'), "\\n");
-    EXPECT_EQ(sexpr::escape('\n'), "\n");
-    EXPECT_EQ(sexpr::escape('\r'), "\\r");
-    EXPECT_EQ(sexpr::escape('\t'), "\\t");
-    EXPECT_EQ(sexpr::escape('\v'), "\\v");
-    EXPECT_EQ(sexpr::escape('\\'), "\\\\");
-    EXPECT_EQ(sexpr::escape('\"'), "\\\"");
+    EXPECT_EQ(sexpr::escape('\0'), "\\x00"_s);
+    EXPECT_EQ(sexpr::escape('\x1f'), "\\x1f"_s);
+    EXPECT_EQ(sexpr::escape('\x20'), " "_s);
+    EXPECT_EQ(sexpr::escape('\x7e'), "~"_s);
+    EXPECT_EQ(sexpr::escape('\x7f'), "\\x7f"_s);
+    EXPECT_EQ(sexpr::escape('\x80'), "\\x80"_s);
+    EXPECT_EQ(sexpr::escape('\xff'), "\\xff"_s);
+    EXPECT_EQ(sexpr::escape('\a'), "\\a"_s);
+    EXPECT_EQ(sexpr::escape('\b'), "\\b"_s);
+    EXPECT_EQ(sexpr::escape('\e'), "\\e"_s);
+    EXPECT_EQ(sexpr::escape('\f'), "\\f"_s);
+    //EXPECT_EQ(sexpr::escape('\n'), "\\n"_s);
+    EXPECT_EQ(sexpr::escape('\n'), "\n"_s);
+    EXPECT_EQ(sexpr::escape('\r'), "\\r"_s);
+    EXPECT_EQ(sexpr::escape('\t'), "\\t"_s);
+    EXPECT_EQ(sexpr::escape('\v'), "\\v"_s);
+    EXPECT_EQ(sexpr::escape('\\'), "\\\\"_s);
+    EXPECT_EQ(sexpr::escape('\"'), "\\\""_s);
 
-    EXPECT_EQ(sexpr::escape("\x1f\x20\x7e\x7f\x80\xff\a\b\e\f\r\t\v\\\""),
-            "\"\\x1f ~\\x7f\\x80\\xff\\a\\b\\e\\f\\r\\t\\v\\\\\\\"\"");
+    EXPECT_EQ(sexpr::escape("\x1f\x20\x7e\x7f\x80\xff\a\b\e\f\r\t\v\\\""_s),
+            "\"\\x1f ~\\x7f\\x80\\xff\\a\\b\\e\\f\\r\\t\\v\\\\\\\"\""_s);
 }
 
 TEST(sexpr, lexer)
 {
     io::LineSpan span;
-    sexpr::Lexer lexer("<lexer-test1>", string_pipe(" foo( ) 123\"\" \n"));
+    sexpr::Lexer lexer("<lexer-test1>"_s, string_pipe(" foo( ) 123\"\" \n"_s));
     EXPECT_EQ(lexer.peek(), sexpr::TOK_TOKEN);
-    EXPECT_EQ(lexer.val_string(), "foo");
-    EXPECT_EQ(lexer.span().message_str("error", "test"),
+    EXPECT_EQ(lexer.val_string(), "foo"_s);
+    EXPECT_EQ(lexer.span().message_str("error"_s, "test"_s),
             "<lexer-test1>:1:2: error: test\n"
             " foo( ) 123\"\" \n"
-            " ^~~\n"
+            " ^~~\n"_s
     );
     lexer.adv();
     EXPECT_EQ(lexer.peek(), sexpr::TOK_OPEN);
-    EXPECT_EQ(lexer.span().message_str("error", "test"),
+    EXPECT_EQ(lexer.span().message_str("error"_s, "test"_s),
             "<lexer-test1>:1:5: error: test\n"
             " foo( ) 123\"\" \n"
-            "    ^\n"
+            "    ^\n"_s
     );
     lexer.adv();
     EXPECT_EQ(lexer.peek(), sexpr::TOK_CLOSE);
-    EXPECT_EQ(lexer.span().message_str("error", "test"),
+    EXPECT_EQ(lexer.span().message_str("error"_s, "test"_s),
             "<lexer-test1>:1:7: error: test\n"
             " foo( ) 123\"\" \n"
-            "      ^\n"
+            "      ^\n"_s
     );
     lexer.adv();
     EXPECT_EQ(lexer.peek(), sexpr::TOK_TOKEN);
-    EXPECT_EQ(lexer.val_string(), "123");
-    EXPECT_EQ(lexer.span().message_str("error", "test"),
+    EXPECT_EQ(lexer.val_string(), "123"_s);
+    EXPECT_EQ(lexer.span().message_str("error"_s, "test"_s),
             "<lexer-test1>:1:9: error: test\n"
             " foo( ) 123\"\" \n"
-            "        ^~~\n"
+            "        ^~~\n"_s
     );
     lexer.adv();
     EXPECT_EQ(lexer.peek(), sexpr::TOK_STRING);
-    EXPECT_EQ(lexer.val_string(), "");
-    EXPECT_EQ(lexer.span().message_str("error", "test"),
+    EXPECT_EQ(lexer.val_string(), ""_s);
+    EXPECT_EQ(lexer.span().message_str("error"_s, "test"_s),
             "<lexer-test1>:1:12: error: test\n"
             " foo( ) 123\"\" \n"
-            "           ^~\n"
+            "           ^~\n"_s
     );
     lexer.adv();
     EXPECT_EQ(lexer.peek(), sexpr::TOK_EOF);
@@ -112,22 +112,22 @@ TEST(sexpr, lexbad)
 {
     {
         io::LineSpan span;
-        sexpr::Lexer lexer("<lexer-bad>", string_pipe("(\n"));
+        sexpr::Lexer lexer("<lexer-bad>"_s, string_pipe("(\n"_s));
         EXPECT_EQ(lexer.peek(), sexpr::TOK_OPEN);
         lexer.adv();
         EXPECT_EQ(lexer.peek(), sexpr::TOK_ERROR);
     }
     for (ZString bad : {
-            ZString(")\n"),
-            ZString("\"\n"),
-            ZString("'\n"),
-            ZString("\\\n"),
-            ZString("\"\\"),
-            ZString("\"\\z\""),
+            ZString(")\n"_s),
+            ZString("\"\n"_s),
+            ZString("'\n"_s),
+            ZString("\\\n"_s),
+            ZString("\"\\"_s),
+            ZString("\"\\z\""_s),
     })
     {
         io::LineSpan span;
-        sexpr::Lexer lexer("<lexer-bad>", string_pipe(bad));
+        sexpr::Lexer lexer("<lexer-bad>"_s, string_pipe(bad));
         EXPECT_EQ(lexer.peek(), sexpr::TOK_ERROR);
     }
 }
diff --git a/src/sexpr/parser_test.cpp b/src/sexpr/parser_test.cpp
index d67d041..0be333b 100644
--- a/src/sexpr/parser_test.cpp
+++ b/src/sexpr/parser_test.cpp
@@ -42,11 +42,11 @@ TEST(sexpr, parser)
 {
     sexpr::SExpr s;
     io::LineSpan span;
-    sexpr::Lexer lexer("<parser-test1>", string_pipe(" foo( ) 123\"\" \n"));
+    sexpr::Lexer lexer("<parser-test1>"_s, string_pipe(" foo( ) 123\"\" \n"_s));
 
     EXPECT_TRUE(sexpr::parse(lexer, s));
     EXPECT_EQ(s._type, sexpr::TOKEN);
-    EXPECT_EQ(s._str, "foo");
+    EXPECT_EQ(s._str, "foo"_s);
 
     EXPECT_TRUE(sexpr::parse(lexer, s));
     EXPECT_EQ(s._type, sexpr::LIST);
@@ -58,7 +58,7 @@ TEST(sexpr, parser)
 
     EXPECT_TRUE(sexpr::parse(lexer, s));
     EXPECT_EQ(s._type, sexpr::STRING);
-    EXPECT_EQ(s._str, "");
+    EXPECT_EQ(s._str, ""_s);
 
     EXPECT_FALSE(sexpr::parse(lexer, s));
     EXPECT_EQ(lexer.peek(), sexpr::TOK_EOF);
@@ -67,19 +67,19 @@ TEST(sexpr, parser)
 TEST(sexpr, parselist)
 {
     sexpr::SExpr s;
-    sexpr::Lexer lexer("<parser-test1>", string_pipe("(foo)(bar)\n"));
+    sexpr::Lexer lexer("<parser-test1>"_s, string_pipe("(foo)(bar)\n"_s));
 
     EXPECT_TRUE(sexpr::parse(lexer, s));
     EXPECT_EQ(s._type, sexpr::LIST);
     EXPECT_EQ(s._list.size(), 1);
     EXPECT_EQ(s._list[0]._type, sexpr::TOKEN);
-    EXPECT_EQ(s._list[0]._str, "foo");
+    EXPECT_EQ(s._list[0]._str, "foo"_s);
 
     EXPECT_TRUE(sexpr::parse(lexer, s));
     EXPECT_EQ(s._type, sexpr::LIST);
     EXPECT_EQ(s._list.size(), 1);
     EXPECT_EQ(s._list[0]._type, sexpr::TOKEN);
-    EXPECT_EQ(s._list[0]._str, "bar");
+    EXPECT_EQ(s._list[0]._str, "bar"_s);
 
     EXPECT_FALSE(sexpr::parse(lexer, s));
     EXPECT_EQ(lexer.peek(), sexpr::TOK_EOF);
@@ -87,22 +87,22 @@ TEST(sexpr, parselist)
 
 TEST(sexpr, parsebad)
 {
-    for (ZString bad : {
-            ZString("(\n"),
-            ZString(")\n"),
-            ZString("\"\n"),
-            ZString("'\n"),
-            ZString("\\\n"),
-            ZString("\"\\"),
-            ZString("\"\\z\""),
-            ZString("(()\n"),
-            ZString("((\n"),
-            ZString("((\"\n"),
+    for (LString bad : {
+            "(\n"_s,
+            ")\n"_s,
+            "\"_s\n"_s,
+            "'\n"_s,
+            "\\\n"_s,
+            "\"_s\\"_s,
+            "\"_s\\z\""_s,
+            "(()\n"_s,
+            "((\n"_s,
+            "((\"\n"_s,
     })
     {
         sexpr::SExpr s;
         io::LineSpan span;
-        sexpr::Lexer lexer("<parse-bad>", string_pipe(bad));
+        sexpr::Lexer lexer("<parse-bad>"_s, string_pipe(bad));
         EXPECT_FALSE(sexpr::parse(lexer, s));
         EXPECT_EQ(lexer.peek(), sexpr::TOK_ERROR);
     }