Split string header into pieces

28 files changed, 2734 insertions, 0 deletions

diff --git a/src/strings/all.hpp b/src/strings/all.hpp
new file mode 100644
index 0000000..333cb4b
--- /dev/null
+++ b/src/strings/all.hpp
@@ -0,0 +1,31 @@
+#ifndef TMWA_STRINGS_ALL_HPP
+#define TMWA_STRINGS_ALL_HPP
+//    strings/all.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 "base.hpp"
+#include "mstring.hpp"
+#include "fstring.hpp"
+#include "tstring.hpp"
+#include "sstring.hpp"
+#include "zstring.hpp"
+#include "xstring.hpp"
+#include "vstring.hpp"
+
+#endif // TMWA_STRINGS_ALL_HPP
diff --git a/src/strings/base.hpp b/src/strings/base.hpp
new file mode 100644
index 0000000..2ea303f
--- /dev/null
+++ b/src/strings/base.hpp
@@ -0,0 +1,205 @@
+#ifndef TMWA_STRINGS_BASE_HPP
+#define TMWA_STRINGS_BASE_HPP
+//    strings/base.cls.hpp - CRTP base for string implementations.
+//
+//    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 "fwd.hpp"
+#include "pair.hpp"
+
+#include <iterator>
+
+// 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
+{
+    // 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 P>
+    class _crtp_string
+    {
+        typedef typename P::TailSlice Z;
+        typedef typename P::FullSlice X;
+    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;
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+    public:
+        size_t size() const;
+        reverse_iterator rbegin() const;
+        reverse_iterator rend() const;
+        explicit
+        operator bool() const;
+        bool operator !() const;
+        operator P() const;
+
+        // 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;
+        char front() const;
+        char back() const;
+        const char *data();
+
+        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(XPair x) const;
+        bool endswith(XPair x) const;
+        bool startswith(char c) const;
+        bool endswith(char c) const;
+
+        bool contains(char c) const;
+        bool contains_seq(XPair s) const;
+        bool contains_any(XPair 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
+    };
+
+    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);
+    };
+
+    // not really intended for public use
+    int pair_compare(XPair l, XPair r);
+
+    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((pair_compare(l, r), true));
+    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((pair_compare(l, r), true));
+    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((pair_compare(l, r), true));
+    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((pair_compare(l, r), true));
+    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((pair_compare(l, r), true));
+    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((pair_compare(l, r), true));
+
+    // sadness
+    typedef MString MS;
+    typedef FString FS;
+    typedef TString TS;
+    typedef SString SS;
+    typedef ZString ZS;
+    typedef XString XS;
+} // namespace strings
+
+#include "base.tcc"
+
+#endif // TMWA_STRINGS_BASE_HPP
diff --git a/src/strings/base.tcc b/src/strings/base.tcc
new file mode 100644
index 0000000..cde277f
--- /dev/null
+++ b/src/strings/base.tcc
@@ -0,0 +1,442 @@
+//    strings/base.tcc - Inline functions for strings/base.hpp
+//
+//    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 <algorithm>
+
+#include "pair.hpp"
+
+namespace strings
+{
+    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;
+        }
+    } // namespace detail
+
+    template<class T, class O, class P>
+    const T& _crtp_string<T, O, P>::_ref() const
+    {
+        return static_cast<const T&>(*this);
+    }
+    template<class T, class O, class P>
+    typename _crtp_string<T, O, P>::iterator _crtp_string<T, O, P>::begin() const
+    {
+        return _ref().begin();
+    }
+    template<class T, class O, class P>
+    typename _crtp_string<T, O, P>::iterator _crtp_string<T, O, P>::end() const
+    {
+        return _ref().end();
+    }
+    template<class T, class O, class P>
+    const FString *_crtp_string<T, O, P>::base() const
+    {
+        return _ref().base();
+    }
+    template<class T, class O, class P>
+    size_t _crtp_string<T, O, P>::size() const
+    {
+        return end() - begin();
+    }
+    template<class T, class O, class P>
+    typename _crtp_string<T, O, P>::reverse_iterator _crtp_string<T, O, P>::rbegin() const
+    {
+        return reverse_iterator(end());
+    }
+    template<class T, class O, class P>
+    typename _crtp_string<T, O, P>::reverse_iterator _crtp_string<T, O, P>::rend() const
+    {
+        return reverse_iterator(begin());
+    }
+    template<class T, class O, class P>
+    _crtp_string<T, O, P>::operator bool() const
+    {
+        return size();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::operator !() const
+    {
+        return !size();
+    }
+    template<class T, class O, class P>
+    _crtp_string<T, O, P>::operator P() const
+    {
+        return {&*begin(), &*end()};
+    }
+
+    template<class T, class O, class P>
+    __attribute__((deprecated))
+    char _crtp_string<T, O, P>::operator[](size_t i) const
+    {
+        return begin()[i];
+    }
+    template<class T, class O, class P>
+    char _crtp_string<T, O, P>::front() const
+    {
+        return *begin();
+    }
+    template<class T, class O, class P>
+    char _crtp_string<T, O, P>::back() const
+    {
+        return end()[-1];
+    }
+    template<class T, class O, class P>
+    const char *_crtp_string<T, O, P>::data()
+    {
+        return &*begin();
+    }
+
+    template<class T, class O, class P>
+    typename P::TailSlice _crtp_string<T, O, P>::xslice_t(size_t o) const
+    {
+        return typename P::TailSlice(&begin()[o], &*end(), base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xslice_h(size_t o) const
+    {
+        return typename P::FullSlice(&*begin(), &begin()[o], base());
+    }
+    template<class T, class O, class P>
+    typename P::TailSlice _crtp_string<T, O, P>::xrslice_t(size_t no) const
+    {
+        return typename P::TailSlice(&end()[-no], &*end(), base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xrslice_h(size_t no) const
+    {
+        return typename P::FullSlice(&*begin(), &end()[-no], base());
+    }
+    template<class T, class O, class P>
+    typename P::TailSlice _crtp_string<T, O, P>::xislice_t(iterator it) const
+    {
+        return typename P::TailSlice(&*it, &*end(), base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xislice_h(iterator it) const
+    {
+        return typename P::FullSlice(&*begin(), &*it, base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xlslice(size_t o, size_t l) const
+    {
+        return typename P::FullSlice(&begin()[o], &begin()[o + l], base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xpslice(size_t b, size_t e) const
+    {
+        return typename P::FullSlice(&begin()[b], &begin()[e], base());
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::xislice(iterator b, iterator e) const
+    {
+        return typename P::FullSlice(&*b, &*e, base());
+    }
+    template<class T, class O, class P>
+    typename P::TailSlice _crtp_string<T, O, P>::lstrip() const
+    {
+        typename P::TailSlice z = _ref();
+        while (z.startswith(' '))
+            z = z.xslice_t(1);
+        return z;
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::rstrip() const
+    {
+        typename P::FullSlice x = _ref();
+        while (x.endswith(' '))
+            x = x.xrslice_h(1);
+        return x;
+    }
+    template<class T, class O, class P>
+    typename P::FullSlice _crtp_string<T, O, P>::strip() const
+    {
+        return lstrip().rstrip();
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::startswith(XPair x) const
+    {
+        return size() >= x.size() && pair_compare(xslice_h(x.size()), x) == 0;
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::endswith(XPair x) const
+    {
+        return size() > x.size() && pair_compare(xrslice_t(x.size()), x) == 0;
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::startswith(char c) const
+    {
+        return size() && front() == c;
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::endswith(char c) const
+    {
+        return size() && back() == c;
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::contains(char c) const
+    {
+        return std::find(begin(), end(), c) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::contains_seq(XPair s) const
+    {
+        return std::search(begin(), end(), s.begin(), s.end()) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::contains_any(XPair s) const
+    {
+        return std::find_if(s.begin(), s.end(), [this](char c) { return this->contains(c); }) != end();
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_print() const
+    {
+        return std::find_if(begin(), end(), detail::is_print) != end(); }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_print() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_print) == end(); }
+    template<class T, class O, class P>
+    O _crtp_string<T, O, P>::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 XPair(b, e);
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_graph() const
+    {
+        return std::find_if(begin(), end(), detail::is_graph) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_graph() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_graph) == end();
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_lower() const
+    {
+        return std::find_if(begin(), end(), detail::is_lower) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_lower() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_lower) == end();
+    }
+    template<class T, class O, class P>
+    O _crtp_string<T, O, P>::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 XPair(b, e);
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_upper() const
+    {
+        return std::find_if(begin(), end(), detail::is_upper) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_upper() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_upper) == end();
+    }
+    template<class T, class O, class P>
+    O _crtp_string<T, O, P>::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 XPair(b, e);
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_alpha() const
+    {
+        return std::find_if(begin(), end(), detail::is_alpha) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_alpha() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_alpha) == end();
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_digit2() const
+    {
+        return std::find_if(begin(), end(), detail::is_digit2) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_digit2() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_digit2) == end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_digit8() const
+    {
+        return std::find_if(begin(), end(), detail::is_digit8) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_digit8() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_digit8) == end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_digit10() const
+    {
+        return std::find_if(begin(), end(), detail::is_digit10) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_digit10() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_digit10) == end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_digit16() const
+    {
+        return std::find_if(begin(), end(), detail::is_digit16) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_digit16() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_digit16) == end();
+    }
+
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::has_alnum() const
+    {
+        return std::find_if(begin(), end(), detail::is_alnum) != end();
+    }
+    template<class T, class O, class P>
+    bool _crtp_string<T, O, P>::is_alnum() const
+    {
+        return std::find_if_not(begin(), end(), detail::is_alnum) == end();
+    }
+
+    // not really intended for public use
+    inline
+    int pair_compare(XPair l, XPair 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, typename>
+    auto operator == (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) == 0;
+    }
+    template<class L, class R, typename>
+    auto operator != (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) != 0;
+    }
+    template<class L, class R, typename>
+    auto operator < (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) < 0;
+    }
+    template<class L, class R, typename>
+    auto operator <= (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) <= 0;
+    }
+    template<class L, class R, typename>
+    auto operator > (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) > 0;
+    }
+    template<class L, class R, typename>
+    auto operator >= (const L& l, const R& r) -> decltype((pair_compare(l, r), true))
+    {
+        return pair_compare(l, r) >= 0;
+    }
+} // namespace strings
diff --git a/src/strings/base_test.cpp b/src/strings/base_test.cpp
new file mode 100644
index 0000000..836ea4b
--- /dev/null
+++ b/src/strings/base_test.cpp
@@ -0,0 +1,18 @@
+#include "base.hpp"
+#include "vstring.hpp"
+#include "xstring.hpp"
+#include "fstring.hpp"
+
+using namespace strings;
+
+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");
diff --git a/src/strings/fstring.cpp b/src/strings/fstring.cpp
new file mode 100644
index 0000000..4b20852
--- /dev/null
+++ b/src/strings/fstring.cpp
@@ -0,0 +1,150 @@
+#include "fstring.hpp"
+//    strings/fstring.cpp - Functions for fstring.hpp
+//
+//    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 "mstring.hpp"
+#include "tstring.hpp"
+#include "sstring.hpp"
+#include "zstring.hpp"
+#include "xstring.hpp"
+#include "vstring.hpp"
+
+namespace strings
+{
+    FString::FString()
+    {
+        const char *sadness = "";
+        _assign(sadness, sadness);
+    }
+
+    FString::FString(const MString& s)
+    {
+        _assign(s.begin(), s.end());
+    }
+
+    FString::FString(XPair p)
+    {
+        _assign(p.begin(), p.end());
+    }
+
+    FString::FString(const TString& t)
+    {
+        *this = XString(t);
+    }
+    FString::FString(const SString& s)
+    {
+        *this = XString(s);
+    }
+    FString::FString(ZString z)
+    {
+        *this = XString(z);
+    }
+    FString::FString(XString x)
+    {
+        const FString *f = x.base();
+        const char *xb = &*x.begin();
+        const char *xe = &*x.end();
+        const char *fb = f ? &*f->begin() : nullptr;
+        const char *fe = f ? &*f->end() : nullptr;
+        if (f && xb == fb && xe == fe)
+            *this = *f;
+        else
+            _assign(x.begin(), x.end());
+    }
+
+    FString::iterator FString::begin() const
+    {
+        return &_hack2->begin()[0];
+    }
+    FString::iterator FString::end() const
+    {
+        return &_hack2->end()[-1];
+    }
+    const FString *FString::base() const
+    {
+        return this;
+    }
+    const char *FString::c_str() const
+    {
+        return &*begin();
+    }
+
+    TS FS::oslice_t(size_t o) const
+    { return TS(*this, o); }
+    SS FS::oslice_h(size_t o) const
+    { return SS(*this, 0, o); }
+    TS FS::orslice_t(size_t no) const
+    { return TS(*this, size() - no); }
+    SS FS::orslice_h(size_t no) const
+    { return SS(*this, 0, size() - no); }
+    TS FS::oislice_t(iterator it) const
+    { return TS(*this, it - begin()); }
+    SS FS::oislice_h(iterator it) const
+    { return SS(*this, 0, it - begin()); }
+    SS FS::olslice(size_t o, size_t l) const
+    { return SS(*this, o, o + l); }
+    SS FS::opslice(size_t b, size_t e) const
+    { return SS(*this, b, e); }
+    SS FS::oislice(iterator b, iterator e) const
+    { return SS(*this, b - begin(), e - begin()); }
+
+    const char *decay_for_printf(const FString& fs)
+    {
+        return fs.c_str();
+    }
+
+    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;
+    }
+
+    StringConverter::StringConverter(FString& s)
+    : out(s), mid(nullptr)
+    {}
+
+    StringConverter::~StringConverter()
+    {
+        if (mid)
+        {
+            out = ZString(really_construct_from_a_pointer, mid, nullptr);
+            free(mid);
+        }
+    }
+
+    char **StringConverter::operator &()
+    {
+        return &mid;
+    }
+
+    StringConverter convert_for_scanf(FString& s)
+    {
+        return StringConverter(s);
+    }
+} // namespace strings
diff --git a/src/strings/fstring.hpp b/src/strings/fstring.hpp
new file mode 100644
index 0000000..0f4f09d
--- /dev/null
+++ b/src/strings/fstring.hpp
@@ -0,0 +1,104 @@
+#ifndef TMWA_STRINGS_FSTRING_HPP
+#define TMWA_STRINGS_FSTRING_HPP
+//    strings/fstring.hpp - An owned, reference-counted immutable string.
+//
+//    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 <cstdarg>
+#include <cstring>
+
+#include <memory>
+#include <vector>
+
+#include "base.hpp"
+
+namespace strings
+{
+    /// An owning string that has reached its final contents.
+    /// The storage is NUL-terminated
+    /// TODO reimplement without std::shared_ptr
+    class FString : public _crtp_string<FString, FString, ZPair>
+    {
+        std::shared_ptr<std::vector<char>> _hack2;
+
+        template<class It>
+        void _assign(It b, It e);
+    public:
+        FString();
+
+        explicit FString(const MString& s);
+
+        template<size_t n>
+        FString(char (&s)[n]) = delete;
+
+        template<size_t n>
+        FString(const char (&s)[n]);
+
+        template<class It>
+        FString(It b, It e);
+
+        FString(XPair p);
+        //FString(const FString&)
+        FString(const TString&);
+        FString(const SString&);
+        FString(ZString);
+        FString(XString);
+        template<uint8_t n>
+        FString(const VString<n>& v);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+        const char *c_str() const;
+
+        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;
+    };
+
+    // 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.
+    const char *decay_for_printf(const FString& fs);
+
+    __attribute__((format(printf, 2, 0)))
+    int do_vprint(FString& out, const char *fmt, va_list ap);
+
+    class StringConverter
+    {
+        FString& out;
+        char *mid;
+    public:
+        StringConverter(FString& s);
+        ~StringConverter();
+        char **operator &();
+    };
+
+    StringConverter convert_for_scanf(FString& s);
+} // namespace strings
+
+#include "fstring.tcc"
+
+#endif // TMWA_STRINGS_FSTRING_HPP
diff --git a/src/strings/fstring.tcc b/src/strings/fstring.tcc
new file mode 100644
index 0000000..388aef1
--- /dev/null
+++ b/src/strings/fstring.tcc
@@ -0,0 +1,62 @@
+//    strings/fstring.tcc - Inline functions for fstring.hpp
+//
+//    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/>.
+
+namespace strings
+{
+    template<class It>
+    void FString::_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();
+            return;
+        }
+        size_t diff = std::distance(b, e);
+        _hack2 = std::make_shared<std::vector<char>>(diff + 1, '\0');
+        std::copy(b, e, _hack2->begin());
+    }
+
+    template<size_t n>
+    FString::FString(const char (&s)[n])
+    {
+        _assign(s, s + strlen(s));
+    }
+
+    template<class It>
+    FString::FString(It b, It e)
+    {
+        _assign(b, e);
+    }
+
+    template<uint8_t n>
+    FString::FString(const VString<n>& v)
+    {
+        _assign(v.begin(), v.end());
+    }
+} // namespace strings
diff --git a/src/strings/fwd.hpp b/src/strings/fwd.hpp
new file mode 100644
index 0000000..41abbbb
--- /dev/null
+++ b/src/strings/fwd.hpp
@@ -0,0 +1,58 @@
+#ifndef TMWA_STRINGS_FWD_HPP
+#define TMWA_STRINGS_FWD_HPP
+//    strings/fwd.hpp - Forward declarations for all the string classes.
+//
+//    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 "../common/sanity.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;
+
+    // refactor this into a function?
+    enum _type_that_just_has_a_name_to_fix_linkage
+    { really_construct_from_a_pointer };
+} // namespace strings
+
+using strings::MString;
+using strings::FString;
+using strings::TString;
+using strings::SString;
+
+using strings::ZString;
+using strings::XString;
+
+using strings::VString;
+
+#endif // TMWA_STRINGS_FWD_HPP
diff --git a/src/strings/mstring.cpp b/src/strings/mstring.cpp
new file mode 100644
index 0000000..0d496a5
--- /dev/null
+++ b/src/strings/mstring.cpp
@@ -0,0 +1,100 @@
+#include "mstring.hpp"
+//    strings/mstring.cpp - Functions for mstring.hpp
+//
+//    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 "xstring.hpp"
+
+namespace strings
+{
+    MString::iterator MString::begin()
+    {
+        return _hack.begin();
+    }
+    MString::iterator MString::end()
+    {
+        return _hack.end();
+    }
+    MString::const_iterator MString::begin() const
+    {
+        return _hack.begin();
+    }
+    MString::const_iterator MString::end() const
+    {
+        return _hack.end();
+    }
+    MString::reverse_iterator MString::rbegin()
+    {
+        return reverse_iterator(end());
+    }
+    MString::reverse_iterator MString::rend()
+    {
+        return reverse_iterator(begin());
+    }
+    MString::const_reverse_iterator MString::rbegin() const
+    {
+        return const_reverse_iterator(end());
+    }
+    MString::const_reverse_iterator MString::rend() const
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    size_t MString::size() const
+    {
+        return _hack.size();
+    }
+    MString::operator bool() const
+    {
+        return size();
+    }
+    bool MString::operator !() const
+    {
+        return !size();
+    }
+
+    MString& MString::operator += (MString rhs)
+    {
+        _hack.insert(_hack.end(), rhs.begin(), rhs.end());
+        return *this;
+    }
+    MString& MString::operator += (char c)
+    {
+        _hack.push_back(c);
+        return *this;
+    }
+    MString& MString::operator += (XString x)
+    {
+        _hack.insert(_hack.end(), x.begin(), x.end());
+        return *this;
+    }
+
+    void MString::pop_back(size_t n)
+    {
+        while (n--)
+            _hack.pop_back();
+    }
+    char& MString::front()
+    {
+        return _hack.front();
+    }
+    char& MString::back()
+    {
+        return _hack.back();
+    }
+} // namespace strings
diff --git a/src/strings/mstring.hpp b/src/strings/mstring.hpp
new file mode 100644
index 0000000..9658601
--- /dev/null
+++ b/src/strings/mstring.hpp
@@ -0,0 +1,66 @@
+#ifndef TMWA_STRINGS_MSTRING_HPP
+#define TMWA_STRINGS_MSTRING_HPP
+//    strings/mstring.hpp - A mutable string.
+//
+//    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 <deque>
+
+#include "base.hpp"
+
+namespace strings
+{
+    /// 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::deque.
+    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();
+        iterator end();
+        const_iterator begin() const;
+        const_iterator end() const;
+        reverse_iterator rbegin();
+        reverse_iterator rend();
+        const_reverse_iterator rbegin() const;
+        const_reverse_iterator rend() const;
+
+        size_t size() const;
+        explicit
+        operator bool() const;
+        bool operator !() const;
+
+        MString& operator += (MString rhs);
+        MString& operator += (char c);
+        MString& operator += (XString xs);
+
+        void pop_back(size_t n=1);
+        char& front();
+        char& back();
+    };
+} // namespace strings
+
+#endif // TMWA_STRINGS_MSTRING_HPP
diff --git a/src/strings/pair.hpp b/src/strings/pair.hpp
new file mode 100644
index 0000000..88422be
--- /dev/null
+++ b/src/strings/pair.hpp
@@ -0,0 +1,73 @@
+#ifndef TMWA_STRINGS_PAIR_HPP
+#define TMWA_STRINGS_PAIR_HPP
+//    strings/pair.hpp - Internal contiguous range.
+//
+//    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 "../common/sanity.hpp"
+
+#include <cstring>
+
+#include "fwd.hpp"
+
+namespace strings
+{
+    // TODO instead typedef ranges::Contiguous<const char>
+    // or whatever it becomes once it exists.
+    // const_array is just a hack, as evidenced by the fact
+    // that it's not really const.
+    class XPair
+    {
+        const char *_begin;
+        const char *_end;
+    public:
+        typedef XString TailSlice;
+        typedef XString FullSlice;
+
+        XPair(const char *b, const char *e)
+        : _begin(b), _end(e)
+        {}
+        template<size_t n>
+        XPair(char (&arr)[n]) = delete;
+        template<size_t n>
+        XPair(const char (&arr)[n])
+        : _begin(arr), _end(arr + strlen(arr))
+        {}
+
+        const char *begin() const { return _begin; }
+        const char *end() const { return _end; }
+        size_t size() { return end() - begin(); }
+    };
+    struct ZPair : XPair
+    {
+        typedef ZString TailSlice;
+        typedef XString FullSlice;
+
+        ZPair(const char *b, const char *e)
+        : XPair(b, e)
+        {}
+        template<size_t n>
+        ZPair(char (&arr)[n]) = delete;
+        template<size_t n>
+        ZPair(const char (&arr)[n])
+        : XPair(arr)
+        {}
+    };
+} // namespace strings
+
+#endif // TMWA_STRINGS_PAIR_HPP
diff --git a/src/strings/sstring.cpp b/src/strings/sstring.cpp
new file mode 100644
index 0000000..bcbcb58
--- /dev/null
+++ b/src/strings/sstring.cpp
@@ -0,0 +1,91 @@
+#include "sstring.hpp"
+//    strings/sstring.cpp - Functions for sstring.hpp
+//
+//    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 "tstring.hpp"
+#include "zstring.hpp"
+#include "xstring.hpp"
+
+namespace strings
+{
+    SString::SString()
+    : _s(), _b(), _e()
+    {}
+    SString::SString(FString f)
+    : _s(std::move(f)), _b(), _e(_s.size())
+    {}
+    SString::SString(TString t)
+    : _s(t._s), _b(0), _e(_s.size())
+    {}
+    SString::SString(const ZString& z)
+    {
+        *this = XString(z);
+    }
+    SString::SString(const XString& x)
+    {
+        const FString *f = x.base();
+        const char *xb = &*x.begin();
+        const char *xe = &*x.end();
+        const char *fb = f ? &*f->begin() : nullptr;
+        //const char *fe = f ? &*f->end() : nullptr;
+        if (f)
+            *this = SString(*f, xb - fb, xe - fb);
+        else
+            *this = FString(x);
+    }
+
+    SString::SString(FString f, size_t b, size_t e)
+    : _s(std::move(f)), _b(b), _e(e)
+    {}
+    SString::SString(XPair p)
+    : _s(p), _b(0), _e(p.size())
+    {}
+
+    SString::iterator SString::begin() const
+    {
+        return &_s.begin()[_b];
+    }
+    SString::iterator SString::end() const
+    {
+        return &_s.begin()[_e];
+    }
+    const FString *SString::base() const
+    {
+        return &_s;
+    }
+
+    SS SS::oslice_t(size_t o) const
+    { return SS(_s, _b + o, _e); }
+    SS SS::oslice_h(size_t o) const
+    { return SS(_s, _b, _b + o); }
+    SS SS::orslice_t(size_t no) const
+    { return SS(_s, _e - no, _e); }
+    SS SS::orslice_h(size_t no) const
+    { return SS(_s, _b, _e - no); }
+    SS SS::oislice_t(iterator it) const
+    { return SS(_s, _b + it - begin(), _e); }
+    SS SS::oislice_h(iterator it) const
+    { return SS(_s, _b, _b + it - begin()); }
+    SS SS::olslice(size_t o, size_t l) const
+    { return SS(_s, _b + o, _b + o + l); }
+    SS SS::opslice(size_t b, size_t e) const
+    { return SS(_s, _b + b, _b + e); }
+    SS SS::oislice(iterator b, iterator e) const
+    { return SS(_s, _b + b - begin(), _b + e - begin()); }
+} // namespace strings
diff --git a/src/strings/sstring.hpp b/src/strings/sstring.hpp
new file mode 100644
index 0000000..6f55f9a
--- /dev/null
+++ b/src/strings/sstring.hpp
@@ -0,0 +1,69 @@
+#ifndef TMWA_STRINGS_SSTRING_HPP
+#define TMWA_STRINGS_SSTRING_HPP
+//    strings/sstring.hpp - A full slice of an FString.
+//
+//    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 "base.hpp"
+#include "fstring.hpp"
+
+namespace strings
+{
+    /// An owning string that represents a arbitrary slice of an FString.
+    /// Not guaranteed to be NUL-terminated.
+    class SString : public _crtp_string<SString, SString, XPair>
+    {
+        FString _s;
+        size_t _b, _e;
+    public:
+        SString();
+        SString(FString f);
+        SString(TString t);
+        //SString(const SString&);
+        SString(const ZString&);
+        SString(const XString&);
+        template<uint8_t n>
+        SString(const VString<n>& v);
+        template<size_t n>
+        SString(char (&s)[n]) = delete;
+        template<size_t n>
+        SString(const char (&s)[n]);
+        //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);
+        SString(XPair p);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+
+        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;
+    };
+} // namespace strings
+
+#include "sstring.tcc"
+
+#endif // TMWA_STRINGS_SSTRING_HPP
diff --git a/src/strings/sstring.tcc b/src/strings/sstring.tcc
new file mode 100644
index 0000000..4be33dd
--- /dev/null
+++ b/src/strings/sstring.tcc
@@ -0,0 +1,33 @@
+//    strings/sstring.tcc - Inline functions for fstring.hpp
+//
+//    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 "vstring.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    SString::SString(const VString<n>& v)
+    : _s(v), _b(0), _e(_s.size())
+    {}
+
+    template<size_t n>
+    SString::SString(const char (&s)[n])
+    : _s(s), _b(0), _e(_s.size())
+    {}
+} // namespace strings
diff --git a/src/strings/strings2_test.cpp b/src/strings/strings2_test.cpp
new file mode 100644
index 0000000..3f8662a
--- /dev/null
+++ b/src/strings/strings2_test.cpp
@@ -0,0 +1,118 @@
+#include "all.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/strings/strings_test.cpp b/src/strings/strings_test.cpp
new file mode 100644
index 0000000..b7a7d39
--- /dev/null
+++ b/src/strings/strings_test.cpp
@@ -0,0 +1,294 @@
+#include "all.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);
+
+    TypeParam f4(f);
+    TypeParam t4(t);
+    TypeParam s4(s);
+    TypeParam z4(z);
+    TypeParam x4(x);
+    TypeParam v4(v);
+    TypeParam l4(l);
+    TypeParam hi4(hi);
+
+    EXPECT_EQ(f, f4);
+    EXPECT_EQ(t, t4);
+    EXPECT_EQ(s, s4);
+    EXPECT_EQ(z, z4);
+    EXPECT_EQ(x, x4);
+    EXPECT_EQ(v, v4);
+    EXPECT_EQ(l, l4);
+    EXPECT_EQ(hi, hi4);
+}
+
+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(strings::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/strings/tstring.cpp b/src/strings/tstring.cpp
new file mode 100644
index 0000000..9decc61
--- /dev/null
+++ b/src/strings/tstring.cpp
@@ -0,0 +1,98 @@
+#include "tstring.hpp"
+//    strings/tstring.cpp - Functions for tstring.hpp
+//
+//    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 "sstring.hpp"
+#include "zstring.hpp"
+#include "xstring.hpp"
+
+namespace strings
+{
+    TString::TString()
+    : _s(), _o()
+    {}
+    TString::TString(FString b, size_t i)
+    : _s(std::move(b)), _o(i)
+    {}
+    TString::TString(const SString& s)
+    {
+        *this = XString(s);
+    }
+    TString::TString(const ZString& z)
+    {
+        *this = XString(z);
+    }
+    TString::TString(const XString& x)
+    {
+        const FString *f = x.base();
+        const char *xb = &*x.begin();
+        const char *xe = &*x.end();
+        const char *fb = f ? &*f->begin() : nullptr;
+        const char *fe = f ? &*f->end() : nullptr;
+        if (f && xe == fe)
+            *this = TString(*f, xb - fb);
+        else
+            *this = FString(x);
+    }
+
+    TString::TString(XPair p)
+    : _s(p), _o(0)
+    {}
+
+    TString::iterator TString::begin() const
+    {
+        return &_s.begin()[_o];
+    }
+    TString::iterator TString::end() const
+    {
+        return &*_s.end();
+    }
+    const FString *TString::base() const
+    {
+        return &_s;
+    }
+    const char *TString::c_str() const
+    {
+        return &*begin();
+    }
+
+    TS TS::oslice_t(size_t o) const
+    { return TS(_s, _o + o); }
+    SS TS::oslice_h(size_t o) const
+    { return SS(_s, _o, _o + o); }
+    TS TS::orslice_t(size_t no) const
+    { return TS(_s, _s.size() - no); }
+    SS TS::orslice_h(size_t no) const
+    { return SS(_s, _o, _s.size() - no); }
+    TS TS::oislice_t(iterator it) const
+    { return TS(_s, _o + it - begin()); }
+    SS TS::oislice_h(iterator it) const
+    { return SS(_s, _o, _o + it - begin()); }
+    SS TS::olslice(size_t o, size_t l) const
+    { return SS(_s, _o + o, _o + o + l); }
+    SS TS::opslice(size_t b, size_t e) const
+    { return SS(_s, _o + b, _o + e); }
+    SS TS::oislice(iterator b, iterator e) const
+    { return SS(_s, _o + b - begin(), _o + e - begin()); }
+
+    const char *decay_for_printf(const TString& ts)
+    {
+        return ts.c_str();
+    }
+} // namespace strings
diff --git a/src/strings/tstring.hpp b/src/strings/tstring.hpp
new file mode 100644
index 0000000..63f3b7a
--- /dev/null
+++ b/src/strings/tstring.hpp
@@ -0,0 +1,76 @@
+#ifndef TMWA_STRINGS_TSTRING_HPP
+#define TMWA_STRINGS_TSTRING_HPP
+//    strings/tstring.hpp - A tail slice of a string.
+//
+//    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 "base.hpp"
+#include "fstring.hpp"
+
+namespace strings
+{
+    /// An owning string that represents a tail slice of an FString.
+    /// Guaranteed to be NUL-terminated.
+    class TString : public _crtp_string<TString, TString, ZPair>
+    {
+        friend class SString;
+        FString _s;
+        size_t _o;
+    public:
+        TString();
+        TString(FString b, size_t i=0);
+        //TString(const TString&)
+        TString(const SString&);
+        TString(const ZString&);
+        TString(const XString&);
+        template<uint8_t n>
+        TString(const VString<n>& v);
+        template<size_t n>
+        TString(char (&s)[n]) = delete;
+        template<size_t n>
+        TString(const char (&s)[n]);
+        //template<class It>
+        //TString(It b, It e) : _s(b, e), _o(0) {}
+        TString(XPair p);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+        const char *c_str() const;
+
+        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;
+    };
+
+    // 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.
+    const char *decay_for_printf(const TString& ts);
+} // namespace strings
+
+#include "tstring.tcc"
+
+#endif // TMWA_STRINGS_TSTRING_HPP
diff --git a/src/strings/tstring.tcc b/src/strings/tstring.tcc
new file mode 100644
index 0000000..4eba13f
--- /dev/null
+++ b/src/strings/tstring.tcc
@@ -0,0 +1,32 @@
+//    strings/tstring.tcc - Inline functions for tstring.hpp
+//
+//    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 "vstring.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    TString::TString(const VString<n>& v)
+    : _s(v), _o(0)
+    {}
+    template<size_t n>
+    TString::TString(const char (&s)[n])
+    : _s(s), _o(0)
+    {}
+} // namespace strings
diff --git a/src/strings/vstring.cpp b/src/strings/vstring.cpp
new file mode 100644
index 0000000..6a0416a
--- /dev/null
+++ b/src/strings/vstring.cpp
@@ -0,0 +1,23 @@
+#include "vstring.hpp"
+//    strings/vstring.cpp - Functions for vstring.hpp
+//
+//    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/>.
+
+namespace strings
+{
+} // namespace strings
diff --git a/src/strings/vstring.hpp b/src/strings/vstring.hpp
new file mode 100644
index 0000000..527c2b4
--- /dev/null
+++ b/src/strings/vstring.hpp
@@ -0,0 +1,79 @@
+#ifndef TMWA_STRINGS_VSTRING_HPP
+#define TMWA_STRINGS_VSTRING_HPP
+//    strings/vstring.hpp - A small string that stores its own value.
+//
+//    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 "base.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    class VString : public _crtp_string<VString<n>, VString<n>, ZPair>
+    {
+        char _data[n];
+        unsigned char _special;
+    public:
+        typedef typename _crtp_string<VString<n>, VString<n>, ZPair>::iterator iterator;
+        VString(XString x);
+        VString(FString f);
+        VString(TString t);
+        VString(SString s);
+        VString(ZString z);
+        template<uint8_t m>
+        VString(VString<m> v);
+        template<size_t m>
+        VString(char (&s)[m]) = delete;
+        template<size_t m>
+        VString(const char (&s)[m]);
+        VString(decltype(really_construct_from_a_pointer) e, const char *s);
+        VString(char c);
+        VString();
+        VString(XPair p);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+        const char *c_str() const;
+
+        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); }
+    };
+
+    // 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.
+    template<uint8_t n>
+    const char *decay_for_printf(const VString<n>& vs);
+
+    template<uint8_t len>
+    __attribute__((format(printf, 2, 0)))
+    int do_vprint(VString<len>& out, const char *fmt, va_list ap);
+} // namespace strings
+
+#include "vstring.tcc"
+
+#endif // TMWA_STRINGS_VSTRING_HPP
diff --git a/src/strings/vstring.tcc b/src/strings/vstring.tcc
new file mode 100644
index 0000000..674b21d
--- /dev/null
+++ b/src/strings/vstring.tcc
@@ -0,0 +1,143 @@
+//    strings/vstring.tcc - Inline functions for vstring.hpp
+//
+//    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 <cassert>
+
+#include "../common/utils2.hpp"
+
+#include "fstring.hpp"
+#include "tstring.hpp"
+#include "sstring.hpp"
+#include "zstring.hpp"
+#include "xstring.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    VString<n>::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
+    template<uint8_t n>
+    VString<n>::VString(FString f)
+    {
+        *this = XString(f);
+    }
+    template<uint8_t n>
+    VString<n>::VString(TString t)
+    {
+        *this = XString(t);
+    }
+    template<uint8_t n>
+    VString<n>::VString(SString s)
+    {
+        *this = XString(s);
+    }
+    template<uint8_t n>
+    VString<n>::VString(ZString z)
+    {
+        *this = XString(z);
+    }
+    template<uint8_t n>
+    template<uint8_t m>
+    VString<n>::VString(VString<m> v)
+    {
+        static_assert(m < n, "can only grow");
+        *this = XString(v);
+    }
+    template<uint8_t n>
+    template<size_t m>
+    VString<n>::VString(const char (&s)[m])
+    {
+        static_assert(m <= n + 1, "string would truncate");
+        *this = XString(s);
+    }
+    template<uint8_t n>
+    VString<n>::VString(decltype(really_construct_from_a_pointer) e, const char *s)
+    {
+        *this = XString(e, s, nullptr);
+    }
+    template<uint8_t n>
+    VString<n>::VString(char c)
+    {
+        *this = XString(&c, &c + 1, nullptr);
+    }
+    template<uint8_t n>
+    VString<n>::VString()
+    {
+        *this = XString();
+    }
+    template<uint8_t n>
+    VString<n>::VString(XPair p)
+    {
+        *this = XString(p);
+    }
+
+    // hopefully this is obvious
+    template<uint8_t n>
+    typename VString<n>::iterator VString<n>::begin() const
+    {
+        return std::begin(_data);
+    }
+    template<uint8_t n>
+    typename VString<n>::iterator VString<n>::end() const
+    {
+        return std::end(_data) - _special;
+    }
+    template<uint8_t n>
+    const FString *VString<n>::base() const
+    {
+        return nullptr;
+    }
+    template<uint8_t n>
+    const char *VString<n>::c_str() const
+    {
+        return &*begin();
+    }
+
+    // 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.
+    template<uint8_t n>
+    inline
+    const char *decay_for_printf(const VString<n>& vs)
+    {
+        return vs.c_str();
+    }
+
+    template<uint8_t len>
+    inline
+    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;
+    }
+} // namespace strings
diff --git a/src/strings/xstring.cpp b/src/strings/xstring.cpp
new file mode 100644
index 0000000..107217b
--- /dev/null
+++ b/src/strings/xstring.cpp
@@ -0,0 +1,62 @@
+#include "xstring.hpp"
+//    strings/xstring.cpp - Functions for xstring.hpp
+//
+//    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/>.
+
+namespace strings
+{
+    XString::XString()
+    : _b(""), _e(_b), _base()
+    {}
+    XString::XString(const FString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+    XString::XString(const TString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+    XString::XString(const SString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+    XString::XString(const ZString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+
+    XString::XString(const char *b, const char *e, const FString *base_)
+    : _b(b), _e(e), _base(base_)
+    {}
+    XString::XString(decltype(really_construct_from_a_pointer) e, const char *s, const FString *base_)
+    {
+        *this = ZString(e, s, base_);
+    }
+    XString::XString(XPair p)
+    : _b(p.begin()), _e(p.end()), _base(nullptr)
+    {}
+
+    XString::iterator XString::begin() const
+    {
+        return _b;
+    }
+    XString::iterator XString::end() const
+    {
+        return _e;
+    }
+    const FString *XString::base() const
+    {
+        return _base;
+    }
+} // namespace strings
diff --git a/src/strings/xstring.hpp b/src/strings/xstring.hpp
new file mode 100644
index 0000000..448d0ba
--- /dev/null
+++ b/src/strings/xstring.hpp
@@ -0,0 +1,71 @@
+#ifndef TMWA_STRINGS_XSTRING_HPP
+#define TMWA_STRINGS_XSTRING_HPP
+//    strings/xstring.hpp - A full borrowed slice.
+//
+//    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 "base.hpp"
+
+namespace strings
+{
+    /// 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, XPair>
+    {
+        iterator _b, _e;
+        // optional
+        const FString *_base;
+    public:
+        // do I really want this?
+        XString();
+        XString(std::nullptr_t) = delete;
+        // no MString
+        XString(const FString& s);
+        XString(const TString& s);
+        XString(const SString& s);
+        XString(const ZString& s);
+        template<uint8_t n>
+        XString(const VString<n>& s);
+        template<size_t n>
+        XString(char (&s)[n]) = delete;
+        template<size_t n>
+        XString(const char (&s)[n]);
+        // mostly internal
+        XString(const char *b, const char *e, const FString *base_);
+        XString(decltype(really_construct_from_a_pointer) e, const char *s, const FString *base_);
+        XString(XPair p);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+
+        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); }
+    };
+} // namespace strings
+
+#include "xstring.tcc"
+
+#endif // TMWA_STRINGS_XSTRING_HPP
diff --git a/src/strings/xstring.tcc b/src/strings/xstring.tcc
new file mode 100644
index 0000000..aee87f8
--- /dev/null
+++ b/src/strings/xstring.tcc
@@ -0,0 +1,32 @@
+//    strings/xstring.tcc - Inline functions for xstring.hpp
+//
+//    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 "vstring.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    XString::XString(const VString<n>& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(nullptr)
+    {}
+    template<size_t n>
+    XString::XString(const char (&s)[n])
+    : _b(s), _e(s + strlen(s)), _base(nullptr)
+    {}
+} // namespace strings
diff --git a/src/strings/zstring.cpp b/src/strings/zstring.cpp
new file mode 100644
index 0000000..3b86b0e
--- /dev/null
+++ b/src/strings/zstring.cpp
@@ -0,0 +1,88 @@
+#include "zstring.hpp"
+//    strings/zstring.cpp - Functions for zstring.hpp
+//
+//    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 "xstring.hpp"
+
+namespace strings
+{
+    ZString::ZString()
+    {
+        *this = ZString("");
+    }
+    ZString::ZString(const FString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+    ZString::ZString(const TString& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(s.base())
+    {}
+    ZString::ZString(const char *b, const char *e, const FString *base_)
+    : _b(b), _e(e), _base(base_)
+    {}
+    ZString::ZString(decltype(really_construct_from_a_pointer), const char *s, const FString *base_)
+    : _b(s), _e(s + strlen(s)), _base(base_)
+    {}
+
+    ZString::iterator ZString::begin() const
+    {
+        return _b;
+    }
+    ZString::iterator ZString::end() const
+    {
+        return _e;
+    }
+    const FString *ZString::base() const
+    {
+        return _base;
+    }
+    const char *ZString::c_str() const
+    {
+        return &*begin();
+    }
+
+    ZS ZS::oslice_t(size_t o) const
+    { return ZS(really_construct_from_a_pointer, &begin()[o], base()); }
+    XS ZS::oslice_h(size_t o) const
+    { return XS(&*begin(), &begin()[o], base()); }
+    ZS ZS::orslice_t(size_t no) const
+    { return ZS(really_construct_from_a_pointer, &end()[-no], base()); }
+    XS ZS::orslice_h(size_t no) const
+    { return XS(&*begin(), &end()[-no], base()); }
+    ZS ZS::oislice_t(iterator it) const
+    { return ZS(really_construct_from_a_pointer, &*it, base()); }
+    XS ZS::oislice_h(iterator it) const
+    { return XS(&*begin(), &*it, base()); }
+    XS ZS::olslice(size_t o, size_t l) const
+    { return XS(&begin()[o], &begin()[o + l], base()); }
+    XS ZS::opslice(size_t b, size_t e) const
+    { return XS(&begin()[b], &begin()[e], base()); }
+    XS ZS::oislice(iterator b, iterator e) const
+    { return XS(&*b, &*e, base()); }
+
+    const char *decay_for_printf(const ZString& zs)
+    {
+        return zs.c_str();
+    }
+
+    __attribute__((format(scanf, 2, 0)))
+    int do_vscan(ZString in, const char *fmt, va_list ap)
+    {
+        return vsscanf(in.c_str(), fmt, ap);
+    }
+} // namespace strings
diff --git a/src/strings/zstring.hpp b/src/strings/zstring.hpp
new file mode 100644
index 0000000..1b7e7fc
--- /dev/null
+++ b/src/strings/zstring.hpp
@@ -0,0 +1,81 @@
+#ifndef TMWA_STRINGS_ZSTRING_HPP
+#define TMWA_STRINGS_ZSTRING_HPP
+//    strings/zstring.hpp - A borrowed tail slice of a string.
+//
+//    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 <cstring>
+
+#include "base.hpp"
+
+namespace strings
+{
+    /// 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, ZPair>
+    {
+        iterator _b, _e;
+        // optional
+        const FString *_base;
+    public:
+        ZString();
+        // no MString
+        ZString(const FString& s);
+        ZString(const TString& s);
+        ZString(const SString&) = delete;
+        //ZString(ZString);
+        ZString(const XString&) = delete;
+        template<uint8_t n>
+        ZString(const VString<n>& s);
+        // dangerous
+        ZString(const char *b, const char *e, const FString *base_);
+        ZString(decltype(really_construct_from_a_pointer), const char *s, const FString *base_);
+        template<size_t n>
+        ZString(char (&s)[n]) = delete;
+        template<size_t n>
+        ZString(const char (&s)[n], const FString *base_=nullptr);
+
+        iterator begin() const;
+        iterator end() const;
+        const FString *base() const;
+        const char *c_str() const;
+
+        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;
+    };
+
+    // 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.
+    const char *decay_for_printf(const ZString& zs);
+
+    __attribute__((format(scanf, 2, 0)))
+    int do_vscan(ZString in, const char *fmt, va_list ap);
+} // namespace strings
+
+#include "zstring.tcc"
+
+#endif // TMWA_STRINGS_ZSTRING_HPP
diff --git a/src/strings/zstring.tcc b/src/strings/zstring.tcc
new file mode 100644
index 0000000..1065b7c
--- /dev/null
+++ b/src/strings/zstring.tcc
@@ -0,0 +1,35 @@
+//    strings/zstring.tcc - Inline functions for zstring.hpp
+//
+//    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 <cstring>
+
+#include "vstring.hpp"
+
+namespace strings
+{
+    template<uint8_t n>
+    ZString::ZString(const VString<n>& s)
+    : _b(&*s.begin()), _e(&*s.end()), _base(nullptr)
+    {}
+
+    template<size_t n>
+    ZString::ZString(const char (&s)[n], const FString *base_)
+    : _b(s), _e(s + strlen(s)), _base(base_)
+    {}
+} // namespace strings