pack.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_PACK_HPP
#define JOIN_DATA_PACK_HPP
 
// dconv.
#include <dconv/probe.hpp>
 
// libjoin.
#include <join/value_builder.hpp>
#include <join/value.hpp>
#include <join/utils.hpp>
#include <join/sax.hpp>
 
// C++.
#include <algorithm>
#include <sstream>
#include <fstream>
 
// C.
#include <cstring>
 
namespace join
{
    class PackWriter
    {
    public:
        explicit PackWriter (std::ostream& document)
        : _out (document.rdbuf ())
        {
        }
 
        PackWriter (const PackWriter& other) = delete;
 
        PackWriter& operator= (const PackWriter& other) = delete;
 
        PackWriter (PackWriter&& other) = delete;
 
        PackWriter& operator= (PackWriter&& other) = delete;
 
        ~PackWriter () = default;
 
        int setNull ()
        {
            append (0xc0);
            endValue ();
            return 0;
        }
 
        int setBool (bool value)
        {
            if (value)
            {
                append (0xc3);
            }
            else
            {
                append (0xc2);
            }
            endValue ();
            return 0;
        }
 
        int setInt (int32_t value)
        {
            if (value < -(1 << 15))
            {
                append (0xd2);
                pack (static_cast<uint32_t> (value));
            }
            else if (value < -(1 << 7))
            {
                append (0xd1);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < -(1 << 5))
            {
                append (0xd0);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            endValue ();
            return 0;
        }
 
        int setUint (uint32_t value)
        {
            if (value < (1 << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else
            {
                append (0xce);
                pack (value);
            }
            endValue ();
            return 0;
        }
 
        int setInt64 (int64_t value)
        {
            if (value < -(1LL << 31))
            {
                append (0xd3);
                pack (static_cast<uint64_t> (value));
            }
            else if (value < -(1LL << 15))
            {
                append (0xd2);
                pack (static_cast<uint32_t> (value));
            }
            else if (value < -(1LL << 7))
            {
                append (0xd1);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < -(1LL << 5))
            {
                append (0xd0);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < (1LL << 32))
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            else
            {
                append (0xcf);
                pack (static_cast<uint64_t> (value));
            }
            endValue ();
            return 0;
        }
 
        int setUint64 (uint64_t value)
        {
            if (value < (1ULL << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1ULL << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1ULL << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < (1ULL << 32))
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            else
            {
                append (0xcf);
                pack (value);
            }
            endValue ();
            return 0;
        }
 
        int setDouble (double value)
        {
            float f = static_cast<float> (value);
            if (std::isfinite (value) && static_cast<double> (f) == value)
            {
                append (0xca);
                pack (f);
            }
            else
            {
                append (0xcb);
                pack (value);
            }
            endValue ();
            return 0;
        }
 
        int setString (std::string_view value)
        {
            if (value.size () < 32)
            {
                append (static_cast<char> (0xa0 | value.size ()));
            }
            else if (value.size () < 256)
            {
                append (0xd9);
                pack (static_cast<uint8_t> (value.size ()));
            }
            else if (value.size () < 65536)
            {
                append (0xda);
                pack (static_cast<uint16_t> (value.size ()));
            }
            else
            {
                append (0xdb);
                pack (static_cast<uint32_t> (value.size ()));
            }
            append (value.data (), static_cast<uint32_t> (value.size ()));
            endValue ();
            return 0;
        }
 
        int startArray (uint32_t size)
        {
            if (size < 16)
            {
                append (static_cast<char> (0x90 | size));
            }
            else if (size < 65536)
            {
                append (0xdc);
                pack (static_cast<uint16_t> (size));
            }
            else
            {
                append (0xdd);
                pack (size);
            }
            ++_depth;
            return 0;
        }
 
        int stopArray ()
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            --_depth;
            endValue ();
            return 0;
        }
 
        int startObject (uint32_t size)
        {
            if (size < 16)
            {
                append (static_cast<char> (0x80 | size));
            }
            else if (size < 65536)
            {
                append (0xde);
                pack (static_cast<uint16_t> (size));
            }
            else
            {
                append (0xdf);
                pack (size);
            }
            ++_depth;
            return 0;
        }
 
        const Object& members (const Object& object) const noexcept
        {
            return object;
        }
 
        int setKey ([[maybe_unused]] std::nullptr_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setNull ();
        }
 
        int setKey (bool key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setBool (key);
        }
 
        int setKey (int32_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setInt (key);
        }
 
        int setKey (uint32_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setUint (key);
        }
 
        int setKey (int64_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setInt64 (key);
        }
 
        int setKey (uint64_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setUint64 (key);
        }
 
        int setKey (double key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setDouble (key);
        }
 
        int setKey (std::string_view key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            return setString (key);
        }
 
        int setKey (const char* key)
        {
            return setKey (std::string_view (key));
        }
 
        int stopObject ()
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                reset ();
                return -1;
            }
            --_depth;
            endValue ();
            return 0;
        }
 
        void flush ()
        {
            if (_size)
            {
                _out->sputn (_buffer, _size);
                _size = 0;
            }
        }
 
        void reset () noexcept
        {
            _size = 0;
            _depth = 0;
        }
 
    protected:
        inline void append (char data)
        {
            if (JOIN_UNLIKELY (_size == sizeof (_buffer)))
            {
                flush ();
            }
            _buffer[_size++] = data;
        }
 
        inline void append (const char* data, uint32_t size)
        {
            if (JOIN_UNLIKELY (size > sizeof (_buffer) - _size))
            {
                flush ();
                if (size >= sizeof (_buffer))
                {
                    _out->sputn (data, size);
                    return;
                }
            }
            std::memcpy (_buffer + _size, data, size);
            _size += size;
        }
 
        template <typename Type>
        void pack (Type value)
        {
            append (reinterpret_cast<const char*> (&swap (value)), sizeof (value));
        }
 
        inline void endValue ()
        {
            if (_depth == 0)
            {
                flush ();
            }
        }
 
        std::streambuf* _out;
 
        char _buffer[1024] = {};
 
        size_t _size = 0;
 
        size_t _depth = 0;
    };
 
    class PackReader
    {
    public:
        PackReader () = default;
 
        PackReader (const PackReader& other) = delete;
 
        PackReader& operator= (const PackReader& other) = delete;
 
        PackReader (PackReader&& other) = delete;
 
        PackReader& operator= (PackReader&& other) = delete;
 
        ~PackReader () = default;
 
        template <typename Handler>
        int deserialize (const char* document, size_t length, Handler& handler)
        {
            dconv::StringProbe in (document, length);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (const char* first, const char* last, Handler& handler)
        {
            dconv::StringProbe in (first, last);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::string_view document, Handler& handler)
        {
            dconv::StringProbe in (document.data (), document.size ());
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::stringstream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::istringstream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::fstream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::ifstream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::iostream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
        template <typename Handler>
        int deserialize (std::istream& document, Handler& handler)
        {
            dconv::StreamProbe in (document);
            return read (in, handler);
        }
 
    protected:
        template <typename ProbeType>
        int read (ProbeType& document, Value& value)
        {
            return read (document, ValueBuilder (value));
        }
 
        template <typename ProbeType, typename Handler>
        int read (ProbeType& document, Handler&& handler)
        {
            try
            {
                if (JOIN_LIKELY (readValue (document, handler, 0) == 0))
                {
                    if (JOIN_LIKELY (document.peek () == std::char_traits<char>::eof ()))
                    {
                        return 0;
                    }
 
                    join::lastError = make_error_code (SaxErrc::ExtraData);
                }
            }
            catch (...)
            {
                handler.reset ();
                throw;
            }
            handler.reset ();
            return -1;
        }
 
        template <typename ProbeType, typename Handler>
        int readValue (ProbeType& document, Handler& handler, size_t depth)
        {
            int ch = document.peek ();
            if (JOIN_UNLIKELY (ch == std::char_traits<char>::eof ()))
            {
                join::lastError = make_error_code (SaxErrc::Truncated);
                return -1;
            }
 
            uint8_t head = static_cast<uint8_t> (ch);
 
            if (isArray (head))
            {
                return readArray (document, handler, depth);
            }
            else if (isObject (head))
            {
                return readObject (document, handler, depth);
            }
            else if (isNull (head))
            {
                return readNull (document, handler);
            }
            else if (isFalse (head))
            {
                return readFalse (document, handler);
            }
            else if (isTrue (head))
            {
                return readTrue (document, handler);
            }
            else if (isString (head))
            {
                return readString (document, handler);
            }
            else if (isBin (head))
            {
                return readBin (document, handler);
            }
            else if (isNumber (head))
            {
                return readNumber (document, handler);
            }
            else
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
        }
 
        template <typename ProbeType, typename Handler>
        int readNull (ProbeType& document, Handler& handler, bool isKey = false)
        {
            document.get ();
            return (isKey) ? handler.setKey (nullptr) : handler.setNull ();
        }
 
        template <typename ProbeType, typename Handler>
        int readFalse (ProbeType& document, Handler& handler, bool isKey = false)
        {
            document.get ();
            return (isKey) ? handler.setKey (false) : handler.setBool (false);
        }
 
        template <typename ProbeType, typename Handler>
        int readTrue (ProbeType& document, Handler& handler, bool isKey = false)
        {
            document.get ();
            return (isKey) ? handler.setKey (true) : handler.setBool (true);
        }
 
        template <typename ProbeType, typename Handler>
        int readArray (ProbeType& document, Handler& handler, size_t depth)
        {
            if (JOIN_UNLIKELY (depth == saxMaxDepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            uint32_t len = 0;
 
            if (document.getIf (0xdd))
            {
                if (JOIN_UNLIKELY (unpack<uint32_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xdc))
            {
                if (JOIN_UNLIKELY (unpack<uint16_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else
            {
                len = static_cast<uint8_t> (document.get ()) & ~0x90u;
            }
 
            if (JOIN_UNLIKELY (handler.startArray (len) == -1))
            {
                return -1;
            }
 
            while (len)
            {
                if (JOIN_UNLIKELY (readValue (document, handler, depth + 1) == -1))
                {
                    return -1;
                }
 
                --len;
            }
 
            return handler.stopArray ();
        }
 
        template <typename ProbeType, typename Handler>
        int readObject (ProbeType& document, Handler& handler, size_t depth)
        {
            if (JOIN_UNLIKELY (depth == saxMaxDepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            uint32_t len = 0;
 
            if (document.getIf (0xdf))
            {
                if (JOIN_UNLIKELY (unpack<uint32_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xde))
            {
                if (JOIN_UNLIKELY (unpack<uint16_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else
            {
                len = static_cast<uint8_t> (document.get ()) & ~0x80u;
            }
 
            if (JOIN_UNLIKELY (handler.startObject (len) == -1))
            {
                return -1;
            }
 
            while (len)
            {
                if (JOIN_UNLIKELY (readKey (document, handler) == -1))
                {
                    return -1;
                }
 
                if (JOIN_UNLIKELY (readValue (document, handler, depth + 1) == -1))
                {
                    return -1;
                }
 
                --len;
            }
 
            return handler.stopObject ();
        }
 
        template <typename ProbeType, typename Handler>
        int readKey (ProbeType& document, Handler& handler)
        {
            int ch = document.peek ();
            if (JOIN_UNLIKELY (ch == std::char_traits<char>::eof ()))
            {
                join::lastError = make_error_code (SaxErrc::Truncated);
                return -1;
            }
 
            uint8_t head = static_cast<uint8_t> (ch);
 
            if (isNull (head))
            {
                return readNull (document, handler, true);
            }
            else if (isFalse (head))
            {
                return readFalse (document, handler, true);
            }
            else if (isTrue (head))
            {
                return readTrue (document, handler, true);
            }
            else if (isString (head))
            {
                return readString (document, handler, true);
            }
            else if (isNumber (head))
            {
                return readNumber (document, handler, true);
            }
            else
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
        }
 
        template <typename ProbeType, typename Handler>
        int readString (ProbeType& document, Handler& handler, bool isKey = false)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xdb))
            {
                if (JOIN_UNLIKELY (unpack<uint32_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xda))
            {
                if (JOIN_UNLIKELY (unpack<uint16_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xd9))
            {
                if (JOIN_UNLIKELY (unpack<uint8_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else
            {
                len = static_cast<uint8_t> (document.get ()) & ~0xa0u;
            }
 
            thread_local std::string cache;
            std::string output = std::move (cache);
            output.clear ();
            if (JOIN_UNLIKELY (readBytes (document, len, output) == -1))
            {
                return -1;
            }
 
            int result = isKey ? handler.setKey (output) : handler.setString (output);
            cache = std::move (output);
            return result;
        }
 
        template <typename ProbeType, typename Handler>
        int readBin (ProbeType& document, Handler& handler)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xc6))
            {
                if (JOIN_UNLIKELY (unpack<uint32_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xc5))
            {
                if (JOIN_UNLIKELY (unpack<uint16_t> (document, len) == -1))
                {
                    return -1;
                }
            }
            else if (document.getIf (0xc4))
            {
                if (JOIN_UNLIKELY (unpack<uint8_t> (document, len) == -1))
                {
                    return -1;
                }
            }
 
            thread_local std::string cache;
            std::string output = std::move (cache);
            output.clear ();
            if (JOIN_UNLIKELY (readBytes (document, len, output) == -1))
            {
                return -1;
            }
 
            int result = handler.setString (output);
            cache = std::move (output);
            return result;
        }
 
        template <typename ProbeType, typename Handler>
        int readNumber (ProbeType& document, Handler& handler, bool isKey = false)
        {
            uint8_t head = document.get ();
 
            if (head <= 0x7f)
            {
                auto number = uint32_t (head);
                return isKey ? handler.setKey (number) : handler.setUint (number);
            }
            else if (head >= 0xe0)
            {
                auto number = int32_t (static_cast<int8_t> (head));
                return isKey ? handler.setKey (number) : handler.setInt (number);
            }
            else if (head == 0xd3)
            {
                int64_t number;
                if (JOIN_UNLIKELY (unpack<int64_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setInt64 (number);
            }
            else if (head == 0xcf)
            {
                uint64_t number;
                if (JOIN_UNLIKELY (unpack<uint64_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setUint64 (number);
            }
            else if (head == 0xcb)
            {
                double number;
                if (JOIN_UNLIKELY (unpack<double> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setDouble (number);
            }
            else if (head == 0xd2)
            {
                int32_t number;
                if (JOIN_UNLIKELY (unpack<int32_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setInt (number);
            }
            else if (head == 0xce)
            {
                uint32_t number;
                if (JOIN_UNLIKELY (unpack<uint32_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setUint (number);
            }
            else if (head == 0xca)
            {
                double number;
                if (JOIN_UNLIKELY (unpack<float> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setDouble (number);
            }
            else if (head == 0xd1)
            {
                int32_t number;
                if (JOIN_UNLIKELY (unpack<int16_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setInt (number);
            }
            else if (head == 0xcd)
            {
                uint32_t number;
                if (JOIN_UNLIKELY (unpack<uint16_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setUint (number);
            }
            else if (head == 0xd0)
            {
                int32_t number;
                if (JOIN_UNLIKELY (unpack<int8_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setInt (number);
            }
            else if (head == 0xcc)
            {
                uint32_t number;
                if (JOIN_UNLIKELY (unpack<uint8_t> (document, number) == -1))
                {
                    return -1;
                }
                return isKey ? handler.setKey (number) : handler.setUint (number);
            }
            else
            {
                // LCOV_EXCL_START
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
                // LCOV_EXCL_STOP
            }
        }
 
        template <typename ProbeType>
        static int readBytes (ProbeType& document, uint32_t len, std::string& output)
        {
            while (len)
            {
                size_t pos = output.size ();
                size_t chunk = std::min<size_t> (len, 65536);
                output.resize (pos + chunk);
                if (JOIN_UNLIKELY (document.read (&output[pos], chunk) != chunk))
                {
                    join::lastError = make_error_code (SaxErrc::Truncated);
                    return -1;
                }
                len -= chunk;
            }
            return 0;
        }
 
        template <typename Type, typename ProbeType, typename Output>
        static int unpack (ProbeType& document, Output& output)
            requires std::is_arithmetic_v<Type>
        {
            Type value;
            if (JOIN_UNLIKELY (document.read (reinterpret_cast<char*> (&value), sizeof (value)) != sizeof (value)))
            {
                join::lastError = make_error_code (SaxErrc::Truncated);
                return -1;
            }
            output = static_cast<Output> (swap (value));
            return 0;
        }
 
        constexpr bool isNull (uint8_t c)
        {
            return (c == 0xc0);
        }
 
        constexpr bool isFalse (uint8_t c)
        {
            return (c == 0xc2);
        }
 
        constexpr bool isTrue (uint8_t c)
        {
            return (c == 0xc3);
        }
 
        constexpr bool isInt (uint8_t c)
        {
            return ((c <= 0x7f) || (c >= 0xe0)) || (c == 0xd0) || (c == 0xd1) || (c == 0xd2);
        }
 
        constexpr bool isUint (uint8_t c)
        {
            return (c == 0xcc) || (c == 0xcd) || (c == 0xce);
        }
 
        constexpr bool isInt64 (uint8_t c)
        {
            return (c == 0xd3);
        }
 
        constexpr bool isUint64 (uint8_t c)
        {
            return (c == 0xcf);
        }
 
        constexpr bool isReal (uint8_t c)
        {
            return (c == 0xca) || (c == 0xcb);
        }
 
        constexpr bool isNumber (uint8_t c)
        {
            return isInt (c) || isUint (c) || isInt64 (c) || isUint64 (c) || isReal (c);
        }
 
        constexpr bool isString (uint8_t c)
        {
            return ((c >= 0xa0) && (c <= 0xbf)) || (c == 0xd9) || (c == 0xda) || (c == 0xdb);
        }
 
        constexpr bool isBin (uint8_t c)
        {
            return (c == 0xc4) || (c == 0xc5) || (c == 0xc6);
        }
 
        constexpr bool isArray (uint8_t c)
        {
            return ((c >= 0x90) && (c <= 0x9f)) || (c == 0xdc) || (c == 0xdd);
        }
 
        constexpr bool isObject (uint8_t c)
        {
            return ((c >= 0x80) && (c <= 0x8f)) || (c == 0xde) || (c == 0xdf);
        }
    };
}
 
#endif