writer.h
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14 
15 #ifndef RAPIDJSON_WRITER_H_
16 #define RAPIDJSON_WRITER_H_
17 
18 #include "stream.h"
19 #include "internal/meta.h"
20 #include "internal/stack.h"
21 #include "internal/strfunc.h"
22 #include "internal/dtoa.h"
23 #include "internal/itoa.h"
24 #include "stringbuffer.h"
25 #include <new> // placement new
26 
27 #if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
28 #include <intrin.h>
29 #pragma intrinsic(_BitScanForward)
30 #endif
31 #ifdef RAPIDJSON_SSE42
32 #include <nmmintrin.h>
33 #elif defined(RAPIDJSON_SSE2)
34 #include <emmintrin.h>
35 #elif defined(RAPIDJSON_NEON)
36 #include <arm_neon.h>
37 #endif
38 
39 #ifdef __clang__
40 RAPIDJSON_DIAG_PUSH
41 RAPIDJSON_DIAG_OFF(padded)
42 RAPIDJSON_DIAG_OFF(unreachable-code)
43 RAPIDJSON_DIAG_OFF(c++98-compat)
44 #elif defined(_MSC_VER)
45 RAPIDJSON_DIAG_PUSH
46 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
47 #endif
48 
49 RAPIDJSON_NAMESPACE_BEGIN
50 
51 ///////////////////////////////////////////////////////////////////////////////
52 // WriteFlag
53 
54 /*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS
55  \ingroup RAPIDJSON_CONFIG
56  \brief User-defined kWriteDefaultFlags definition.
57 
58  User can define this as any \c WriteFlag combinations.
59 */
60 #ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
61 #define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
62 #endif
63 
64 //! Combination of writeFlags
65 enum WriteFlag {
66  kWriteNoFlags = 0, //!< No flags are set.
67  kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
68  kWriteNanAndInfFlag = 2, //!< Allow writing of Infinity, -Infinity and NaN.
69  kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
70 };
71 
72 //! JSON writer
73 /*! Writer implements the concept Handler.
74  It generates JSON text by events to an output os.
75 
76  User may programmatically calls the functions of a writer to generate JSON text.
77 
78  On the other side, a writer can also be passed to objects that generates events,
79 
80  for example Reader::Parse() and Document::Accept().
81 
82  \tparam OutputStream Type of output stream.
83  \tparam SourceEncoding Encoding of source string.
84  \tparam TargetEncoding Encoding of output stream.
85  \tparam StackAllocator Type of allocator for allocating memory of stack.
86  \note implements Handler concept
87 */
88 template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
89 class Writer {
90 public:
91  typedef typename SourceEncoding::Ch Ch;
92 
93  static const int kDefaultMaxDecimalPlaces = 324;
94 
95  //! Constructor
96  /*! \param os Output stream.
97  \param stackAllocator User supplied allocator. If it is null, it will create a private one.
98  \param levelDepth Initial capacity of stack.
99  */
100  explicit
101  Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) :
102  os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
103 
104  explicit
105  Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
106  os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
107 
108 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
109  Writer(Writer&& rhs) :
110  os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) {
111  rhs.os_ = 0;
112  }
113 #endif
114 
115  //! Reset the writer with a new stream.
116  /*!
117  This function reset the writer with a new stream and default settings,
118  in order to make a Writer object reusable for output multiple JSONs.
119 
120  \param os New output stream.
121  \code
122  Writer<OutputStream> writer(os1);
123  writer.StartObject();
124  // ...
125  writer.EndObject();
126 
127  writer.Reset(os2);
128  writer.StartObject();
129  // ...
130  writer.EndObject();
131  \endcode
132  */
133  void Reset(OutputStream& os) {
134  os_ = &os;
135  hasRoot_ = false;
136  level_stack_.Clear();
137  }
138 
139  //! Checks whether the output is a complete JSON.
140  /*!
141  A complete JSON has a complete root object or array.
142  */
143  bool IsComplete() const {
144  return hasRoot_ && level_stack_.Empty();
145  }
146 
147  int GetMaxDecimalPlaces() const {
148  return maxDecimalPlaces_;
149  }
150 
151  //! Sets the maximum number of decimal places for double output.
152  /*!
153  This setting truncates the output with specified number of decimal places.
154 
155  For example,
156 
157  \code
158  writer.SetMaxDecimalPlaces(3);
159  writer.StartArray();
160  writer.Double(0.12345); // "0.123"
161  writer.Double(0.0001); // "0.0"
162  writer.Double(1.234567890123456e30); // "1.234567890123456e30" (do not truncate significand for positive exponent)
163  writer.Double(1.23e-4); // "0.0" (do truncate significand for negative exponent)
164  writer.EndArray();
165  \endcode
166 
167  The default setting does not truncate any decimal places. You can restore to this setting by calling
168  \code
169  writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
170  \endcode
171  */
172  void SetMaxDecimalPlaces(int maxDecimalPlaces) {
173  maxDecimalPlaces_ = maxDecimalPlaces;
174  }
175 
176  /*!@name Implementation of Handler
177  \see Handler
178  */
179  //@{
180 
181  bool Null() { Prefix(kNullType); return EndValue(WriteNull()); }
182  bool Bool(bool b) { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); }
183  bool Int(int i) { Prefix(kNumberType); return EndValue(WriteInt(i)); }
184  bool Uint(unsigned u) { Prefix(kNumberType); return EndValue(WriteUint(u)); }
185  bool Int64(int64_t i64) { Prefix(kNumberType); return EndValue(WriteInt64(i64)); }
186  bool Uint64(uint64_t u64) { Prefix(kNumberType); return EndValue(WriteUint64(u64)); }
187 
188  //! Writes the given \c double value to the stream
189  /*!
190  \param d The value to be written.
191  \return Whether it is succeed.
192  */
193  bool Double(double d) { Prefix(kNumberType); return EndValue(WriteDouble(d)); }
194 
195  bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
196  RAPIDJSON_ASSERT(str != 0);
197  (void)copy;
198  Prefix(kNumberType);
199  return EndValue(WriteString(str, length));
200  }
201 
202  bool String(const Ch* str, SizeType length, bool copy = false) {
203  RAPIDJSON_ASSERT(str != 0);
204  (void)copy;
205  Prefix(kStringType);
206  return EndValue(WriteString(str, length));
207  }
208 
209 #if RAPIDJSON_HAS_STDSTRING
210  bool String(const std::basic_string<Ch>& str) {
211  return String(str.data(), SizeType(str.size()));
212  }
213 #endif
214 
215  bool StartObject() {
216  Prefix(kObjectType);
217  new (level_stack_.template Push<Level>()) Level(false);
218  return WriteStartObject();
219  }
220 
221  bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
222 
223 #if RAPIDJSON_HAS_STDSTRING
224  bool Key(const std::basic_string<Ch>& str)
225  {
226  return Key(str.data(), SizeType(str.size()));
227  }
228 #endif
229 
230  bool EndObject(SizeType memberCount = 0) {
231  (void)memberCount;
232  RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
233  RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
234  RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
235  level_stack_.template Pop<Level>(1);
236  return EndValue(WriteEndObject());
237  }
238 
239  bool StartArray() {
240  Prefix(kArrayType);
241  new (level_stack_.template Push<Level>()) Level(true);
242  return WriteStartArray();
243  }
244 
245  bool EndArray(SizeType elementCount = 0) {
246  (void)elementCount;
247  RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
248  RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
249  level_stack_.template Pop<Level>(1);
250  return EndValue(WriteEndArray());
251  }
252  //@}
253 
254  /*! @name Convenience extensions */
255  //@{
256 
257  //! Simpler but slower overload.
258  bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); }
259  bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
260 
261  //@}
262 
263  //! Write a raw JSON value.
264  /*!
265  For user to write a stringified JSON as a value.
266 
267  \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
268  \param length Length of the json.
269  \param type Type of the root of json.
270  */
271  bool RawValue(const Ch* json, size_t length, Type type) {
272  RAPIDJSON_ASSERT(json != 0);
273  Prefix(type);
274  return EndValue(WriteRawValue(json, length));
275  }
276 
277  //! Flush the output stream.
278  /*!
279  Allows the user to flush the output stream immediately.
280  */
281  void Flush() {
282  os_->Flush();
283  }
284 
285 protected:
286  //! Information for each nested level
287  struct Level {
288  Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
289  size_t valueCount; //!< number of values in this level
290  bool inArray; //!< true if in array, otherwise in object
291  };
292 
293  static const size_t kDefaultLevelDepth = 32;
294 
295  bool WriteNull() {
296  PutReserve(*os_, 4);
297  PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
298  }
299 
300  bool WriteBool(bool b) {
301  if (b) {
302  PutReserve(*os_, 4);
303  PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
304  }
305  else {
306  PutReserve(*os_, 5);
307  PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
308  }
309  return true;
310  }
311 
312  bool WriteInt(int i) {
313  char buffer[11];
314  const char* end = internal::i32toa(i, buffer);
315  PutReserve(*os_, static_cast<size_t>(end - buffer));
316  for (const char* p = buffer; p != end; ++p)
317  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
318  return true;
319  }
320 
321  bool WriteUint(unsigned u) {
322  char buffer[10];
323  const char* end = internal::u32toa(u, buffer);
324  PutReserve(*os_, static_cast<size_t>(end - buffer));
325  for (const char* p = buffer; p != end; ++p)
326  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
327  return true;
328  }
329 
330  bool WriteInt64(int64_t i64) {
331  char buffer[21];
332  const char* end = internal::i64toa(i64, buffer);
333  PutReserve(*os_, static_cast<size_t>(end - buffer));
334  for (const char* p = buffer; p != end; ++p)
335  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
336  return true;
337  }
338 
339  bool WriteUint64(uint64_t u64) {
340  char buffer[20];
341  char* end = internal::u64toa(u64, buffer);
342  PutReserve(*os_, static_cast<size_t>(end - buffer));
343  for (char* p = buffer; p != end; ++p)
344  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
345  return true;
346  }
347 
348  bool WriteDouble(double d) {
349  if (internal::Double(d).IsNanOrInf()) {
350  if (!(writeFlags & kWriteNanAndInfFlag))
351  return false;
352  if (internal::Double(d).IsNan()) {
353  PutReserve(*os_, 3);
354  PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
355  return true;
356  }
357  if (internal::Double(d).Sign()) {
358  PutReserve(*os_, 9);
359  PutUnsafe(*os_, '-');
360  }
361  else
362  PutReserve(*os_, 8);
363  PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
364  PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
365  return true;
366  }
367 
368  char buffer[25];
369  char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
370  PutReserve(*os_, static_cast<size_t>(end - buffer));
371  for (char* p = buffer; p != end; ++p)
372  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
373  return true;
374  }
375 
376  bool WriteString(const Ch* str, SizeType length) {
377  static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
378  static const char escape[256] = {
379 #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
380  //0 1 2 3 4 5 6 7 8 9 A B C D E F
381  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
382  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
383  0, 0, '"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20
384  Z16, Z16, // 30~4F
385  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, // 50
386  Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 // 60~FF
387 #undef Z16
388  };
389 
390  if (TargetEncoding::supportUnicode)
391  PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
392  else
393  PutReserve(*os_, 2 + length * 12); // "\uxxxx\uyyyy..."
394 
395  PutUnsafe(*os_, '\"');
397  while (ScanWriteUnescapedString(is, length)) {
398  const Ch c = is.Peek();
399  if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
400  // Unicode escaping
401  unsigned codepoint;
402  if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
403  return false;
404  PutUnsafe(*os_, '\\');
405  PutUnsafe(*os_, 'u');
406  if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
407  PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
408  PutUnsafe(*os_, hexDigits[(codepoint >> 8) & 15]);
409  PutUnsafe(*os_, hexDigits[(codepoint >> 4) & 15]);
410  PutUnsafe(*os_, hexDigits[(codepoint ) & 15]);
411  }
412  else {
413  RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
414  // Surrogate pair
415  unsigned s = codepoint - 0x010000;
416  unsigned lead = (s >> 10) + 0xD800;
417  unsigned trail = (s & 0x3FF) + 0xDC00;
418  PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
419  PutUnsafe(*os_, hexDigits[(lead >> 8) & 15]);
420  PutUnsafe(*os_, hexDigits[(lead >> 4) & 15]);
421  PutUnsafe(*os_, hexDigits[(lead ) & 15]);
422  PutUnsafe(*os_, '\\');
423  PutUnsafe(*os_, 'u');
424  PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
425  PutUnsafe(*os_, hexDigits[(trail >> 8) & 15]);
426  PutUnsafe(*os_, hexDigits[(trail >> 4) & 15]);
427  PutUnsafe(*os_, hexDigits[(trail ) & 15]);
428  }
429  }
430  else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)])) {
431  is.Take();
432  PutUnsafe(*os_, '\\');
433  PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
434  if (escape[static_cast<unsigned char>(c)] == 'u') {
435  PutUnsafe(*os_, '0');
436  PutUnsafe(*os_, '0');
437  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
438  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
439  }
440  }
441  else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
444  return false;
445  }
446  PutUnsafe(*os_, '\"');
447  return true;
448  }
449 
450  bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
451  return RAPIDJSON_LIKELY(is.Tell() < length);
452  }
453 
454  bool WriteStartObject() { os_->Put('{'); return true; }
455  bool WriteEndObject() { os_->Put('}'); return true; }
456  bool WriteStartArray() { os_->Put('['); return true; }
457  bool WriteEndArray() { os_->Put(']'); return true; }
458 
459  bool WriteRawValue(const Ch* json, size_t length) {
460  PutReserve(*os_, length);
462  while (RAPIDJSON_LIKELY(is.Tell() < length)) {
463  RAPIDJSON_ASSERT(is.Peek() != '\0');
464  if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
467  return false;
468  }
469  return true;
470  }
471 
472  void Prefix(Type type) {
473  (void)type;
474  if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
475  Level* level = level_stack_.template Top<Level>();
476  if (level->valueCount > 0) {
477  if (level->inArray)
478  os_->Put(','); // add comma if it is not the first element in array
479  else // in object
480  os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
481  }
482  if (!level->inArray && level->valueCount % 2 == 0)
483  RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name
484  level->valueCount++;
485  }
486  else {
487  RAPIDJSON_ASSERT(!hasRoot_); // Should only has one and only one root.
488  hasRoot_ = true;
489  }
490  }
491 
492  // Flush the value if it is the top level one.
493  bool EndValue(bool ret) {
494  if (RAPIDJSON_UNLIKELY(level_stack_.Empty())) // end of json text
495  Flush();
496  return ret;
497  }
498 
499  OutputStream* os_;
500  internal::Stack<StackAllocator> level_stack_;
501  int maxDecimalPlaces_;
502  bool hasRoot_;
503 
504 private:
505  // Prohibit copy constructor & assignment operator.
506  Writer(const Writer&);
507  Writer& operator=(const Writer&);
508 };
509 
510 // Full specialization for StringStream to prevent memory copying
511 
512 template<>
513 inline bool Writer<StringBuffer>::WriteInt(int i) {
514  char *buffer = os_->Push(11);
515  const char* end = internal::i32toa(i, buffer);
516  os_->Pop(static_cast<size_t>(11 - (end - buffer)));
517  return true;
518 }
519 
520 template<>
521 inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
522  char *buffer = os_->Push(10);
523  const char* end = internal::u32toa(u, buffer);
524  os_->Pop(static_cast<size_t>(10 - (end - buffer)));
525  return true;
526 }
527 
528 template<>
529 inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
530  char *buffer = os_->Push(21);
531  const char* end = internal::i64toa(i64, buffer);
532  os_->Pop(static_cast<size_t>(21 - (end - buffer)));
533  return true;
534 }
535 
536 template<>
537 inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
538  char *buffer = os_->Push(20);
539  const char* end = internal::u64toa(u, buffer);
540  os_->Pop(static_cast<size_t>(20 - (end - buffer)));
541  return true;
542 }
543 
544 template<>
545 inline bool Writer<StringBuffer>::WriteDouble(double d) {
546  if (internal::Double(d).IsNanOrInf()) {
547  // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
549  return false;
550  if (internal::Double(d).IsNan()) {
551  PutReserve(*os_, 3);
552  PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
553  return true;
554  }
555  if (internal::Double(d).Sign()) {
556  PutReserve(*os_, 9);
557  PutUnsafe(*os_, '-');
558  }
559  else
560  PutReserve(*os_, 8);
561  PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
562  PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
563  return true;
564  }
565 
566  char *buffer = os_->Push(25);
567  char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
568  os_->Pop(static_cast<size_t>(25 - (end - buffer)));
569  return true;
570 }
571 
572 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
573 template<>
574 inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
575  if (length < 16)
576  return RAPIDJSON_LIKELY(is.Tell() < length);
577 
578  if (!RAPIDJSON_LIKELY(is.Tell() < length))
579  return false;
580 
581  const char* p = is.src_;
582  const char* end = is.head_ + length;
583  const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
584  const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
585  if (nextAligned > end)
586  return true;
587 
588  while (p != nextAligned)
589  if (*p < 0x20 || *p == '\"' || *p == '\\') {
590  is.src_ = p;
591  return RAPIDJSON_LIKELY(is.Tell() < length);
592  }
593  else
594  os_->PutUnsafe(*p++);
595 
596  // The rest of string using SIMD
597  static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
598  static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
599  static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
600  const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
601  const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
602  const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
603 
604  for (; p != endAligned; p += 16) {
605  const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
606  const __m128i t1 = _mm_cmpeq_epi8(s, dq);
607  const __m128i t2 = _mm_cmpeq_epi8(s, bs);
608  const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
609  const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
610  unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
611  if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
612  SizeType len;
613 #ifdef _MSC_VER // Find the index of first escaped
614  unsigned long offset;
615  _BitScanForward(&offset, r);
616  len = offset;
617 #else
618  len = static_cast<SizeType>(__builtin_ffs(r) - 1);
619 #endif
620  char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
621  for (size_t i = 0; i < len; i++)
622  q[i] = p[i];
623 
624  p += len;
625  break;
626  }
627  _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
628  }
629 
630  is.src_ = p;
631  return RAPIDJSON_LIKELY(is.Tell() < length);
632 }
633 #elif defined(RAPIDJSON_NEON)
634 template<>
635 inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
636  if (length < 16)
637  return RAPIDJSON_LIKELY(is.Tell() < length);
638 
639  if (!RAPIDJSON_LIKELY(is.Tell() < length))
640  return false;
641 
642  const char* p = is.src_;
643  const char* end = is.head_ + length;
644  const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
645  const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
646  if (nextAligned > end)
647  return true;
648 
649  while (p != nextAligned)
650  if (*p < 0x20 || *p == '\"' || *p == '\\') {
651  is.src_ = p;
652  return RAPIDJSON_LIKELY(is.Tell() < length);
653  }
654  else
655  os_->PutUnsafe(*p++);
656 
657  // The rest of string using SIMD
658  const uint8x16_t s0 = vmovq_n_u8('"');
659  const uint8x16_t s1 = vmovq_n_u8('\\');
660  const uint8x16_t s2 = vmovq_n_u8('\b');
661  const uint8x16_t s3 = vmovq_n_u8(32);
662 
663  for (; p != endAligned; p += 16) {
664  const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
665  uint8x16_t x = vceqq_u8(s, s0);
666  x = vorrq_u8(x, vceqq_u8(s, s1));
667  x = vorrq_u8(x, vceqq_u8(s, s2));
668  x = vorrq_u8(x, vcltq_u8(s, s3));
669 
670  x = vrev64q_u8(x); // Rev in 64
671  uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0); // extract
672  uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1); // extract
673 
674  SizeType len = 0;
675  bool escaped = false;
676  if (low == 0) {
677  if (high != 0) {
678  unsigned lz = (unsigned)__builtin_clzll(high);
679  len = 8 + (lz >> 3);
680  escaped = true;
681  }
682  } else {
683  unsigned lz = (unsigned)__builtin_clzll(low);
684  len = lz >> 3;
685  escaped = true;
686  }
687  if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
688  char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
689  for (size_t i = 0; i < len; i++)
690  q[i] = p[i];
691 
692  p += len;
693  break;
694  }
695  vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
696  }
697 
698  is.src_ = p;
699  return RAPIDJSON_LIKELY(is.Tell() < length);
700 }
701 #endif // RAPIDJSON_NEON
702 
703 RAPIDJSON_NAMESPACE_END
704 
705 #if defined(_MSC_VER) || defined(__clang__)
706 RAPIDJSON_DIAG_POP
707 #endif
708 
709 #endif // RAPIDJSON_RAPIDJSON_H_
true
Definition: rapidjson.h:645
bool inArray
true if in array, otherwise in object
Definition: writer.h:290
void SetMaxDecimalPlaces(int maxDecimalPlaces)
Sets the maximum number of decimal places for double output.
Definition: writer.h:172
Read-only string stream.
Definition: fwd.h:47
No flags are set.
Definition: writer.h:66
Encoding conversion.
Definition: encodings.h:658
bool IsComplete() const
Checks whether the output is a complete JSON.
Definition: writer.h:143
Validate encoding of JSON strings.
Definition: writer.h:67
void PutReserve(Stream &stream, size_t count)
Reserve n characters for writing to a stream.
Definition: stream.h:84
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:384
bool String(const Ch *const &str)
Simpler but slower overload.
Definition: writer.h:258
WriteFlag
Combination of writeFlags.
Definition: writer.h:65
false
Definition: rapidjson.h:644
const Ch * head_
Original head of the string.
Definition: stream.h:169
bool RawValue(const Ch *json, size_t length, Type type)
Write a raw JSON value.
Definition: writer.h:271
const Ch * src_
Current read position.
Definition: stream.h:168
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
Definition: rapidjson.h:463
Information for each nested level.
Definition: writer.h:287
size_t valueCount
number of values in this level
Definition: writer.h:289
Type
Type of JSON value.
Definition: rapidjson.h:642
object
Definition: rapidjson.h:646
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
Definition: rapidjson.h:476
array
Definition: rapidjson.h:647
JSON writer.
Definition: fwd.h:95
null
Definition: rapidjson.h:643
string
Definition: rapidjson.h:648
Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS. ...
Definition: writer.h:69
void Flush()
Flush the output stream.
Definition: writer.h:281
#define RAPIDJSON_WRITE_DEFAULT_FLAGS
User-defined kWriteDefaultFlags definition.
Definition: writer.h:61
bool Double(double d)
Writes the given double value to the stream.
Definition: writer.h:193
void PutUnsafe(Stream &stream, typename Stream::Ch c)
Write character to a stream, presuming buffer is reserved.
Definition: stream.h:91
Writer(OutputStream &os, StackAllocator *stackAllocator=0, size_t levelDepth=kDefaultLevelDepth)
Constructor.
Definition: writer.h:101
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:406
void Reset(OutputStream &os)
Reset the writer with a new stream.
Definition: writer.h:133
number
Definition: rapidjson.h:649
Allow writing of Infinity, -Infinity and NaN.
Definition: writer.h:68