XSteam/3rdparty/ValveFileVDF/vdf_parser.hpp

// MIT License
//
// Copyright(c) 2016 Matthias Moeller
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#ifndef __TYTI_STEAM_VDF_PARSER_H__
#define __TYTI_STEAM_VDF_PARSER_H__

#include <algorithm>
#include <fstream>
#include <functional>
#include <iterator>
#include <map>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#include <exception>
#include <system_error>

// for wstring support
#include <cwchar>
#include <string>

// internal
#include <stack>

// VS < 2015 has only partial C++11 support
#if defined(_MSC_VER) && _MSC_VER < 1900
#ifndef CONSTEXPR
#define CONSTEXPR
#endif

#ifndef NOEXCEPT
#define NOEXCEPT
#endif
#else
#ifndef CONSTEXPR
#define CONSTEXPR constexpr
#define TYTI_UNDEF_CONSTEXPR
#endif

#ifndef NOEXCEPT
#define NOEXCEPT noexcept
#define TYTI_UNDEF_NOEXCEPT
#endif

#endif

namespace tyti
{
namespace vdf
{
namespace detail
{
///////////////////////////////////////////////////////////////////////////
//  Helper functions selecting the right encoding (char/wchar_T)
///////////////////////////////////////////////////////////////////////////

template <typename T> struct literal_macro_help
{
    static CONSTEXPR const char *result(const char *c, const wchar_t *) NOEXCEPT
    {
        return c;
    }
    static CONSTEXPR char result(const char c, const wchar_t) NOEXCEPT
    {
        return c;
    }
};

template <> struct literal_macro_help<wchar_t>
{
    static CONSTEXPR const wchar_t *result(const char *,
                                           const wchar_t *wc) NOEXCEPT
    {
        return wc;
    }
    static CONSTEXPR wchar_t result(const char, const wchar_t wc) NOEXCEPT
    {
        return wc;
    }
};
#define TYTI_L(type, text)                                                     \
    vdf::detail::literal_macro_help<type>::result(text, L##text)

inline std::string string_converter(const std::string &w) NOEXCEPT { return w; }

inline std::string string_converter(const std::wstring &w) NOEXCEPT
{
    std::mbstate_t state = std::mbstate_t();
    auto wstr = w.data();
// unsafe: ignores any error handling
// and disables warning that wcsrtombs_s should be used
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4996)
#endif
    std::size_t len = 1 + std::wcsrtombs(nullptr, &wstr, 0, &state);
    std::string mbstr(len, '\0');
    std::wcsrtombs(&mbstr[0], &wstr, mbstr.size(), &state);
#ifdef WIN32
#pragma warning(pop)
#endif
    return mbstr;
}

///////////////////////////////////////////////////////////////////////////
//  Writer helper functions
///////////////////////////////////////////////////////////////////////////

template <typename charT> class tabs
{
    const size_t t;

  public:
    explicit CONSTEXPR tabs(size_t i) NOEXCEPT : t(i) {}
    std::basic_string<charT> print() const
    {
        return std::basic_string<charT>(t, TYTI_L(charT, '\t'));
    }
    inline CONSTEXPR tabs operator+(size_t i) const NOEXCEPT
    {
        return tabs(t + i);
    }
};

template <typename oStreamT>
oStreamT &operator<<(oStreamT &s, const tabs<typename oStreamT::char_type> t)
{
    s << t.print();
    return s;
}
} // end namespace detail

///////////////////////////////////////////////////////////////////////////
//  Interface
///////////////////////////////////////////////////////////////////////////

/// custom objects and their corresponding write functions

/// basic object node. Every object has a name and can contains attributes saved
/// as key_value pairs or childrens
template <typename CharT> struct basic_object
{
    typedef CharT char_type;
    std::basic_string<char_type> name;
    std::unordered_map<std::basic_string<char_type>,
                       std::basic_string<char_type>>
        attribs;
    std::unordered_map<std::basic_string<char_type>,
                       std::shared_ptr<basic_object<char_type>>>
        childs;

    void add_attribute(std::basic_string<char_type> key,
                       std::basic_string<char_type> value)
    {
        attribs.emplace(std::move(key), std::move(value));
    }
    void add_child(std::unique_ptr<basic_object<char_type>> child)
    {
        std::shared_ptr<basic_object<char_type>> obj{child.release()};
        childs.emplace(obj->name, obj);
    }
    void set_name(std::basic_string<char_type> n) { name = std::move(n); }
};

template <typename CharT> struct basic_multikey_object
{
    typedef CharT char_type;
    std::basic_string<char_type> name;
    std::unordered_multimap<std::basic_string<char_type>,
                            std::basic_string<char_type>>
        attribs;
    std::unordered_multimap<std::basic_string<char_type>,
                            std::shared_ptr<basic_multikey_object<char_type>>>
        childs;

    void add_attribute(std::basic_string<char_type> key,
                       std::basic_string<char_type> value)
    {
        attribs.emplace(std::move(key), std::move(value));
    }
    void add_child(std::unique_ptr<basic_multikey_object<char_type>> child)
    {
        std::shared_ptr<basic_multikey_object<char_type>> obj{child.release()};
        childs.emplace(obj->name, obj);
    }
    void set_name(std::basic_string<char_type> n) { name = std::move(n); }
};

typedef basic_object<char> object;
typedef basic_object<wchar_t> wobject;
typedef basic_multikey_object<char> multikey_object;
typedef basic_multikey_object<wchar_t> wmultikey_object;

struct Options
{
    bool strip_escape_symbols;
    bool ignore_all_platform_conditionals;
    bool ignore_includes;

    Options()
        : strip_escape_symbols(true), ignore_all_platform_conditionals(false),
          ignore_includes(false)
    {
    }
};

// forward decls
// forward decl
template <typename OutputT, typename iStreamT>
OutputT read(iStreamT &inStream, const Options &opt = Options{});

/** \brief writes given object tree in vdf format to given stream.
Output is prettyfied, using tabs
*/
template <typename oStreamT, typename T>
void write(oStreamT &s, const T &r,
           const detail::tabs<typename oStreamT::char_type> tab =
               detail::tabs<typename oStreamT::char_type>(0))
{
    typedef typename oStreamT::char_type charT;
    using namespace detail;
    s << tab << TYTI_L(charT, '"') << r.name << TYTI_L(charT, "\"\n") << tab
      << TYTI_L(charT, "{\n");
    for (const auto &i : r.attribs)
        s << tab + 1 << TYTI_L(charT, '"') << i.first
          << TYTI_L(charT, "\"\t\t\"") << i.second << TYTI_L(charT, "\"\n");
    for (const auto &i : r.childs)
        if (i.second)
            write(s, *i.second, tab + 1);
    s << tab << TYTI_L(charT, "}\n");
}

namespace detail
{
template <typename iStreamT>
std::basic_string<typename iStreamT::char_type> read_file(iStreamT &inStream)
{
    // cache the file
    typedef typename iStreamT::char_type charT;
    std::basic_string<charT> str;
    inStream.seekg(0, std::ios::end);
    str.resize(static_cast<size_t>(inStream.tellg()));
    if (str.empty())
        return str;

    inStream.seekg(0, std::ios::beg);
    inStream.read(&str[0], static_cast<std::streamsize>(str.size()));
    return str;
}

/** \brief Read VDF formatted sequences defined by the range [first, last).
If the file is mailformatted, parser will try to read it until it can.
@param first            begin iterator
@param end              end iterator
@param exclude_files    list of files which cant be included anymore.
                        prevents circular includes

can thow:
        - "std::runtime_error" if a parsing error occured
        - "std::bad_alloc" if not enough memory coup be allocated
*/
template <typename OutputT, typename IterT>
std::vector<std::unique_ptr<OutputT>> read_internal(
    IterT first, const IterT last,
    std::unordered_set<
        std::basic_string<typename std::iterator_traits<IterT>::value_type>>
        &exclude_files,
    const Options &opt)
{
    static_assert(std::is_default_constructible<OutputT>::value,
                  "Output Type must be default constructible (provide "
                  "constructor without arguments)");
    static_assert(std::is_move_constructible<OutputT>::value,
                  "Output Type must be move constructible");

    typedef typename std::iterator_traits<IterT>::value_type charT;

    const std::basic_string<charT> comment_end_str = TYTI_L(charT, "*/");
    const std::basic_string<charT> whitespaces = TYTI_L(charT, " \n\v\f\r\t");

#ifdef WIN32
    std::function<bool(const std::basic_string<charT> &)> is_platform_str =
        [](const std::basic_string<charT> &in)
    {
        return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$WINDOWS");
    };
#elif __APPLE__
    // WIN32 stands for pc in general
    std::function<bool(const std::basic_string<charT> &)> is_platform_str =
        [](const std::basic_string<charT> &in)
    {
        return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") ||
               in == TYTI_L(charT, "$OSX");
    };

#elif __linux__
    // WIN32 stands for pc in general
    std::function<bool(const std::basic_string<charT> &)> is_platform_str =
        [](const std::basic_string<charT> &in)
    {
        return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") ||
               in == TYTI_L(charT, "$LINUX");
    };
#else
    std::function<bool(const std::basic_string<charT> &)> is_platform_str =
        [](const std::basic_string<charT> &in) { return false; };
#endif

    if (opt.ignore_all_platform_conditionals)
        is_platform_str = [](const std::basic_string<charT> &)
        { return false; };

    // function for skipping a comment block
    // iter: iterator poition to the position after a '/'
    auto skip_comments = [&comment_end_str](IterT iter,
                                            const IterT &last) -> IterT
    {
        ++iter;
        if (iter == last)
            return last;

        if (*iter == TYTI_L(charT, '/'))
        {
            // line comment, skip whole line
            iter = std::find(iter + 1, last, TYTI_L(charT, '\n'));
            if (iter == last)
                return last;
        }

        if (*iter == '*')
        {
            // block comment, skip until next occurance of "*\"
            iter = std::search(iter + 1, last, std::begin(comment_end_str),
                               std::end(comment_end_str));
            if (std::distance(iter, last) <= 2)
                return last;
            iter += 2;
        }

        return iter;
    };

    auto end_quote = [](IterT iter, const IterT &last) -> IterT
    {
        const auto begin = iter;
        auto last_esc = iter;
        if (iter == last)
            throw std::runtime_error{"quote was opened but not closed."};
        do
        {
            ++iter;
            iter = std::find(iter, last, TYTI_L(charT, '\"'));
            if (iter == last)
                break;

            last_esc = std::prev(iter);
            while (last_esc != begin && *last_esc == '\\')
                --last_esc;
        } while (!(std::distance(last_esc, iter) % 2) && iter != last);
        if (iter == last)
            throw std::runtime_error{"quote was opened but not closed."};
        return iter;
    };

    auto end_word = [&whitespaces](IterT iter, const IterT &last) -> IterT
    {
        const auto begin = iter;
        auto last_esc = iter;
        if (iter == last)
            throw std::runtime_error{"quote was opened but not closed."};
        do
        {
            ++iter;
            iter = std::find_first_of(iter, last, std::begin(whitespaces),
                                      std::end(whitespaces));
            if (iter == last)
                break;

            last_esc = std::prev(iter);
            while (last_esc != begin && *last_esc == '\\')
                --last_esc;
        } while (!(std::distance(last_esc, iter) % 2) && iter != last);
        if (iter == last)
            throw std::runtime_error{"word wasnt properly ended"};
        return iter;
    };

    auto skip_whitespaces = [&whitespaces](IterT iter,
                                           const IterT &last) -> IterT
    {
        if (iter == last)
            return iter;
        iter = std::find_if_not(iter, last,
                                [&whitespaces](charT c)
                                {
                                    // return true if whitespace
                                    return std::any_of(std::begin(whitespaces),
                                                       std::end(whitespaces),
                                                       [c](charT pc)
                                                       { return pc == c; });
                                });
        return iter;
    };

    std::function<void(std::basic_string<charT> &)> strip_escape_symbols =
        [](std::basic_string<charT> &s)
    {
        auto quote_searcher = [&s](size_t pos)
        { return s.find(TYTI_L(charT, "\\\""), pos); };
        auto p = quote_searcher(0);
        while (p != s.npos)
        {
            s.replace(p, 2, TYTI_L(charT, "\""));
            p = quote_searcher(p);
        }
        auto searcher = [&s](size_t pos)
        { return s.find(TYTI_L(charT, "\\\\"), pos); };
        p = searcher(0);
        while (p != s.npos)
        {
            s.replace(p, 2, TYTI_L(charT, "\\"));
            p = searcher(p);
        }
    };

    if (!opt.strip_escape_symbols)
        strip_escape_symbols = [](std::basic_string<charT> &) {};

    auto conditional_fullfilled =
        [&skip_whitespaces, &is_platform_str](IterT &iter, const IterT &last)
    {
        iter = skip_whitespaces(iter, last);
        if (iter == last)
            return true;
        if (*iter == '[')
        {
            ++iter;
            if (iter == last)
                throw std::runtime_error("conditional not closed");
            const auto end = std::find(iter, last, ']');
            if (end == last)
                throw std::runtime_error("conditional not closed");
            const bool negate = *iter == '!';
            if (negate)
                ++iter;
            auto conditional = std::basic_string<charT>(iter, end);

            const bool is_platform = is_platform_str(conditional);
            iter = end + 1;

            return static_cast<bool>(is_platform ^ negate);
        }
        return true;
    };

    // read header
    //  first, quoted name
    std::unique_ptr<OutputT> curObj = nullptr;
    std::vector<std::unique_ptr<OutputT>> roots;
    std::stack<std::unique_ptr<OutputT>> lvls;
    auto curIter = first;

    while (curIter != last && *curIter != '\0')
    {
        //  find first starting attrib/child, or ending
        curIter = skip_whitespaces(curIter, last);
        if (curIter == last || *curIter == '\0')
            break;
        if (*curIter == TYTI_L(charT, '/'))
        {
            curIter = skip_comments(curIter, last);
            if (curIter == last || *curIter == '\0')
                throw std::runtime_error("Unexpected eof");
        }
        else if (*curIter != TYTI_L(charT, '}'))
        {
            // get key
            const auto keyEnd = (*curIter == TYTI_L(charT, '\"'))
                                    ? end_quote(curIter, last)
                                    : end_word(curIter, last);
            if (*curIter == TYTI_L(charT, '\"'))
                ++curIter;
            std::basic_string<charT> key(curIter, keyEnd);
            strip_escape_symbols(key);
            curIter = keyEnd + ((*keyEnd == TYTI_L(charT, '\"')) ? 1 : 0);
            if (curIter == last)
                throw std::runtime_error{"key opened, but never closed"};

            curIter = skip_whitespaces(curIter, last);

            if (!conditional_fullfilled(curIter, last))
                continue;
            if (curIter == last)
                throw std::runtime_error{"key declared, but no value"};

            while (*curIter == TYTI_L(charT, '/'))
            {

                curIter = skip_comments(curIter, last);
                if (curIter == last || *curIter == '}')
                    throw std::runtime_error{"key declared, but no value"};
                curIter = skip_whitespaces(curIter, last);
                if (curIter == last || *curIter == '}')
                    throw std::runtime_error{"key declared, but no value"};
            }
            // get value
            if (*curIter != '{')
            {
                if (curIter == last)
                    throw std::runtime_error{"key declared, but no value"};
                const auto valueEnd = (*curIter == TYTI_L(charT, '\"'))
                                          ? end_quote(curIter, last)
                                          : end_word(curIter, last);
                if (valueEnd == last)
                    throw std::runtime_error("No closed word");
                if (*curIter == TYTI_L(charT, '\"'))
                    ++curIter;
                if (curIter == last)
                    throw std::runtime_error("No closed word");

                auto value = std::basic_string<charT>(curIter, valueEnd);
                strip_escape_symbols(value);
                curIter =
                    valueEnd + ((*valueEnd == TYTI_L(charT, '\"')) ? 1 : 0);

                if (!conditional_fullfilled(curIter, last))
                    continue;

                // process value
                if (key != TYTI_L(charT, "#include") &&
                    key != TYTI_L(charT, "#base"))
                {
                    if (curObj)
                    {
                        curObj->add_attribute(std::move(key), std::move(value));
                    }
                    else
                    {
                        throw std::runtime_error{
                            "unexpected key without object"};
                    }
                }
                else
                {
                    if (!opt.ignore_includes &&
                        exclude_files.find(value) == exclude_files.end())
                    {
                        exclude_files.insert(value);
                        std::basic_ifstream<charT> i(
                            detail::string_converter(value));
                        auto str = read_file(i);
                        auto file_objs = read_internal<OutputT>(
                            str.begin(), str.end(), exclude_files, opt);
                        for (auto &n : file_objs)
                        {
                            if (curObj)
                                curObj->add_child(std::move(n));
                            else
                                roots.push_back(std::move(n));
                        }
                        exclude_files.erase(value);
                    }
                }
            }
            else if (*curIter == '{')
            {
                if (curObj)
                    lvls.push(std::move(curObj));
                curObj = std::make_unique<OutputT>();
                curObj->set_name(std::move(key));
                ++curIter;
            }
        }
        // end of new object
        else if (curObj && *curIter == TYTI_L(charT, '}'))
        {
            if (!lvls.empty())
            {
                // get object before
                std::unique_ptr<OutputT> prev{std::move(lvls.top())};
                lvls.pop();

                // add finished obj to obj before and release it from processing
                prev->add_child(std::move(curObj));
                curObj = std::move(prev);
            }
            else
            {
                roots.push_back(std::move(curObj));
                curObj.reset();
            }
            ++curIter;
        }
        else
        {
            throw std::runtime_error{"unexpected '}'"};
        }
    }
    if (curObj != nullptr || !lvls.empty())
    {
        throw std::runtime_error{"object is not closed with '}'"};
    }

    return roots;
}

} // namespace detail

/** \brief Read VDF formatted sequences defined by the range [first, last).
If the file is mailformatted, parser will try to read it until it can.
@param first begin iterator
@param end end iterator

can thow:
        - "std::runtime_error" if a parsing error occured
        - "std::bad_alloc" if not enough memory coup be allocated
*/
template <typename OutputT, typename IterT>
OutputT read(IterT first, const IterT last, const Options &opt = Options{})
{
    auto exclude_files = std::unordered_set<
        std::basic_string<typename std::iterator_traits<IterT>::value_type>>{};
    auto roots =
        detail::read_internal<OutputT>(first, last, exclude_files, opt);

    OutputT result;
    if (roots.size() > 1)
    {
        for (auto &i : roots)
            result.add_child(std::move(i));
    }
    else if (roots.size() == 1)
        result = std::move(*roots[0]);

    return result;
}

/** \brief Read VDF formatted sequences defined by the range [first, last).
If the file is mailformatted, parser will try to read it until it can.
@param first begin iterator
@param end end iterator
@param ec output bool. 0 if ok, otherwise, holds an system error code

Possible error codes:
std::errc::protocol_error: file is mailformatted
std::errc::not_enough_memory: not enough space
std::errc::invalid_argument: iterators throws e.g. out of range
*/
template <typename OutputT, typename IterT>
OutputT read(IterT first, IterT last, std::error_code &ec,
             const Options &opt = Options{}) NOEXCEPT

{
    ec.clear();
    OutputT r{};
    try
    {
        r = read<OutputT>(first, last, opt);
    }
    catch (std::runtime_error &)
    {
        ec = std::make_error_code(std::errc::protocol_error);
    }
    catch (std::bad_alloc &)
    {
        ec = std::make_error_code(std::errc::not_enough_memory);
    }
    catch (...)
    {
        ec = std::make_error_code(std::errc::invalid_argument);
    }
    return r;
}

/** \brief Read VDF formatted sequences defined by the range [first, last).
If the file is mailformatted, parser will try to read it until it can.
@param first begin iterator
@param end end iterator
@param ok output bool. true, if parser successed, false, if parser failed
*/
template <typename OutputT, typename IterT>
OutputT read(IterT first, const IterT last, bool *ok,
             const Options &opt = Options{}) NOEXCEPT
{
    std::error_code ec;
    auto r = read<OutputT>(first, last, ec, opt);
    if (ok)
        *ok = !ec;
    return r;
}

template <typename IterT>
inline auto read(IterT first, const IterT last, bool *ok,
                 const Options &opt = Options{}) NOEXCEPT
    -> basic_object<typename std::iterator_traits<IterT>::value_type>
{
    return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(
        first, last, ok, opt);
}

template <typename IterT>
inline auto read(IterT first, IterT last, std::error_code &ec,
                 const Options &opt = Options{}) NOEXCEPT
    -> basic_object<typename std::iterator_traits<IterT>::value_type>
{
    return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(
        first, last, ec, opt);
}

template <typename IterT>
inline auto read(IterT first, const IterT last, const Options &opt = Options{})
    -> basic_object<typename std::iterator_traits<IterT>::value_type>
{
    return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(
        first, last, opt);
}

/** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf
   formatted data. throws "std::bad_alloc" if file buffer could not be allocated
*/
template <typename OutputT, typename iStreamT>
OutputT read(iStreamT &inStream, std::error_code &ec,
             const Options &opt = Options{})
{
    // cache the file
    typedef typename iStreamT::char_type charT;
    std::basic_string<charT> str = detail::read_file(inStream);

    // parse it
    return read<OutputT>(str.begin(), str.end(), ec, opt);
}

template <typename iStreamT>
inline basic_object<typename iStreamT::char_type>
read(iStreamT &inStream, std::error_code &ec, const Options &opt = Options{})
{
    return read<basic_object<typename iStreamT::char_type>>(inStream, ec, opt);
}

/** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf
   formatted data. throws "std::bad_alloc" if file buffer could not be allocated
    ok == false, if a parsing error occured
*/
template <typename OutputT, typename iStreamT>
OutputT read(iStreamT &inStream, bool *ok, const Options &opt = Options{})
{
    std::error_code ec;
    const auto r = read<OutputT>(inStream, ec, opt);
    if (ok)
        *ok = !ec;
    return r;
}

template <typename iStreamT>
inline basic_object<typename iStreamT::char_type>
read(iStreamT &inStream, bool *ok, const Options &opt = Options{})
{
    return read<basic_object<typename iStreamT::char_type>>(inStream, ok, opt);
}

/** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf
   formatted data. throws "std::bad_alloc" if file buffer could not be allocated
    throws "std::runtime_error" if a parsing error occured
*/
template <typename OutputT, typename iStreamT>
OutputT read(iStreamT &inStream, const Options &opt)
{

    // cache the file
    typedef typename iStreamT::char_type charT;
    std::basic_string<charT> str = detail::read_file(inStream);
    // parse it
    return read<OutputT>(str.begin(), str.end(), opt);
}

template <typename iStreamT>
inline basic_object<typename iStreamT::char_type>
read(iStreamT &inStream, const Options &opt = Options{})
{
    return read<basic_object<typename iStreamT::char_type>>(inStream, opt);
}

} // namespace vdf
} // namespace tyti
#ifndef TYTI_NO_L_UNDEF
#undef TYTI_L
#endif

#ifdef TYTI_UNDEF_CONSTEXPR
#undef CONSTEXPR
#undef TYTI_NO_L_UNDEF
#endif

#ifdef TYTI_UNDEF_NOTHROW
#undef NOTHROW
#undef TYTI_UNDEF_NOTHROW
#endif

#endif //__TYTI_STEAM_VDF_PARSER_H__