/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/writer.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/writer.h Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/writer.h Source File
Go to the documentation of this file.
 // Tencent is pleased to support the open source community by making RapidJSON available.
 //
 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
 //
 // http://opensource.org/licenses/MIT
 //
 // Unless required by applicable law or agreed to in writing, software distributed
 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
 // specific language governing permissions and limitations under the License.
  
 #ifndef RAPIDJSON_WRITER_H_
 #define RAPIDJSON_WRITER_H_
  
 #include "stream.h"
 #include "internal/clzll.h"
 #include "internal/meta.h"
 #include "internal/stack.h"
 #include "internal/strfunc.h"
 #include "internal/dtoa.h"
 #include "internal/itoa.h"
 #include "stringbuffer.h"
 #include <new> // placement new
  
 #if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
 #include <intrin.h>
 #pragma intrinsic(_BitScanForward)
 #endif
 #ifdef RAPIDJSON_SSE42
 #include <nmmintrin.h>
 #elif defined(RAPIDJSON_SSE2)
 #include <emmintrin.h>
 #elif defined(RAPIDJSON_NEON)
 #include <arm_neon.h>
 #endif
  
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(unreachable - code)
 RAPIDJSON_DIAG_OFF(c++ 98 - compat)
 #elif defined(_MSC_VER)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
 #endif
  
 RAPIDJSON_NAMESPACE_BEGIN
  
 // WriteFlag
  
 #ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
 #define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
 #endif
  
 enum WriteFlag
 {
     kWriteNoFlags              = 0, 
     kWriteValidateEncodingFlag = 1, 
     kWriteNanAndInfFlag        = 2, 
     kWriteNanAndInfNullFlag    = 4, 
     kWriteDefaultFlags =
         RAPIDJSON_WRITE_DEFAULT_FLAGS 
 };
  
  
 template <typename OutputStream,
           typename SourceEncoding = UTF8<>,
           typename TargetEncoding = UTF8<>,
           typename StackAllocator = CrtAllocator,
           unsigned writeFlags     = kWriteDefaultFlags>
 class Writer
 {
     public:
     typedef typename SourceEncoding::Ch Ch;
  
     static const int kDefaultMaxDecimalPlaces = 324;
  
  
     explicit Writer(OutputStream& os,
                     StackAllocator* stackAllocator = 0,
                     size_t levelDepth              = kDefaultLevelDepth)
         : os_(&os),
           level_stack_(stackAllocator, levelDepth * sizeof(Level)),
           maxDecimalPlaces_(kDefaultMaxDecimalPlaces),
           hasRoot_(false)
     {
     }
  
     explicit Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth)
         : os_(0),
           level_stack_(allocator, levelDepth * sizeof(Level)),
           maxDecimalPlaces_(kDefaultMaxDecimalPlaces),
           hasRoot_(false)
     {
     }
  
 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
     Writer(Writer&& rhs)
         : os_(rhs.os_),
           level_stack_(std::move(rhs.level_stack_)),
           maxDecimalPlaces_(rhs.maxDecimalPlaces_),
           hasRoot_(rhs.hasRoot_)
     {
         rhs.os_ = 0;
     }
 #endif
  
  
     void Reset(OutputStream& os)
     {
         os_      = &os;
         hasRoot_ = false;
         level_stack_.Clear();
     }
  
  
     bool IsComplete() const { return hasRoot_ && level_stack_.Empty(); }
  
     int GetMaxDecimalPlaces() const { return maxDecimalPlaces_; }
  
  
     void SetMaxDecimalPlaces(int maxDecimalPlaces) { maxDecimalPlaces_ = maxDecimalPlaces; }
  
  
     bool Null()
     {
         Prefix(kNullType);
         return EndValue(WriteNull());
     }
     bool Bool(bool b)
     {
         Prefix(b ? kTrueType : kFalseType);
         return EndValue(WriteBool(b));
     }
     bool Int(int i)
     {
         Prefix(kNumberType);
         return EndValue(WriteInt(i));
     }
     bool Uint(unsigned u)
     {
         Prefix(kNumberType);
         return EndValue(WriteUint(u));
     }
     bool Int64(int64_t i64)
     {
         Prefix(kNumberType);
         return EndValue(WriteInt64(i64));
     }
     bool Uint64(uint64_t u64)
     {
         Prefix(kNumberType);
         return EndValue(WriteUint64(u64));
     }
  
  
     bool Double(double d)
     {
         Prefix(kNumberType);
         return EndValue(WriteDouble(d));
     }
  
     bool RawNumber(const Ch* str, SizeType length, bool copy = false)
     {
         RAPIDJSON_ASSERT(str != 0);
         (void)copy;
         Prefix(kNumberType);
         return EndValue(WriteString(str, length));
     }
  
     bool String(const Ch* str, SizeType length, bool copy = false)
     {
         RAPIDJSON_ASSERT(str != 0);
         (void)copy;
         Prefix(kStringType);
         return EndValue(WriteString(str, length));
     }
  
 #if RAPIDJSON_HAS_STDSTRING
     bool String(const std::basic_string<Ch>& str)
     {
         return String(str.data(), SizeType(str.size()));
     }
 #endif
  
     bool StartObject()
     {
         Prefix(kObjectType);
         new(level_stack_.template Push<Level>()) Level(false);
         return WriteStartObject();
     }
  
     bool Key(const Ch* str, SizeType length, bool copy = false)
     {
         return String(str, length, copy);
     }
  
 #if RAPIDJSON_HAS_STDSTRING
     bool Key(const std::basic_string<Ch>& str) { return Key(str.data(), SizeType(str.size())); }
 #endif
  
     bool EndObject(SizeType memberCount = 0)
     {
         (void)memberCount;
         RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
         RAPIDJSON_ASSERT(
             !level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
         RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount %
                                   2); // Object has a Key without a Value
         level_stack_.template Pop<Level>(1);
         return EndValue(WriteEndObject());
     }
  
     bool StartArray()
     {
         Prefix(kArrayType);
         new(level_stack_.template Push<Level>()) Level(true);
         return WriteStartArray();
     }
  
     bool EndArray(SizeType elementCount = 0)
     {
         (void)elementCount;
         RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
         RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
         level_stack_.template Pop<Level>(1);
         return EndValue(WriteEndArray());
     }
  
  
     bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); }
     bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
  
  
  
     bool RawValue(const Ch* json, size_t length, Type type)
     {
         RAPIDJSON_ASSERT(json != 0);
         Prefix(type);
         return EndValue(WriteRawValue(json, length));
     }
  
  
     void Flush() { os_->Flush(); }
  
     static const size_t kDefaultLevelDepth = 32;
  
     protected:
     struct Level
     {
         Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
         size_t valueCount; 
         bool inArray;      
     };
  
     bool WriteNull()
     {
         PutReserve(*os_, 4);
         PutUnsafe(*os_, 'n');
         PutUnsafe(*os_, 'u');
         PutUnsafe(*os_, 'l');
         PutUnsafe(*os_, 'l');
         return true;
     }
  
     bool WriteBool(bool b)
     {
         if(b)
         {
             PutReserve(*os_, 4);
             PutUnsafe(*os_, 't');
             PutUnsafe(*os_, 'r');
             PutUnsafe(*os_, 'u');
             PutUnsafe(*os_, 'e');
         }
         else
         {
             PutReserve(*os_, 5);
             PutUnsafe(*os_, 'f');
             PutUnsafe(*os_, 'a');
             PutUnsafe(*os_, 'l');
             PutUnsafe(*os_, 's');
             PutUnsafe(*os_, 'e');
         }
         return true;
     }
  
     bool WriteInt(int i)
     {
         char buffer[11];
         const char* end = internal::i32toa(i, buffer);
         PutReserve(*os_, static_cast<size_t>(end - buffer));
         for(const char* p = buffer; p != end; ++p)
             PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
         return true;
     }
  
     bool WriteUint(unsigned u)
     {
         char buffer[10];
         const char* end = internal::u32toa(u, buffer);
         PutReserve(*os_, static_cast<size_t>(end - buffer));
         for(const char* p = buffer; p != end; ++p)
             PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
         return true;
     }
  
     bool WriteInt64(int64_t i64)
     {
         char buffer[21];
         const char* end = internal::i64toa(i64, buffer);
         PutReserve(*os_, static_cast<size_t>(end - buffer));
         for(const char* p = buffer; p != end; ++p)
             PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
         return true;
     }
  
     bool WriteUint64(uint64_t u64)
     {
         char buffer[20];
         char* end = internal::u64toa(u64, buffer);
         PutReserve(*os_, static_cast<size_t>(end - buffer));
         for(char* p = buffer; p != end; ++p)
             PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
         return true;
     }
  
     bool WriteDouble(double d)
     {
         if(internal::Double(d).IsNanOrInf())
         {
             if(!(writeFlags & kWriteNanAndInfFlag) && !(writeFlags & kWriteNanAndInfNullFlag))
                 return false;
             if(writeFlags & kWriteNanAndInfNullFlag)
             {
                 PutReserve(*os_, 4);
                 PutUnsafe(*os_, 'n');
                 PutUnsafe(*os_, 'u');
                 PutUnsafe(*os_, 'l');
                 PutUnsafe(*os_, 'l');
                 return true;
             }
             if(internal::Double(d).IsNan())
             {
                 PutReserve(*os_, 3);
                 PutUnsafe(*os_, 'N');
                 PutUnsafe(*os_, 'a');
                 PutUnsafe(*os_, 'N');
                 return true;
             }
             if(internal::Double(d).Sign())
             {
                 PutReserve(*os_, 9);
                 PutUnsafe(*os_, '-');
             }
             else
                 PutReserve(*os_, 8);
             PutUnsafe(*os_, 'I');
             PutUnsafe(*os_, 'n');
             PutUnsafe(*os_, 'f');
             PutUnsafe(*os_, 'i');
             PutUnsafe(*os_, 'n');
             PutUnsafe(*os_, 'i');
             PutUnsafe(*os_, 't');
             PutUnsafe(*os_, 'y');
             return true;
         }
  
         char buffer[25];
         char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
         PutReserve(*os_, static_cast<size_t>(end - buffer));
         for(char* p = buffer; p != end; ++p)
             PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
         return true;
     }
  
     bool WriteString(const Ch* str, SizeType length)
     {
         static const typename OutputStream::Ch hexDigits[16] = {
             '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
         static const char escape[256] = {
 #define Z16 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
             // 0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
             'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f',  'r', 'u', 'u', // 00
             'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u', 'u', // 10
             0,   0,   '"', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   // 20
             Z16, Z16,                                                                      // 30~4F
             0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   '\\', 0,   0,   0, // 50
             Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                               // 60~FF
 #undef Z16
         };
  
         if(TargetEncoding::supportUnicode)
             PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
         else
             PutReserve(*os_, 2 + length * 12); // "\uxxxx\uyyyy..."
  
         PutUnsafe(*os_, '\"');
         GenericStringStream<SourceEncoding> is(str);
         while(ScanWriteUnescapedString(is, length))
         {
             const Ch c = is.Peek();
             if(!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80)
             {
                 // Unicode escaping
                 unsigned codepoint;
                 if(RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
                     return false;
                 PutUnsafe(*os_, '\\');
                 PutUnsafe(*os_, 'u');
                 if(codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF))
                 {
                     PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
                     PutUnsafe(*os_, hexDigits[(codepoint >> 8) & 15]);
                     PutUnsafe(*os_, hexDigits[(codepoint >> 4) & 15]);
                     PutUnsafe(*os_, hexDigits[(codepoint) & 15]);
                 }
                 else
                 {
                     RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
                     // Surrogate pair
                     unsigned s     = codepoint - 0x010000;
                     unsigned lead  = (s >> 10) + 0xD800;
                     unsigned trail = (s & 0x3FF) + 0xDC00;
                     PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
                     PutUnsafe(*os_, hexDigits[(lead >> 8) & 15]);
                     PutUnsafe(*os_, hexDigits[(lead >> 4) & 15]);
                     PutUnsafe(*os_, hexDigits[(lead) & 15]);
                     PutUnsafe(*os_, '\\');
                     PutUnsafe(*os_, 'u');
                     PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
                     PutUnsafe(*os_, hexDigits[(trail >> 8) & 15]);
                     PutUnsafe(*os_, hexDigits[(trail >> 4) & 15]);
                     PutUnsafe(*os_, hexDigits[(trail) & 15]);
                 }
             }
             else if((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) &&
                     RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))
             {
                 is.Take();
                 PutUnsafe(*os_, '\\');
                 PutUnsafe(
                     *os_,
                     static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
                 if(escape[static_cast<unsigned char>(c)] == 'u')
                 {
                     PutUnsafe(*os_, '0');
                     PutUnsafe(*os_, '0');
                     PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
                     PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
                 }
             }
             else if(RAPIDJSON_UNLIKELY(
                         !(writeFlags & kWriteValidateEncodingFlag
                               ? Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_)
                               : Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is,
                                                                                             *os_))))
                 return false;
         }
         PutUnsafe(*os_, '\"');
         return true;
     }
  
     bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length)
     {
         return RAPIDJSON_LIKELY(is.Tell() < length);
     }
  
     bool WriteStartObject()
     {
         os_->Put('{');
         return true;
     }
     bool WriteEndObject()
     {
         os_->Put('}');
         return true;
     }
     bool WriteStartArray()
     {
         os_->Put('[');
         return true;
     }
     bool WriteEndArray()
     {
         os_->Put(']');
         return true;
     }
  
     bool WriteRawValue(const Ch* json, size_t length)
     {
         PutReserve(*os_, length);
         GenericStringStream<SourceEncoding> is(json);
         while(RAPIDJSON_LIKELY(is.Tell() < length))
         {
             RAPIDJSON_ASSERT(is.Peek() != '\0');
             if(RAPIDJSON_UNLIKELY(
                    !(writeFlags & kWriteValidateEncodingFlag
                          ? Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_)
                          : Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
                 return false;
         }
         return true;
     }
  
     void Prefix(Type type)
     {
         (void)type;
         if(RAPIDJSON_LIKELY(level_stack_.GetSize() != 0))
         { // this value is not at root
             Level* level = level_stack_.template Top<Level>();
             if(level->valueCount > 0)
             {
                 if(level->inArray)
                     os_->Put(','); // add comma if it is not the first element in array
                 else               // in object
                     os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
             }
             if(!level->inArray && level->valueCount % 2 == 0)
                 RAPIDJSON_ASSERT(
                     type == kStringType); // if it's in object, then even number should be a name
             level->valueCount++;
         }
         else
         {
             RAPIDJSON_ASSERT(!hasRoot_); // Should only has one and only one root.
             hasRoot_ = true;
         }
     }
  
     // Flush the value if it is the top level one.
     bool EndValue(bool ret)
     {
         if(RAPIDJSON_UNLIKELY(level_stack_.Empty())) // end of json text
             Flush();
         return ret;
     }
  
     OutputStream* os_;
     internal::Stack<StackAllocator> level_stack_;
     int maxDecimalPlaces_;
     bool hasRoot_;
  
     private:
     // Prohibit copy constructor & assignment operator.
     Writer(const Writer&);
     Writer& operator=(const Writer&);
 };
  
 // Full specialization for StringStream to prevent memory copying
  
 template <>
 inline bool Writer<StringBuffer>::WriteInt(int i)
 {
     char* buffer    = os_->Push(11);
     const char* end = internal::i32toa(i, buffer);
     os_->Pop(static_cast<size_t>(11 - (end - buffer)));
     return true;
 }
  
 template <>
 inline bool Writer<StringBuffer>::WriteUint(unsigned u)
 {
     char* buffer    = os_->Push(10);
     const char* end = internal::u32toa(u, buffer);
     os_->Pop(static_cast<size_t>(10 - (end - buffer)));
     return true;
 }
  
 template <>
 inline bool Writer<StringBuffer>::WriteInt64(int64_t i64)
 {
     char* buffer    = os_->Push(21);
     const char* end = internal::i64toa(i64, buffer);
     os_->Pop(static_cast<size_t>(21 - (end - buffer)));
     return true;
 }
  
 template <>
 inline bool Writer<StringBuffer>::WriteUint64(uint64_t u)
 {
     char* buffer    = os_->Push(20);
     const char* end = internal::u64toa(u, buffer);
     os_->Pop(static_cast<size_t>(20 - (end - buffer)));
     return true;
 }
  
 template <>
 inline bool Writer<StringBuffer>::WriteDouble(double d)
 {
     if(internal::Double(d).IsNanOrInf())
     {
         // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS &
         // kWriteNanAndInfFlag).
         if(!(kWriteDefaultFlags & kWriteNanAndInfFlag))
             return false;
         if(kWriteDefaultFlags & kWriteNanAndInfNullFlag)
         {
             PutReserve(*os_, 4);
             PutUnsafe(*os_, 'n');
             PutUnsafe(*os_, 'u');
             PutUnsafe(*os_, 'l');
             PutUnsafe(*os_, 'l');
             return true;
         }
         if(internal::Double(d).IsNan())
         {
             PutReserve(*os_, 3);
             PutUnsafe(*os_, 'N');
             PutUnsafe(*os_, 'a');
             PutUnsafe(*os_, 'N');
             return true;
         }
         if(internal::Double(d).Sign())
         {
             PutReserve(*os_, 9);
             PutUnsafe(*os_, '-');
         }
         else
             PutReserve(*os_, 8);
         PutUnsafe(*os_, 'I');
         PutUnsafe(*os_, 'n');
         PutUnsafe(*os_, 'f');
         PutUnsafe(*os_, 'i');
         PutUnsafe(*os_, 'n');
         PutUnsafe(*os_, 'i');
         PutUnsafe(*os_, 't');
         PutUnsafe(*os_, 'y');
         return true;
     }
  
     char* buffer = os_->Push(25);
     char* end    = internal::dtoa(d, buffer, maxDecimalPlaces_);
     os_->Pop(static_cast<size_t>(25 - (end - buffer)));
     return true;
 }
  
 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
 template <>
 inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length)
 {
     if(length < 16)
         return RAPIDJSON_LIKELY(is.Tell() < length);
  
     if(!RAPIDJSON_LIKELY(is.Tell() < length))
         return false;
  
     const char* p           = is.src_;
     const char* end         = is.head_ + length;
     const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) &
                                                             static_cast<size_t>(~15));
     const char* endAligned =
         reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
     if(nextAligned > end)
         return true;
  
     while(p != nextAligned)
         if(*p < 0x20 || *p == '\"' || *p == '\\')
         {
             is.src_ = p;
             return RAPIDJSON_LIKELY(is.Tell() < length);
         }
         else
             os_->PutUnsafe(*p++);
  
     // The rest of string using SIMD
     static const char dquote[16] = {'\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"',
                                     '\"'};
     static const char bslash[16] = {'\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\',
                                     '\\'};
     static const char space[16]  = {0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F,
                                     0x1F};
     const __m128i dq             = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&dquote[0]));
     const __m128i bs             = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&bslash[0]));
     const __m128i sp             = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&space[0]));
  
     for(; p != endAligned; p += 16)
     {
         const __m128i s  = _mm_load_si128(reinterpret_cast<const __m128i*>(p));
         const __m128i t1 = _mm_cmpeq_epi8(s, dq);
         const __m128i t2 = _mm_cmpeq_epi8(s, bs);
         const __m128i t3 =
             _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
         const __m128i x  = _mm_or_si128(_mm_or_si128(t1, t2), t3);
         unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
         if(RAPIDJSON_UNLIKELY(r != 0))
         { // some of characters is escaped
             SizeType len;
 #ifdef _MSC_VER // Find the index of first escaped
             unsigned long offset;
             _BitScanForward(&offset, r);
             len = offset;
 #else
             len = static_cast<SizeType>(__builtin_ffs(r) - 1);
 #endif
             char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
             for(size_t i = 0; i < len; i++)
                 q[i] = p[i];
  
             p += len;
             break;
         }
         _mm_storeu_si128(reinterpret_cast<__m128i*>(os_->PushUnsafe(16)), s);
     }
  
     is.src_ = p;
     return RAPIDJSON_LIKELY(is.Tell() < length);
 }
 #elif defined(RAPIDJSON_NEON)
 template <>
 inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length)
 {
     if(length < 16)
         return RAPIDJSON_LIKELY(is.Tell() < length);
  
     if(!RAPIDJSON_LIKELY(is.Tell() < length))
         return false;
  
     const char* p           = is.src_;
     const char* end         = is.head_ + length;
     const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) &
                                                             static_cast<size_t>(~15));
     const char* endAligned =
         reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
     if(nextAligned > end)
         return true;
  
     while(p != nextAligned)
         if(*p < 0x20 || *p == '\"' || *p == '\\')
         {
             is.src_ = p;
             return RAPIDJSON_LIKELY(is.Tell() < length);
         }
         else
             os_->PutUnsafe(*p++);
  
     // The rest of string using SIMD
     const uint8x16_t s0 = vmovq_n_u8('"');
     const uint8x16_t s1 = vmovq_n_u8('\\');
     const uint8x16_t s2 = vmovq_n_u8('\b');
     const uint8x16_t s3 = vmovq_n_u8(32);
  
     for(; p != endAligned; p += 16)
     {
         const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t*>(p));
         uint8x16_t x       = vceqq_u8(s, s0);
         x                  = vorrq_u8(x, vceqq_u8(s, s1));
         x                  = vorrq_u8(x, vceqq_u8(s, s2));
         x                  = vorrq_u8(x, vcltq_u8(s, s3));
  
         x             = vrev64q_u8(x);                              // Rev in 64
         uint64_t low  = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
         uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
  
         SizeType len = 0;
         bool escaped = false;
         if(low == 0)
         {
             if(high != 0)
             {
                 uint32_t lz = internal::clzll(high);
                 len         = 8 + (lz >> 3);
                 escaped     = true;
             }
         }
         else
         {
             uint32_t lz = internal::clzll(low);
             len         = lz >> 3;
             escaped     = true;
         }
         if(RAPIDJSON_UNLIKELY(escaped))
         { // some of characters is escaped
             char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
             for(size_t i = 0; i < len; i++)
                 q[i] = p[i];
  
             p += len;
             break;
         }
         vst1q_u8(reinterpret_cast<uint8_t*>(os_->PushUnsafe(16)), s);
     }
  
     is.src_ = p;
     return RAPIDJSON_LIKELY(is.Tell() < length);
 }
 #endif // RAPIDJSON_NEON
  
 RAPIDJSON_NAMESPACE_END
  
 #if defined(_MSC_VER) || defined(__clang__)
 RAPIDJSON_DIAG_POP
 #endif
  
 #endif // RAPIDJSON_RAPIDJSON_H_