Split string header into pieces

26 files changed, 64 insertions, 1500 deletions

diff --git a/src/common/core.cpp b/src/common/core.cpp
index 76aa09c..727babd 100644
--- a/src/common/core.cpp
+++ b/src/common/core.cpp
@@ -8,6 +8,8 @@
 #include <cstdlib>
 #include <ctime>
 
+#include "../strings/zstring.hpp"
+
 #include "random.hpp"
 #include "socket.hpp"
 #include "timer.hpp"
@@ -79,7 +81,7 @@ int main(int argc, char **argv)
     // ZString args[argc]; is (deliberately!) not supported by clang yet
     ZString *args = static_cast<ZString *>(alloca(argc * sizeof(ZString)));
     for (int i = 0; i < argc; ++i)
-        args[i] = ZString(ZString::really_construct_from_a_pointer, argv[i], nullptr);
+        args[i] = ZString(strings::really_construct_from_a_pointer, argv[i], nullptr);
     do_init(argc, args);
     // set up exit handlers *after* the initialization has happened.
     // This is because term_func is likely to depend on successful init.
diff --git a/src/common/core.hpp b/src/common/core.hpp
index f1473ed..1cbd0c2 100644
--- a/src/common/core.hpp
+++ b/src/common/core.hpp
@@ -3,7 +3,7 @@
 
 #include "sanity.hpp"
 
-#include "strings.hpp"
+#include "../strings/fwd.hpp"
 
 /// core.c contains a server-independent main() function
 /// and then runs a do_sendrecv loop
diff --git a/src/common/dumb_ptr.hpp b/src/common/dumb_ptr.hpp
index fe5031a..bcc9dda 100644
--- a/src/common/dumb_ptr.hpp
+++ b/src/common/dumb_ptr.hpp
@@ -25,8 +25,11 @@
 
 #include <algorithm>
 
+#include "../strings/fstring.hpp"
+#include "../strings/zstring.hpp"
+#include "../strings/xstring.hpp"
+
 #include "const_array.hpp"
-#include "strings.hpp"
 
 // unmanaged new/delete-able pointer
 // should be replaced by std::unique_ptr<T>
@@ -240,7 +243,7 @@ struct dumb_string
 
     operator ZString() const
     {
-        return ZString(ZString::really_construct_from_a_pointer, c_str(), nullptr);
+        return ZString(strings::really_construct_from_a_pointer, c_str(), nullptr);
     }
 
     FString str() const
diff --git a/src/common/extract.cpp b/src/common/extract.cpp
index 720e6df..bac7b38 100644
--- a/src/common/extract.cpp
+++ b/src/common/extract.cpp
@@ -18,6 +18,10 @@
 //    You should have received a copy of the GNU General Public License
 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+#include "../strings/fstring.hpp"
+#include "../strings/xstring.hpp"
+#include "../strings/vstring.hpp"
+
 #include "../poison.hpp"
 
 bool extract(XString str, XString *rv)
diff --git a/src/common/extract.hpp b/src/common/extract.hpp
index c7bdbcb..dd0a8a3 100644
--- a/src/common/extract.hpp
+++ b/src/common/extract.hpp
@@ -23,6 +23,8 @@
 
 #include <algorithm>
 
+#include "../strings/xstring.hpp"
+
 #include "const_array.hpp"
 #include "mmo.hpp"
 #include "utils.hpp"
diff --git a/src/common/extract_test.cpp b/src/common/extract_test.cpp
index 78478c2..3d0610e 100644
--- a/src/common/extract_test.cpp
+++ b/src/common/extract_test.cpp
@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 
+#include "../strings/xstring.hpp"
+
 TEST(extract, record_int)
 {
     int x, y, z;
diff --git a/src/common/human_time_diff.hpp b/src/common/human_time_diff.hpp
index 3fc0f09..a937316 100644
--- a/src/common/human_time_diff.hpp
+++ b/src/common/human_time_diff.hpp
@@ -21,8 +21,9 @@
 
 #include "sanity.hpp"
 
+#include "../strings/xstring.hpp"
+
 #include "extract.hpp"
-#include "strings.hpp"
 
 struct HumanTimeDiff
 {
diff --git a/src/common/intern-pool.hpp b/src/common/intern-pool.hpp
index db840a2..204b659 100644
--- a/src/common/intern-pool.hpp
+++ b/src/common/intern-pool.hpp
@@ -6,7 +6,9 @@
 #include <map>
 #include <vector>
 
-#include "strings.hpp"
+#include "../strings/fstring.hpp"
+#include "../strings/zstring.hpp"
+#include "../strings/xstring.hpp"
 
 class InternPool
 {
diff --git a/src/common/intern-pool_test.cpp b/src/common/intern-pool_test.cpp
index 3bbca7b..bf17b67 100644
--- a/src/common/intern-pool_test.cpp
+++ b/src/common/intern-pool_test.cpp
@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 
+#include "../strings/base.hpp"
+
 TEST(InternPool, whydoesthisalwaysneedasecondname)
 {
     InternPool p;
diff --git a/src/common/io.hpp b/src/common/io.hpp
index 1831651..27bf4e2 100644
--- a/src/common/io.hpp
+++ b/src/common/io.hpp
@@ -4,7 +4,7 @@
 #include <istream>
 #include <ostream>
 
-#include "strings.hpp"
+#include "../strings/fstring.hpp"
 
 namespace io
 {
diff --git a/src/common/ip.cpp b/src/common/ip.cpp
index 4734a8b..a1fdfda 100644
--- a/src/common/ip.cpp
+++ b/src/common/ip.cpp
@@ -18,6 +18,9 @@
 //    You should have received a copy of the GNU General Public License
 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+#include "../strings/xstring.hpp"
+#include "../strings/vstring.hpp"
+
 #include "cxxstdio.hpp"
 
 #include "../poison.hpp"
diff --git a/src/common/ip.hpp b/src/common/ip.hpp
index aceb765..cce6c2b 100644
--- a/src/common/ip.hpp
+++ b/src/common/ip.hpp
@@ -23,8 +23,9 @@
 
 #include <netinet/in.h>
 
+#include "../strings/fwd.hpp"
+
 #include "extract.hpp"
-#include "strings.hpp"
 
 // TODO - in the long run ports belong here also
 // and of course, IPv6 stuff.
diff --git a/src/common/lock.cpp b/src/common/lock.cpp
index f19cd92..e21aee5 100644
--- a/src/common/lock.cpp
+++ b/src/common/lock.cpp
@@ -4,6 +4,9 @@
 
 #include <cstdio>
 
+#include "../strings/fstring.hpp"
+#include "../strings/zstring.hpp"
+
 #include "cxxstdio.hpp"
 #include "socket.hpp"
 
diff --git a/src/common/lock.hpp b/src/common/lock.hpp
index df4d1f8..5ca1aed 100644
--- a/src/common/lock.hpp
+++ b/src/common/lock.hpp
@@ -5,7 +5,7 @@
 
 #include <cstdio>
 
-#include "strings.hpp"
+#include "../strings/fwd.hpp"
 
 // TODO replace with a class
 
diff --git a/src/common/md5calc.cpp b/src/common/md5calc.cpp
index 1c48a24..1961fa6 100644
--- a/src/common/md5calc.cpp
+++ b/src/common/md5calc.cpp
@@ -2,6 +2,9 @@
 
 #include <cstring>
 
+#include "../strings/xstring.hpp"
+#include "../strings/vstring.hpp"
+
 #include "cxxstdio.hpp"
 #include "random.hpp"
 #include "utils.hpp"
diff --git a/src/common/md5calc.hpp b/src/common/md5calc.hpp
index 70a996e..e44a7a7 100644
--- a/src/common/md5calc.hpp
+++ b/src/common/md5calc.hpp
@@ -11,9 +11,11 @@
 
 #include <array>
 
+#include "../strings/fwd.hpp"
+#include "../strings/vstring.hpp"
+
 #include "ip.hpp"
 #include "mmo.hpp"
-#include "strings.hpp"
 
 /// The digest state - becomes the output
 struct MD5_state
diff --git a/src/common/md5calc_test.cpp b/src/common/md5calc_test.cpp
index 51b0b68..ab5f242 100644
--- a/src/common/md5calc_test.cpp
+++ b/src/common/md5calc_test.cpp
@@ -2,6 +2,9 @@
 
 #include <gtest/gtest.h>
 
+#include "../strings/xstring.hpp"
+#include "../strings/vstring.hpp"
+
 #include "utils.hpp"
 
 // This should be made part of the main API,
diff --git a/src/common/mmo.hpp b/src/common/mmo.hpp
index 0d3403c..16acb88 100644
--- a/src/common/mmo.hpp
+++ b/src/common/mmo.hpp
@@ -3,6 +3,9 @@
 #define MMO_HPP
 
 # include "sanity.hpp"
+
+# include "../strings/vstring.hpp"
+
 # include "timer.t.hpp"
 # include "utils2.hpp"
 
@@ -57,7 +60,7 @@ T stringish(VString<sizeof(T) - 1> iv)
 #define DEFAULT_EMAIL stringish<AccountEmail>("a@a.com")
 
 // It is decreed: a mapname shall not contain an extension
-class MapName : public strings::_crtp_string<MapName, MapName, ZString, XString>
+class MapName : public strings::_crtp_string<MapName, MapName, strings::ZPair>
 {
     VString<15> _impl;
 public:
diff --git a/src/common/socket.hpp b/src/common/socket.hpp
index 91a8c49..1ff400a 100644
--- a/src/common/socket.hpp
+++ b/src/common/socket.hpp
@@ -9,6 +9,10 @@
 
 # include <array>
 
+# include "../strings/fstring.hpp"
+# include "../strings/vstring.hpp"
+# include "../strings/xstring.hpp"
+
 # include "dumb_ptr.hpp"
 # include "ip.hpp"
 # include "utils.hpp"
diff --git a/src/common/strings.hpp b/src/common/strings.hpp
deleted file mode 100644
index 0b10570..0000000
--- a/src/common/strings.hpp
+++ /dev/null
@@ -1,1092 +0,0 @@
-#ifndef TMWA_COMMON_STRINGS_HPP
-#define TMWA_COMMON_STRINGS_HPP
-//    strings.hpp - All the string classes you'll ever need.
-//
-//    Copyright © 2013 Ben Longbons <b.r.longbons@gmail.com>
-//
-//    This file is part of The Mana World (Athena server)
-//
-//    This program is free software: you can redistribute it and/or modify
-//    it under the terms of the GNU General Public License as published by
-//    the Free Software Foundation, either version 3 of the License, or
-//    (at your option) any later version.
-//
-//    This program is distributed in the hope that it will be useful,
-//    but WITHOUT ANY WARRANTY; without even the implied warranty of
-//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//    GNU General Public License for more details.
-//
-//    You should have received a copy of the GNU General Public License
-//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "sanity.hpp"
-
-#include <cassert>
-#include <cstdarg>
-#include <cstring>
-
-#include <algorithm>
-#include <deque>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <vector>
-
-#include "utils2.hpp"
-
-// It is a common mistake to assume that one string class for everything.
-// Because C++ and TMWA have a C legacy, there are a few more here
-// than would probably be necessary in an ideal language.
-namespace strings
-{
-    // owning
-    class MString;
-    class FString;
-    class TString; // C legacy version of SString
-    class SString; // is this one really worth it?
-
-    // non-owning
-    class ZString; // C legacy version of XString
-    class XString;
-
-    // semi-owning
-    template<uint8_t len>
-    class VString;
-
-    // simple pointer-wrapping iterator that can be used to get distinct
-    // types for different containers.
-    template<class Tag>
-    class _iterator
-    {
-        typedef _iterator X;
-
-        const char *_ptr;
-    public:
-        typedef ptrdiff_t difference_type;
-        typedef char value_type;
-        typedef const char *pointer;
-        typedef const char& reference;
-        typedef std::random_access_iterator_tag iterator_category;
-
-        _iterator(const char *p=nullptr) : _ptr(p) {}
-
-        // iterator
-        reference operator *() const { return *_ptr; }
-        X& operator ++() { ++_ptr; return *this; }
-        // equality comparable
-        friend bool operator == (X l, X r) { return l._ptr == r._ptr; }
-        // input iterator
-        friend bool operator != (X l, X r) { return !(l == r); }
-        pointer operator->() const { return _ptr; }
-        X operator++ (int) { X out = *this; ++*this; return out; }
-        // forward iterator is mostly semantical, and the ctor is above
-        // bidirectional iterator
-        X& operator --() { --_ptr; return *this; }
-        X operator-- (int) { X out = *this; --*this; return out; }
-        // random access iterator
-        X& operator += (difference_type n) { _ptr += n; return *this; }
-        friend X operator + (X a, difference_type n) { return a += n; }
-        friend X operator + (difference_type n, X a) { return a += n; }
-        X& operator -= (difference_type n) { _ptr -= n; return *this; }
-        friend X operator - (X a, difference_type n) { return a -= n; }
-        friend difference_type operator - (X b, X a) { return b._ptr - a._ptr; }
-        reference operator[](difference_type n) const { return _ptr[n]; }
-        friend bool operator < (X a, X b) { return a._ptr < b._ptr; }
-        friend bool operator > (X a, X b) { return b < a; }
-        friend bool operator >= (X a, X b) { return !(a < b); }
-        friend bool operator <= (X a, X b) { return !(a > b); }
-    };
-
-    /// A helper class that implements all the interesting stuff that can
-    /// be done on any constant string, in terms of .begin() and .end().
-    template<class T, class O, class Z, class X=XString>
-    class _crtp_string
-    {
-    public:
-        // this will have to be changed if MString decides to join in.
-        typedef _iterator<T> iterator;
-        typedef std::reverse_iterator<iterator> reverse_iterator;
-    private:
-        const T& _ref() const { return static_cast<const T&>(*this); }
-        iterator begin() const { return _ref().begin(); }
-        iterator end() const { return _ref().end(); }
-        const FString *base() const { return _ref().base(); }
-    public:
-        size_t size() const { return end() - begin(); }
-        reverse_iterator rbegin() const { return reverse_iterator(end()); }
-        reverse_iterator rend() const { return reverse_iterator(begin()); }
-        explicit
-        operator bool() const { return size(); }
-        bool operator !() const { return !size(); }
-
-        // the existence of this has led to bugs
-        // it's not really sane from a unicode perspective anyway ...
-        // prefer startswith or extract
-        __attribute__((deprecated))
-        char operator[](size_t i) const { return begin()[i]; }
-        char front() const { return *begin(); }
-        char back() const { return end()[-1]; }
-        const char *data() { return &*begin(); }
-
-        Z xslice_t(size_t o) const;
-        X xslice_h(size_t o) const;
-        Z xrslice_t(size_t no) const;
-        X xrslice_h(size_t no) const;
-        Z xislice_t(iterator it) const;
-        X xislice_h(iterator it) const;
-        X xlslice(size_t o, size_t l) const;
-        X xpslice(size_t b, size_t e) const;
-        X xislice(iterator b, iterator e) const;
-        Z lstrip() const;
-        X rstrip() const;
-        X strip() const;
-
-        bool startswith(XString x) const;
-        bool endswith(XString x) const;
-        bool startswith(char c) const;
-        bool endswith(char c) const;
-
-        bool contains(char c) const;
-        bool contains_seq(XString s) const;
-        bool contains_any(XString s) const;
-
-        bool has_print() const;
-        bool is_print() const;
-        __attribute__((deprecated))
-        O to_print() const;
-
-        bool is_graph() const;
-        bool has_graph() const;
-
-        bool has_lower() const;
-        bool is_lower() const;
-        O to_lower() const;
-
-        bool has_upper() const;
-        bool is_upper() const;
-        O to_upper() const;
-
-        bool has_alpha() const; // equivalent to has_lower || has_upper
-        bool is_alpha() const; // NOT equivalent to is_lower || is_upper
-
-        bool has_digit2() const;
-        bool is_digit2() const;
-        bool has_digit8() const;
-        bool is_digit8() const;
-        bool has_digit10() const;
-        bool is_digit10() const;
-        bool has_digit16() const;
-        bool is_digit16() const;
-
-        bool has_alnum() const; // equivalent to has_alpha || has_digit10
-        bool is_alnum() const; // NOT equivalent to is_alpha || is_digit10
-    };
-
-
-    /// An owning string that is still expected to change.
-    /// The storage might not be contiguous, but it still offers
-    /// random-access iterators.
-    /// TODO implement a special one, to avoid quirks of std::string.
-    class MString
-    {
-    public:
-        typedef std::deque<char>::iterator iterator;
-        typedef std::deque<char>::const_iterator const_iterator;
-        typedef std::reverse_iterator<iterator> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    private:
-        std::deque<char> _hack;
-    public:
-        iterator begin() { return _hack.begin(); }
-        iterator end() { return _hack.end(); }
-        const_iterator begin() const { return _hack.begin(); }
-        const_iterator end() const { return _hack.end(); }
-        reverse_iterator rbegin() { return reverse_iterator(end()); }
-        reverse_iterator rend() { return reverse_iterator(begin()); }
-        const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-        const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-
-        size_t size() const { return _hack.size(); }
-        explicit
-        operator bool() const { return size(); }
-        bool operator !() const { return !size(); }
-
-        MString& operator += (MString rhs)
-        {
-            _hack.insert(_hack.end(), rhs.begin(), rhs.end());
-            return *this;
-        }
-        MString& operator += (char c)
-        {
-            _hack.push_back(c);
-            return *this;
-        }
-        MString& operator += (XString xs);
-
-        void pop_back(size_t n=1)
-        {
-            while (n--)
-                _hack.pop_back();
-        }
-        char& front()
-        {
-            return _hack.front();
-        }
-        char& back()
-        {
-            return _hack.back();
-        }
-    };
-
-    /// An owning string that has reached its final contents.
-    /// The storage is NUL-terminated
-    /// TODO implement a special one, that guarantees refcounting.
-    class FString : public _crtp_string<FString, FString, ZString, XString>
-    {
-        std::shared_ptr<std::vector<char>> _hack2;
-
-        template<class It>
-        void _assign(It b, It e)
-        {
-            if (b == e)
-            {
-                // TODO use a special empty object
-                // return;
-            }
-            if (!std::is_base_of<std::forward_iterator_tag, typename std::iterator_traits<It>::iterator_category>::value)
-            {
-                // can't use std::distance
-                _hack2 = std::make_shared<std::vector<char>>();
-                for (; b != e; ++b)
-                    _hack2->push_back(*b);
-                _hack2->push_back('\0');
-                _hack2->shrink_to_fit();
-            }
-            size_t diff = std::distance(b, e);
-            _hack2 = std::make_shared<std::vector<char>>(diff + 1, '\0');
-            std::copy(b, e, _hack2->begin());
-        }
-    public:
-        FString()
-        {
-            const char *sadness = "";
-            _assign(sadness, sadness);
-        }
-
-        explicit FString(const MString& s)
-        {
-            _assign(s.begin(), s.end());
-        }
-
-        template<size_t n>
-        FString(char (&s)[n]) = delete;
-
-        template<size_t n>
-        FString(const char (&s)[n])
-        {
-            _assign(s, s + strlen(s));
-        }
-
-        template<class It>
-        FString(It b, It e)
-        {
-            _assign(b, e);
-        }
-
-
-        iterator begin() const { return &_hack2->begin()[0]; }
-        iterator end() const { return &_hack2->end()[-1]; }
-        const FString *base() const { return this; }
-        const char *c_str() const { return &*begin(); }
-
-        TString oslice_t(size_t o) const;
-        SString oslice_h(size_t o) const;
-        TString orslice_t(size_t no) const;
-        SString orslice_h(size_t no) const;
-        TString oislice_t(iterator it) const;
-        SString oislice_h(iterator it) const;
-        SString olslice(size_t o, size_t l) const;
-        SString opslice(size_t b, size_t e) const;
-        SString oislice(iterator b, iterator e) const;
-    };
-
-    /// An owning string that represents a tail slice of an FString.
-    /// Guaranteed to be NUL-terminated.
-    class TString : public _crtp_string<TString, TString, ZString, XString>
-    {
-        friend class SString;
-        FString _s;
-        size_t _o;
-    public:
-        TString() : _s(), _o() {}
-        TString(FString b, size_t i=0) : _s(std::move(b)), _o(i) {}
-        template<size_t n>
-        TString(char (&s)[n]) = delete;
-        template<size_t n>
-        TString(const char (&s)[n]) : _s(s), _o(0) {}
-        //template<class It>
-        //TString(It b, It e) : _s(b, e), _o(0) {}
-
-        iterator begin() const { return &_s.begin()[_o]; }
-        iterator end() const { return &*_s.end(); }
-        const FString *base() const { return &_s; }
-        const char *c_str() const { return &*begin(); }
-
-        TString oslice_t(size_t o) const;
-        SString oslice_h(size_t o) const;
-        TString orslice_t(size_t no) const;
-        SString orslice_h(size_t no) const;
-        TString oislice_t(iterator it) const;
-        SString oislice_h(iterator it) const;
-        SString olslice(size_t o, size_t l) const;
-        SString opslice(size_t b, size_t e) const;
-        SString oislice(iterator b, iterator e) const;
-
-        operator FString() const
-        { if (_o) return FString(begin(), end()); else return _s; }
-    };
-
-    /// An owning string that represents a arbitrary slice of an FString.
-    /// Not guaranteed to be NUL-terminated.
-    class SString : public _crtp_string<SString, SString, XString, XString>
-    {
-        FString _s;
-        size_t _b, _e;
-    public:
-        SString() : _s(), _b(), _e() {}
-        SString(FString f) : _s(std::move(f)), _b(), _e(_s.size()) {}
-        SString(TString t) : _s(t._s), _b(0), _e(_s.size()) {}
-        template<size_t n>
-        SString(char (&s)[n]) = delete;
-        template<size_t n>
-        SString(const char (&s)[n]) : _s(s), _b(0), _e(_s.size()) {}
-        //template<class It>
-        //SString(It b, It e) : _s(b, e), _b(0), _e(_s.size()) {}
-        SString(FString f, size_t b, size_t e) : _s(std::move(f)), _b(b), _e(e) {}
-
-        iterator begin() const { return &_s.begin()[_b]; }
-        iterator end() const { return &_s.begin()[_e]; }
-        const FString *base() const { return &_s; }
-
-        SString oslice_t(size_t o) const;
-        SString oslice_h(size_t o) const;
-        SString orslice_t(size_t no) const;
-        SString orslice_h(size_t no) const;
-        SString oislice_t(iterator it) const;
-        SString oislice_h(iterator it) const;
-        SString olslice(size_t o, size_t l) const;
-        SString opslice(size_t b, size_t e) const;
-        SString oislice(iterator b, iterator e) const;
-
-        operator FString() const
-        { if (_b == 0 && _e == _s.size()) return _s; else return FString(begin(), end()); }
-        operator TString() const
-        { if (_e == _s.size()) return TString(_s, _b); else return FString(begin(), end()); }
-    };
-
-    /// A non-owning string that is guaranteed to be NUL-terminated.
-    /// This should be only used as a parameter.
-    class ZString : public _crtp_string<ZString, FString, ZString, XString>
-    {
-        iterator _b, _e;
-        // optional
-        const FString *_base;
-    public:
-        enum { really_construct_from_a_pointer };
-        ZString() { *this = ZString(""); }
-        // no MString
-        ZString(const FString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        ZString(const TString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        ZString(const SString&) = delete;
-        // dangerous
-        ZString(const char *b, const char *e, const FString *base_) : _b(b), _e(e), _base(base_) {}
-        ZString(decltype(really_construct_from_a_pointer), const char *s, const FString *base_) : _b(s), _e(s + strlen(s)), _base(base_) {}
-        template<size_t n>
-        ZString(char (&s)[n]) = delete;
-        template<size_t n>
-        ZString(const char (&s)[n], const FString *base_=nullptr) : _b(s), _e(s + strlen(s)), _base(base_) {}
-
-        iterator begin() const { return _b; }
-        iterator end() const { return _e; }
-        const FString *base() const { return _base; }
-        const char *c_str() const { return &*begin(); }
-
-        ZString oslice_t(size_t o) const;
-        XString oslice_h(size_t o) const;
-        ZString orslice_t(size_t no) const;
-        XString orslice_h(size_t no) const;
-        ZString oislice_t(iterator it) const;
-        XString oislice_h(iterator it) const;
-        XString olslice(size_t o, size_t l) const;
-        XString opslice(size_t b, size_t e) const;
-        XString oislice(iterator b, iterator e) const;
-
-        operator FString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-        operator TString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-        operator SString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-    };
-
-    /// A non-owning string that is not guaranteed to be NUL-terminated.
-    /// This should be only used as a parameter.
-    class XString : public _crtp_string<XString, FString, XString, XString>
-    {
-        iterator _b, _e;
-        // optional
-        const FString *_base;
-    public:
-        // do I really want this?
-        XString() : _b(""), _e(_b), _base() {}
-        XString(std::nullptr_t) = delete;
-        // no MString
-        XString(const FString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        XString(const TString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        XString(const SString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        XString(const ZString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {}
-        template<size_t n>
-        XString(char (&s)[n]) = delete;
-        template<size_t n>
-        XString(const char (&s)[n]) : _b(s), _e(s + strlen(s)), _base(nullptr) {}
-        // mostly internal
-        XString(const char *b, const char *e, const FString *base_) : _b(b), _e(e), _base(base_) {}
-        XString(decltype(ZString::really_construct_from_a_pointer) e, const char *s, const FString *base_)
-        {
-            *this = ZString(e, s, base_);
-        }
-
-        iterator begin() const { return _b; }
-        iterator end() const { return _e; }
-        const FString *base() const { return _base; }
-
-        XString oslice_t(size_t o) const { return xslice_t(o); }
-        XString oslice_h(size_t o) const { return xslice_h(o); }
-        XString orslice_t(size_t no) const { return xrslice_t(no); }
-        XString orslice_h(size_t no) const { return xrslice_h(no); }
-        XString oislice_t(iterator it) const { return xislice_t(it); }
-        XString oislice_h(iterator it) const { return xislice_h(it); }
-        XString olslice(size_t o, size_t l) const { return xlslice(o, l); }
-        XString opslice(size_t b, size_t e) const { return xpslice(b, e); }
-        XString oislice(iterator b, iterator e) const { return xislice(b, e); }
-
-        operator FString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-        operator TString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-        operator SString() const
-        { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); }
-        operator ZString() const = delete;
-    };
-
-    template<uint8_t n>
-    class VString : public _crtp_string<VString<n>, VString<n>, ZString, XString>
-    {
-        char _data[n];
-        unsigned char _special;
-    public:
-        typedef typename _crtp_string<VString<n>, VString<n>, ZString, XString>::iterator iterator;
-        VString(XString x) : _data(), _special()
-        {
-            if (x.size() > n)
-                // we're hoping this doesn't happen
-                // hopefully there will be few enough users of this class
-                x = x.xslice_h(n);
-            char *e = std::copy(x.begin(), x.end(), std::begin(_data));
-            _special = std::end(_data) - e;
-            assert (_special == n - x.size()); // 0 when it needs to be
-        }
-        // poor man's delegated constructors
-        // needed for gcc 4.6 compatibility
-        VString(FString f)
-        {
-            *this = XString(f);
-        }
-        VString(TString t)
-        {
-            *this = XString(t);
-        }
-        VString(SString s)
-        {
-            *this = XString(s);
-        }
-        VString(ZString z)
-        {
-            *this = XString(z);
-        }
-        template<size_t m>
-        VString(char (&s)[m]) = delete;
-        template<size_t m>
-        VString(const char (&s)[m])
-        {
-            static_assert(m <= n + 1, "string would truncate");
-            *this = XString(s);
-        }
-        VString(decltype(ZString::really_construct_from_a_pointer) e, const char *s)
-        {
-            *this = XString(e, s, nullptr);
-        }
-        VString(char c)
-        {
-            *this = XString(&c, &c + 1, nullptr);
-        }
-        VString()
-        {
-            *this = XString();
-        }
-
-        // hopefully this is obvious
-        iterator begin() const { return std::begin(_data); }
-        iterator end() const { return std::end(_data) - _special; }
-        const FString *base() const { return nullptr; }
-        const char *c_str() const { return &*begin(); }
-
-        VString oslice_t(size_t o) const { return this->xslice_t(o); }
-        VString oslice_h(size_t o) const { return this->xslice_h(o); }
-        VString orslice_t(size_t no) const { return this->xrslice_t(no); }
-        VString orslice_h(size_t no) const { return this->xrslice_h(no); }
-        VString oislice_t(iterator it) const { return this->xislice_t(it); }
-        VString oislice_h(iterator it) const { return this->xislice_h(it); }
-        VString olslice(size_t o, size_t l) const { return this->xlslice(o, l); }
-        VString opslice(size_t b, size_t e) const { return this->xpslice(b, e); }
-        VString oislice(iterator b, iterator e) const { return this->xislice(b, e); }
-
-        operator FString() const { return FString(begin(), end()); }
-        operator TString() const { return FString(begin(), end()); }
-        operator SString() const { return FString(begin(), end()); }
-        operator ZString() const { return ZString(_data); }
-        operator XString() const { return XString(&*begin(), &*end(), nullptr); }
-
-        template<uint8_t m>
-        operator VString<m>() const
-        {
-            static_assert(m > n, "can only grow");
-            XString x = *this;
-            return VString<m>(XString(x));
-        }
-    };
-
-    // not really intended for public use
-    inline
-    int xstr_compare(XString l, XString r)
-    {
-        bool less = std::lexicographical_compare(
-                l.begin(), l.end(),
-                r.begin(), r.end());
-        bool greater = std::lexicographical_compare(
-                r.begin(), r.end(),
-                l.begin(), l.end());
-        return greater - less;
-    }
-
-
-    template<class L, class R>
-    class string_comparison_allowed
-    {
-        constexpr static bool l_is_vstring_exact = std::is_same<VString<sizeof(L) - 1>, L>::value;
-        constexpr static bool l_is_vstring_approx = std::is_base_of<VString<sizeof(L) - 1>, L>::value;
-        constexpr static bool r_is_vstring_exact = std::is_same<VString<sizeof(R) - 1>, R>::value;
-        constexpr static bool r_is_vstring_approx = std::is_base_of<VString<sizeof(R) - 1>, R>::value;
-
-        constexpr static bool l_is_restricted = l_is_vstring_approx && !l_is_vstring_exact;
-        constexpr static bool r_is_restricted = r_is_vstring_approx && !r_is_vstring_exact;
-    public:
-        constexpr static bool value = std::is_same<L, R>::value || (!l_is_restricted && !r_is_restricted);
-    };
-
-    struct _test : VString<1> {};
-    struct _test2 : VString<1> {};
-
-    static_assert(string_comparison_allowed<_test, _test>::value, "tt");
-    static_assert(string_comparison_allowed<VString<1>, VString<1>>::value, "vv");
-    static_assert(!string_comparison_allowed<_test, XString>::value, "tx");
-    static_assert(!string_comparison_allowed<_test, VString<1>>::value, "tv");
-    static_assert(!string_comparison_allowed<_test, _test2>::value, "t2");
-    static_assert(string_comparison_allowed<VString<1>, XString>::value, "vx");
-    static_assert(string_comparison_allowed<XString, XString>::value, "xx");
-    static_assert(string_comparison_allowed<XString, FString>::value, "xf");
-
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator == (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) == 0;
-    }
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator != (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) != 0;
-    }
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator < (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) < 0;
-    }
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator <= (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) <= 0;
-    }
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator > (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) > 0;
-    }
-    template<class L, class R, typename=typename std::enable_if<string_comparison_allowed<L, R>::value>::type>
-    auto operator >= (const L& l, const R& r) -> decltype((xstr_compare(l, r), true))
-    {
-        return xstr_compare(l, r) >= 0;
-    }
-
-    namespace detail
-    {
-        constexpr
-        bool is_print(char c)
-        {
-            return ' ' <= c && c <= '~';
-        }
-        constexpr
-        bool is_graph(char c)
-        {
-            return is_print(c) && c != ' ';
-        }
-        constexpr
-        bool is_lower(char c)
-        {
-            return 'a' <= c && c <= 'z';
-        }
-        constexpr
-        bool is_upper(char c)
-        {
-            return 'A' <= c && c <= 'Z';
-        }
-        constexpr
-        bool is_alpha(char c)
-        {
-            return is_lower(c) || is_upper(c);
-        }
-        constexpr
-        bool is_digit2(char c)
-        {
-            return '0' <= c && c <= '1';
-        }
-        constexpr
-        bool is_digit8(char c)
-        {
-            return '0' <= c && c <= '7';
-        }
-        constexpr
-        bool is_digit10(char c)
-        {
-            return '0' <= c && c <= '9';
-        }
-        constexpr
-        bool is_digit16(char c)
-        {
-            return ('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f');
-        }
-        constexpr
-        bool is_alnum(char c)
-        {
-            return is_alpha(c) || is_digit10(c);
-        }
-
-        constexpr
-        char to_lower(char c)
-        {
-            return is_upper(c) ? c | ' ' : c;
-        }
-        constexpr
-        char to_upper(char c)
-        {
-            return is_lower(c) ? c & ~' ' : c;
-        }
-    }
-
-    // sadness
-    typedef MString MS;
-    typedef FString FS;
-    typedef SString SS;
-    typedef TString TS;
-    typedef ZString ZS;
-    typedef XString XS;
-
-    // _crtp_string
-    template<class T, class O, class Z, class X>
-    Z _crtp_string<T, O, Z, X>::xslice_t(size_t o) const
-    { return Z(&begin()[o], &*end(), base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xslice_h(size_t o) const
-    { return X(&*begin(), &begin()[o], base()); }
-    template<class T, class O, class Z, class X>
-    Z _crtp_string<T, O, Z, X>::xrslice_t(size_t no) const
-    { return Z(&end()[-no], &*end(), base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xrslice_h(size_t no) const
-    { return X(&*begin(), &end()[-no], base()); }
-    template<class T, class O, class Z, class X>
-    Z _crtp_string<T, O, Z, X>::xislice_t(iterator it) const
-    { return Z(&*it, &*end(), base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xislice_h(iterator it) const
-    { return X(&*begin(), &*it, base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xlslice(size_t o, size_t l) const
-    { return X(&begin()[o], &begin()[o + l], base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xpslice(size_t b, size_t e) const
-    { return X(&begin()[b], &begin()[e], base()); }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::xislice(iterator b, iterator e) const
-    { return X(&*b, &*e, base()); }
-    template<class T, class O, class Z, class X>
-    Z _crtp_string<T, O, Z, X>::lstrip() const
-    {
-        Z z = _ref();
-        while (z.startswith(' '))
-            z = z.xslice_t(1);
-        return z;
-    }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::rstrip() const
-    {
-        X x = _ref();
-        while (x.endswith(' '))
-            x = x.xrslice_h(1);
-        return x;
-    }
-    template<class T, class O, class Z, class X>
-    X _crtp_string<T, O, Z, X>::strip() const
-    { return lstrip().rstrip(); }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::startswith(XS x) const
-    { return size() >= x.size() && xslice_h(x.size()) == x; }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::endswith(XS x) const
-    { return size() > x.size() && xrslice_t(x.size()) == x; }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::startswith(char c) const
-    { return size() && front() == c; }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::endswith(char c) const
-    { return size() && back() == c; }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::contains(char c) const
-    { return std::find(begin(), end(), c) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::contains_seq(XString s) const
-    { return std::search(begin(), end(), s.begin(), s.end()) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::contains_any(XString s) const
-    { return std::find_if(begin(), end(), [s](char c) { return s.contains(c); }) != end(); }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_print() const
-    { return std::find_if(begin(), end(), detail::is_print) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_print() const
-    { return std::find_if_not(begin(), end(), detail::is_print) == end(); }
-    template<class T, class O, class Z, class X>
-    O _crtp_string<T, O, Z, X>::to_print() const
-    {
-        if (is_print()) return _ref();
-        char buf[size()];
-        char *const b = buf;
-        char *const e = std::transform(begin(), end(), b, [](char c) { return detail::is_print(c) ? c : '_'; });
-        return XString(b, e, nullptr);
-    }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_graph() const
-    { return std::find_if(begin(), end(), detail::is_graph) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_graph() const
-    { return std::find_if_not(begin(), end(), detail::is_graph) == end(); }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_lower() const
-    { return std::find_if(begin(), end(), detail::is_lower) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_lower() const
-    { return std::find_if_not(begin(), end(), detail::is_lower) == end(); }
-    template<class T, class O, class Z, class X>
-    O _crtp_string<T, O, Z, X>::to_lower() const
-    {
-        if (!has_upper()) return _ref();
-        char buf[size()];
-        char *const b = buf;
-        char *const e = std::transform(begin(), end(), b, detail::to_lower);
-        return XString(b, e, nullptr);
-    }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_upper() const
-    { return std::find_if(begin(), end(), detail::is_upper) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_upper() const
-    { return std::find_if_not(begin(), end(), detail::is_upper) == end(); }
-    template<class T, class O, class Z, class X>
-    O _crtp_string<T, O, Z, X>::to_upper() const
-    {
-        if (!has_lower()) return _ref();
-        char buf[size()];
-        char *const b = buf;
-        char *const e = std::transform(begin(), end(), b, detail::to_upper);
-        return XString(b, e, nullptr);
-    }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_alpha() const
-    { return std::find_if(begin(), end(), detail::is_alpha) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_alpha() const
-    { return std::find_if_not(begin(), end(), detail::is_alpha) == end(); }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_digit2() const
-    { return std::find_if(begin(), end(), detail::is_digit2) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_digit2() const
-    { return std::find_if_not(begin(), end(), detail::is_digit2) == end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_digit8() const
-    { return std::find_if(begin(), end(), detail::is_digit8) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_digit8() const
-    { return std::find_if_not(begin(), end(), detail::is_digit8) == end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_digit10() const
-    { return std::find_if(begin(), end(), detail::is_digit10) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_digit10() const
-    { return std::find_if_not(begin(), end(), detail::is_digit10) == end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_digit16() const
-    { return std::find_if(begin(), end(), detail::is_digit16) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_digit16() const
-    { return std::find_if_not(begin(), end(), detail::is_digit16) == end(); }
-
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::has_alnum() const
-    { return std::find_if(begin(), end(), detail::is_alnum) != end(); }
-    template<class T, class O, class Z, class X>
-    bool _crtp_string<T, O, Z, X>::is_alnum() const
-    { return std::find_if_not(begin(), end(), detail::is_alnum) == end(); }
-
-    // MString
-    inline
-    MS& MS::operator += (XS x)
-    {
-        _hack.insert(_hack.end(), x.begin(), x.end());
-        return *this;
-    }
-
-    // FString
-    inline
-    TS FS::oslice_t(size_t o) const
-    { return TS(*this, o); }
-    inline
-    SS FS::oslice_h(size_t o) const
-    { return SS(*this, 0, o); }
-    inline
-    TS FS::orslice_t(size_t no) const
-    { return TS(*this, size() - no); }
-    inline
-    SS FS::orslice_h(size_t no) const
-    { return SS(*this, 0, size() - no); }
-    inline
-    TS FS::oislice_t(iterator it) const
-    { return TS(*this, it - begin()); }
-    inline
-    SS FS::oislice_h(iterator it) const
-    { return SS(*this, 0, it - begin()); }
-    inline
-    SS FS::olslice(size_t o, size_t l) const
-    { return SS(*this, o, o + l); }
-    inline
-    SS FS::opslice(size_t b, size_t e) const
-    { return SS(*this, b, e); }
-    inline
-    SS FS::oislice(iterator b, iterator e) const
-    { return SS(*this, b - begin(), e - begin()); }
-
-    // TString
-    inline
-    TS TS::oslice_t(size_t o) const
-    { return TS(_s, _o + o); }
-    inline
-    SS TS::oslice_h(size_t o) const
-    { return SS(_s, _o, _o + o); }
-    inline
-    TS TS::orslice_t(size_t no) const
-    { return TS(_s, _s.size() - no); }
-    inline
-    SS TS::orslice_h(size_t no) const
-    { return SS(_s, _o, _s.size() - no); }
-    inline
-    TS TS::oislice_t(iterator it) const
-    { return TS(_s, _o + it - begin()); }
-    inline
-    SS TS::oislice_h(iterator it) const
-    { return SS(_s, _o, _o + it - begin()); }
-    inline
-    SS TS::olslice(size_t o, size_t l) const
-    { return SS(_s, _o + o, _o + o + l); }
-    inline
-    SS TS::opslice(size_t b, size_t e) const
-    { return SS(_s, _o + b, _o + e); }
-    inline
-    SS TS::oislice(iterator b, iterator e) const
-    { return SS(_s, _o + b - begin(), _o + e - begin()); }
-
-    // SString
-    inline
-    SS SS::oslice_t(size_t o) const
-    { return SS(_s, _b + o, _e); }
-    inline
-    SS SS::oslice_h(size_t o) const
-    { return SS(_s, _b, _b + o); }
-    inline
-    SS SS::orslice_t(size_t no) const
-    { return SS(_s, _e - no, _e); }
-    inline
-    SS SS::orslice_h(size_t no) const
-    { return SS(_s, _b, _e - no); }
-    inline
-    SS SS::oislice_t(iterator it) const
-    { return SS(_s, _b + it - begin(), _e); }
-    inline
-    SS SS::oislice_h(iterator it) const
-    { return SS(_s, _b, _b + it - begin()); }
-    inline
-    SS SS::olslice(size_t o, size_t l) const
-    { return SS(_s, _b + o, _b + o + l); }
-    inline
-    SS SS::opslice(size_t b, size_t e) const
-    { return SS(_s, _b + b, _b + e); }
-    inline
-    SS SS::oislice(iterator b, iterator e) const
-    { return SS(_s, _b + b - begin(), _b + e - begin()); }
-
-    // ZString
-    inline
-    ZS ZS::oslice_t(size_t o) const
-    { return ZS(really_construct_from_a_pointer, &begin()[o], base()); }
-    inline
-    XS ZS::oslice_h(size_t o) const
-    { return XS(&*begin(), &begin()[o], base()); }
-    inline
-    ZS ZS::orslice_t(size_t no) const
-    { return ZS(really_construct_from_a_pointer, &end()[-no], base()); }
-    inline
-    XS ZS::orslice_h(size_t no) const
-    { return XS(&*begin(), &end()[-no], base()); }
-    inline
-    ZS ZS::oislice_t(iterator it) const
-    { return ZS(really_construct_from_a_pointer, &*it, base()); }
-    inline
-    XS ZS::oislice_h(iterator it) const
-    { return XS(&*begin(), &*it, base()); }
-    inline
-    XS ZS::olslice(size_t o, size_t l) const
-    { return XS(&begin()[o], &begin()[o + l], base()); }
-    inline
-    XS ZS::opslice(size_t b, size_t e) const
-    { return XS(&begin()[b], &begin()[e], base()); }
-    inline
-    XS ZS::oislice(iterator b, iterator e) const
-    { return XS(&*b, &*e, base()); }
-
-
-    // cxxstdio helpers
-    // I think the conversion will happen automatically. TODO test this.
-    // Nope, it doesn't, since there's a template
-    // Actually, it might now.
-    inline
-    const char *decay_for_printf(const FString& fs) { return fs.c_str(); }
-    inline
-    const char *decay_for_printf(const TString& ts) { return ts.c_str(); }
-    inline
-    const char *decay_for_printf(const ZString& zs) { return zs.c_str(); }
-    template<uint8_t n>
-    inline
-    const char *decay_for_printf(const VString<n>& vs) { return vs.c_str(); }
-
-    template<uint8_t len>
-    inline __attribute__((format(printf, 2, 0)))
-    int do_vprint(VString<len>& out, const char *fmt, va_list ap)
-    {
-        char buffer[len + 1];
-        vsnprintf(buffer, len + 1, fmt, ap);
-
-        out = const_(buffer);
-        return len;
-    }
-
-    inline __attribute__((format(printf, 2, 0)))
-    int do_vprint(FString& out, const char *fmt, va_list ap)
-    {
-        int len;
-        {
-            va_list ap2;
-            va_copy(ap2, ap);
-            len = vsnprintf(nullptr, 0, fmt, ap2);
-            va_end(ap2);
-        }
-        char buffer[len + 1];
-        vsnprintf(buffer, len + 1, fmt, ap);
-
-        out = FString(buffer, buffer + len);
-        return len;
-    }
-
-    inline __attribute__((format(scanf, 2, 0)))
-    int do_vscan(ZString in, const char *fmt, va_list ap)
-    {
-        return vsscanf(in.c_str(), fmt, ap);
-    }
-
-    class StringConverter
-    {
-        FString& out;
-        char *mid;
-    public:
-        StringConverter(FString& s)
-        : out(s), mid(nullptr)
-        {}
-        ~StringConverter()
-        {
-            if (mid)
-            {
-                out = ZString(ZString::really_construct_from_a_pointer, mid, nullptr);
-                free(mid);
-            }
-        }
-        char **operator &()
-        {
-            return &mid;
-        }
-    };
-
-    inline
-    StringConverter convert_for_scanf(FString& s)
-    {
-        return StringConverter(s);
-    }
-} // namespace strings
-
-// owning
-using strings::MString;
-using strings::FString;
-using strings::SString;
-using strings::TString;
-
-// non-owning
-using strings::ZString;
-using strings::XString;
-
-// semi-owning
-using strings::VString;
-
-#endif // TMWA_COMMON_STRINGS_HPP
diff --git a/src/common/strings2_test.cpp b/src/common/strings2_test.cpp
deleted file mode 100644
index fa4dc6f..0000000
--- a/src/common/strings2_test.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "strings.hpp"
-
-#include <gtest/gtest.h>
-
-TEST(StringTests, traits2)
-{
-    ZString print_non = "\t\e";
-    ZString print_mix = "n\t";
-    FString print_all = "n ";
-    EXPECT_FALSE(print_non.has_print());
-    EXPECT_TRUE(print_mix.has_print());
-    EXPECT_TRUE(print_all.has_print());
-    EXPECT_FALSE(print_non.is_print());
-    EXPECT_FALSE(print_mix.is_print());
-    EXPECT_TRUE(print_all.is_print());
-    EXPECT_EQ("__", print_non.to_print());
-    EXPECT_EQ("n_", print_mix.to_print());
-    EXPECT_EQ("n ", print_all.to_print());
-    EXPECT_EQ(print_all.begin(), print_all.to_print().begin());
-
-    ZString graph_non = " \e";
-    ZString graph_mix = "n ";
-    FString graph_all = "n.";
-    EXPECT_FALSE(graph_non.has_graph());
-    EXPECT_TRUE(graph_mix.has_graph());
-    EXPECT_TRUE(graph_all.has_graph());
-    EXPECT_FALSE(graph_non.is_graph());
-    EXPECT_FALSE(graph_mix.is_graph());
-    EXPECT_TRUE(graph_all.is_graph());
-
-    ZString lower_non = "0A";
-    ZString lower_mix = "Oa";
-    FString lower_all = "oa";
-    EXPECT_FALSE(lower_non.has_lower());
-    EXPECT_TRUE(lower_mix.has_lower());
-    EXPECT_TRUE(lower_all.has_lower());
-    EXPECT_FALSE(lower_non.is_lower());
-    EXPECT_FALSE(lower_mix.is_lower());
-    EXPECT_TRUE(lower_all.is_lower());
-    EXPECT_EQ("0a", lower_non.to_lower());
-    EXPECT_EQ("oa", lower_mix.to_lower());
-    EXPECT_EQ("oa", lower_all.to_lower());
-    EXPECT_EQ(lower_all.begin(), lower_all.to_lower().begin());
-
-    ZString upper_non = "0a";
-    ZString upper_mix = "oA";
-    FString upper_all = "OA";
-    EXPECT_FALSE(upper_non.has_upper());
-    EXPECT_TRUE(upper_mix.has_upper());
-    EXPECT_TRUE(upper_all.has_upper());
-    EXPECT_FALSE(upper_non.is_upper());
-    EXPECT_FALSE(upper_mix.is_upper());
-    EXPECT_TRUE(upper_all.is_upper());
-    EXPECT_EQ("0A", upper_non.to_upper());
-    EXPECT_EQ("OA", upper_mix.to_upper());
-    EXPECT_EQ("OA", upper_all.to_upper());
-    EXPECT_EQ(upper_all.begin(), upper_all.to_upper().begin());
-
-    ZString alpha_non = " 0";
-    ZString alpha_mix = "n ";
-    FString alpha_all = "nA";
-    EXPECT_FALSE(alpha_non.has_alpha());
-    EXPECT_TRUE(alpha_mix.has_alpha());
-    EXPECT_TRUE(alpha_all.has_alpha());
-    EXPECT_FALSE(alpha_non.is_alpha());
-    EXPECT_FALSE(alpha_mix.is_alpha());
-    EXPECT_TRUE(alpha_all.is_alpha());
-
-    ZString digit2_non = "a9";
-    ZString digit2_mix = "20";
-    FString digit2_all = "01";
-    EXPECT_FALSE(digit2_non.has_digit2());
-    EXPECT_TRUE(digit2_mix.has_digit2());
-    EXPECT_TRUE(digit2_all.has_digit2());
-    EXPECT_FALSE(digit2_non.is_digit2());
-    EXPECT_FALSE(digit2_mix.is_digit2());
-    EXPECT_TRUE(digit2_all.is_digit2());
-
-    ZString digit8_non = "a9";
-    ZString digit8_mix = "80";
-    FString digit8_all = "37";
-    EXPECT_FALSE(digit8_non.has_digit8());
-    EXPECT_TRUE(digit8_mix.has_digit8());
-    EXPECT_TRUE(digit8_all.has_digit8());
-    EXPECT_FALSE(digit8_non.is_digit8());
-    EXPECT_FALSE(digit8_mix.is_digit8());
-    EXPECT_TRUE(digit8_all.is_digit8());
-
-    ZString digit10_non = "az";
-    ZString digit10_mix = "a9";
-    FString digit10_all = "42";
-    EXPECT_FALSE(digit10_non.has_digit10());
-    EXPECT_TRUE(digit10_mix.has_digit10());
-    EXPECT_TRUE(digit10_all.has_digit10());
-    EXPECT_FALSE(digit10_non.is_digit10());
-    EXPECT_FALSE(digit10_mix.is_digit10());
-    EXPECT_TRUE(digit10_all.is_digit10());
-
-    ZString digit16_non = "gz";
-    ZString digit16_mix = "ao";
-    FString digit16_all = "be";
-    EXPECT_FALSE(digit16_non.has_digit16());
-    EXPECT_TRUE(digit16_mix.has_digit16());
-    EXPECT_TRUE(digit16_all.has_digit16());
-    EXPECT_FALSE(digit16_non.is_digit16());
-    EXPECT_FALSE(digit16_mix.is_digit16());
-    EXPECT_TRUE(digit16_all.is_digit16());
-
-    ZString alnum_non = " .";
-    ZString alnum_mix = "n ";
-    FString alnum_all = "n0";
-    EXPECT_FALSE(alnum_non.has_alnum());
-    EXPECT_TRUE(alnum_mix.has_alnum());
-    EXPECT_TRUE(alnum_all.has_alnum());
-    EXPECT_FALSE(alnum_non.is_alnum());
-    EXPECT_FALSE(alnum_mix.is_alnum());
-    EXPECT_TRUE(alnum_all.is_alnum());
-}
diff --git a/src/common/strings_test.cpp b/src/common/strings_test.cpp
deleted file mode 100644
index fa04f1c..0000000
--- a/src/common/strings_test.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-#include "strings.hpp"
-
-#include <algorithm>
-
-#include <gtest/gtest.h>
-
-template<typename T>
-class StringTest : public ::testing::Test
-{
-};
-TYPED_TEST_CASE_P(StringTest);
-
-TYPED_TEST_P(StringTest, basic)
-{
-    TypeParam hi("Hello");
-    EXPECT_EQ(5, hi.size());
-    EXPECT_EQ(hi, hi);
-    const char hi2[] = "Hello\0random garbage";
-    EXPECT_EQ(hi, hi2);
-    TypeParam hi0;
-    EXPECT_EQ(0, hi0.size());
-
-    __attribute__((unused))
-    const FString *base = hi.base();
-}
-
-TYPED_TEST_P(StringTest, order)
-{
-    TypeParam a;
-    TypeParam b("Hello");
-    TypeParam c("Hello,");
-    TypeParam d("World!");
-
-    // not using EXPECT_LT, etc. for better visibility
-
-    EXPECT_FALSE(a < a);
-    EXPECT_TRUE(a < b);
-    EXPECT_TRUE(a < c);
-    EXPECT_TRUE(a < d);
-    EXPECT_FALSE(b < a);
-    EXPECT_FALSE(b < b);
-    EXPECT_TRUE(b < c);
-    EXPECT_TRUE(b < d);
-    EXPECT_FALSE(c < a);
-    EXPECT_FALSE(c < b);
-    EXPECT_FALSE(c < c);
-    EXPECT_TRUE(c < d);
-    EXPECT_FALSE(d < a);
-    EXPECT_FALSE(d < b);
-    EXPECT_FALSE(d < c);
-    EXPECT_FALSE(d < d);
-
-    EXPECT_TRUE(a <= a);
-    EXPECT_TRUE(a <= b);
-    EXPECT_TRUE(a <= c);
-    EXPECT_TRUE(a <= d);
-    EXPECT_FALSE(b <= a);
-    EXPECT_TRUE(b <= b);
-    EXPECT_TRUE(b <= c);
-    EXPECT_TRUE(b <= d);
-    EXPECT_FALSE(c <= a);
-    EXPECT_FALSE(c <= b);
-    EXPECT_TRUE(c <= c);
-    EXPECT_TRUE(c <= d);
-    EXPECT_FALSE(d <= a);
-    EXPECT_FALSE(d <= b);
-    EXPECT_FALSE(d <= c);
-    EXPECT_TRUE(d <= d);
-
-    EXPECT_TRUE(a >= a);
-    EXPECT_FALSE(a >= b);
-    EXPECT_FALSE(a >= c);
-    EXPECT_FALSE(a >= d);
-    EXPECT_TRUE(b >= a);
-    EXPECT_TRUE(b >= b);
-    EXPECT_FALSE(b >= c);
-    EXPECT_FALSE(b >= d);
-    EXPECT_TRUE(c >= a);
-    EXPECT_TRUE(c >= b);
-    EXPECT_TRUE(c >= c);
-    EXPECT_FALSE(c >= d);
-    EXPECT_TRUE(d >= a);
-    EXPECT_TRUE(d >= b);
-    EXPECT_TRUE(d >= c);
-    EXPECT_TRUE(d >= d);
-
-    EXPECT_FALSE(a > a);
-    EXPECT_FALSE(a > b);
-    EXPECT_FALSE(a > c);
-    EXPECT_FALSE(a > d);
-    EXPECT_TRUE(b > a);
-    EXPECT_FALSE(b > b);
-    EXPECT_FALSE(b > c);
-    EXPECT_FALSE(b > d);
-    EXPECT_TRUE(c > a);
-    EXPECT_TRUE(c > b);
-    EXPECT_FALSE(c > c);
-    EXPECT_FALSE(c > d);
-    EXPECT_TRUE(d > a);
-    EXPECT_TRUE(d > b);
-    EXPECT_TRUE(d > c);
-    EXPECT_FALSE(d > d);
-
-    EXPECT_TRUE(a == a);
-    EXPECT_FALSE(a == b);
-    EXPECT_FALSE(a == c);
-    EXPECT_FALSE(a == d);
-    EXPECT_FALSE(b == a);
-    EXPECT_TRUE(b == b);
-    EXPECT_FALSE(b == c);
-    EXPECT_FALSE(b == d);
-    EXPECT_FALSE(c == a);
-    EXPECT_FALSE(c == b);
-    EXPECT_TRUE(c == c);
-    EXPECT_FALSE(c == d);
-    EXPECT_FALSE(d == a);
-    EXPECT_FALSE(d == b);
-    EXPECT_FALSE(d == c);
-    EXPECT_TRUE(d == d);
-
-    EXPECT_FALSE(a != a);
-    EXPECT_TRUE(a != b);
-    EXPECT_TRUE(a != c);
-    EXPECT_TRUE(a != d);
-    EXPECT_TRUE(b != a);
-    EXPECT_FALSE(b != b);
-    EXPECT_TRUE(b != c);
-    EXPECT_TRUE(b != d);
-    EXPECT_TRUE(c != a);
-    EXPECT_TRUE(c != b);
-    EXPECT_FALSE(c != c);
-    EXPECT_TRUE(c != d);
-    EXPECT_TRUE(d != a);
-    EXPECT_TRUE(d != b);
-    EXPECT_TRUE(d != c);
-    EXPECT_FALSE(d != d);
-}
-
-TYPED_TEST_P(StringTest, iterators)
-{
-    TypeParam hi("Hello");
-    EXPECT_EQ(hi.begin(), hi.begin());
-    EXPECT_NE(hi.begin(), hi.end());
-    EXPECT_EQ(5, std::distance(hi.begin(), hi.end()));
-    const char *hi2 = "Hello";
-    EXPECT_TRUE(std::equal(hi.begin(), hi.end(), hi2));
-}
-
-TYPED_TEST_P(StringTest, xslice)
-{
-    TypeParam hi("Hello, World!");
-    EXPECT_EQ(" World!", hi.xslice_t(6));
-    EXPECT_EQ("Hello,", hi.xslice_h(6));
-    EXPECT_EQ("World!", hi.xrslice_t(6));
-    EXPECT_EQ("Hello, ", hi.xrslice_h(6));
-    typename TypeParam::iterator it = std::find(hi.begin(), hi.end(), ' ');
-    EXPECT_EQ(" World!", hi.xislice_t(it));
-    EXPECT_EQ("Hello,", hi.xislice_h(it));
-    EXPECT_EQ("World", hi.xlslice(7, 5));
-    EXPECT_EQ("World", hi.xpslice(7, 12));
-    EXPECT_EQ("World", hi.xislice(hi.begin() + 7, hi.begin() + 12));
-    EXPECT_TRUE(hi.startswith("Hello"));
-    EXPECT_TRUE(hi.endswith("World!"));
-}
-
-TYPED_TEST_P(StringTest, oslice)
-{
-    TypeParam hi("Hello, World!");
-    EXPECT_EQ(" World!", hi.oslice_t(6));
-    EXPECT_EQ("Hello,", hi.oslice_h(6));
-    EXPECT_EQ("World!", hi.orslice_t(6));
-    EXPECT_EQ("Hello, ", hi.orslice_h(6));
-    typename TypeParam::iterator it = std::find(hi.begin(), hi.end(), ' ');
-    EXPECT_EQ(" World!", hi.oislice_t(it));
-    EXPECT_EQ("Hello,", hi.oislice_h(it));
-    EXPECT_EQ("World", hi.olslice(7, 5));
-    EXPECT_EQ("World", hi.opslice(7, 12));
-    EXPECT_EQ("World", hi.oislice(hi.begin() + 7, hi.begin() + 12));
-}
-
-TYPED_TEST_P(StringTest, convert)
-{
-    constexpr bool is_zstring = std::is_same<TypeParam, ZString>::value;
-    typedef typename std::conditional<is_zstring, TString, SString>::type Sstring;
-    typedef typename std::conditional<is_zstring, ZString, XString>::type Xstring;
-    FString f = "f";
-    TString t = "t";
-    Sstring s = "s";
-    ZString z = "z";
-    Xstring x = "x";
-    VString<255> v = "v";
-    const char l[] = "l";
-    VString<5> hi = "hello";
-
-    TypeParam f2 = f;
-    TypeParam t2 = t;
-    TypeParam s2 = s;
-    TypeParam z2 = z;
-    TypeParam x2 = x;
-    TypeParam v2 = v;
-    TypeParam l2 = l;
-    TypeParam hi2 = hi;
-
-    EXPECT_EQ(f, f2);
-    EXPECT_EQ(t, t2);
-    EXPECT_EQ(s, s2);
-    EXPECT_EQ(z, z2);
-    EXPECT_EQ(x, x2);
-    EXPECT_EQ(v, v2);
-    EXPECT_EQ(l, l2);
-    EXPECT_EQ(hi, hi2);
-
-    TypeParam f3, t3, s3, z3, x3, v3, l3, hi3;
-    f3 = f;
-    t3 = t;
-    s3 = s;
-    z3 = z;
-    x3 = x;
-    v3 = v;
-    l3 = l;
-    hi3 = hi;
-
-    EXPECT_EQ(f, f3);
-    EXPECT_EQ(t, t3);
-    EXPECT_EQ(s, s3);
-    EXPECT_EQ(z, z3);
-    EXPECT_EQ(x, x3);
-    EXPECT_EQ(v, v3);
-    EXPECT_EQ(l, l3);
-    EXPECT_EQ(hi, hi3);
-}
-
-REGISTER_TYPED_TEST_CASE_P(StringTest,
-        basic, order, iterators, xslice, oslice, convert);
-
-typedef ::testing::Types<
-    FString, TString, SString, ZString, XString, VString<255>
-> MostStringTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(StringStuff, StringTest, MostStringTypes);
-
-TEST(VStringTest, basic)
-{
-    VString<5> hi = "Hello";
-    EXPECT_EQ(5, hi.size());
-    EXPECT_EQ(hi, hi);
-    // truncation
-    VString<5> hi2(ZString::really_construct_from_a_pointer, "Hello, world!");
-    EXPECT_EQ(5, hi2.size());
-    EXPECT_EQ(hi, hi2);
-    // short
-    hi = "hi";
-    EXPECT_EQ(2, hi.size());
-    VString<5> hi0;
-    EXPECT_EQ(0, hi0.size());
-}
-
-template<typename T>
-class NulStringTest : public ::testing::Test
-{
-};
-TYPED_TEST_CASE_P(NulStringTest);
-
-TYPED_TEST_P(NulStringTest, basic)
-{
-    TypeParam hi("hello");
-    EXPECT_EQ(hi.size(), strlen(hi.c_str()));
-    EXPECT_STREQ("hello", hi.c_str());
-}
-
-REGISTER_TYPED_TEST_CASE_P(NulStringTest,
-        basic);
-
-typedef ::testing::Types<
-    FString, TString, ZString, VString<255>
-> NulStringTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(NulStringStuff, NulStringTest, NulStringTypes);
diff --git a/src/common/timer.cpp b/src/common/timer.cpp
index c00f06d..17c6d80 100644
--- a/src/common/timer.cpp
+++ b/src/common/timer.cpp
@@ -8,6 +8,8 @@
 
 #include <queue>
 
+#include "../strings/zstring.hpp"
+
 #include "cxxstdio.hpp"
 #include "utils.hpp"
 
diff --git a/src/common/timer.hpp b/src/common/timer.hpp
index b9c9588..de867ab 100644
--- a/src/common/timer.hpp
+++ b/src/common/timer.hpp
@@ -5,7 +5,7 @@
 
 # include "sanity.hpp"
 
-# include "strings.hpp"
+# include "../strings/fwd.hpp"
 
 // updated automatically when using milli_clock::now()
 // which is done only by core.cpp
diff --git a/src/common/utils.cpp b/src/common/utils.cpp
index 9ab470b..21440a4 100644
--- a/src/common/utils.cpp
+++ b/src/common/utils.cpp
@@ -5,6 +5,12 @@
 
 #include <algorithm>
 
+#include "../strings/fstring.hpp"
+#include "../strings/tstring.hpp"
+#include "../strings/sstring.hpp"
+#include "../strings/zstring.hpp"
+#include "../strings/xstring.hpp"
+
 #include "cxxstdio.hpp"
 #include "extract.hpp"
 
@@ -42,7 +48,7 @@ bool e_mail_check(XString email)
 // Return numerical value of a switch configuration
 // on/off, english, français, deutsch, español
 //-------------------------------------------------
-int config_switch (ZString str)
+int config_switch(ZString str)
 {
     if (str == "true" || str == "on" || str == "yes"
         || str == "oui" || str == "ja"
diff --git a/src/common/utils.hpp b/src/common/utils.hpp
index 4f6190a..66b1654 100644
--- a/src/common/utils.hpp
+++ b/src/common/utils.hpp
@@ -8,9 +8,11 @@
 
 #include <type_traits>
 
+#include "../strings/fwd.hpp"
+#include "../strings/vstring.hpp"
+
 #include "const_array.hpp"
 #include "operators.hpp"
-#include "strings.hpp"
 #include "utils2.hpp"
 
 template<class T>