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_ENCODEDSTREAM_H_
16 #define RAPIDJSON_ENCODEDSTREAM_H_
17 
18 #include "stream.h"
19 #include "memorystream.h"
20 
21 #ifdef __GNUC__
22 RAPIDJSON_DIAG_PUSH
23 RAPIDJSON_DIAG_OFF(effc++)
24 #endif
25 
26 #ifdef __clang__
27 RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)28 RAPIDJSON_DIAG_OFF(padded)
29 #endif
30 
31 RAPIDJSON_NAMESPACE_BEGIN
32 
33 //! Input byte stream wrapper with a statically bound encoding.
34 /*!
35     \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
36     \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
37 */
38 template <typename Encoding, typename InputByteStream>
39 class EncodedInputStream {
40     RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
41 public:
42     typedef typename Encoding::Ch Ch;
43 
44     EncodedInputStream(InputByteStream& is) : is_(is) {
45         current_ = Encoding::TakeBOM(is_);
46     }
47 
48     Ch Peek() const { return current_; }
49     Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
50     size_t Tell() const { return is_.Tell(); }
51 
52     // Not implemented
53     void Put(Ch) { RAPIDJSON_ASSERT(false); }
54     void Flush() { RAPIDJSON_ASSERT(false); }
55     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
56     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
57 
58 private:
59     EncodedInputStream(const EncodedInputStream&);
60     EncodedInputStream& operator=(const EncodedInputStream&);
61 
62     InputByteStream& is_;
63     Ch current_;
64 };
65 
66 //! Specialized for UTF8 MemoryStream.
67 template <>
68 class EncodedInputStream<UTF8<>, MemoryStream> {
69 public:
70     typedef UTF8<>::Ch Ch;
71 
EncodedInputStream(MemoryStream & is)72     EncodedInputStream(MemoryStream& is) : is_(is) {
73         if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
74         if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
75         if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
76     }
Peek()77     Ch Peek() const { return is_.Peek(); }
Take()78     Ch Take() { return is_.Take(); }
Tell()79     size_t Tell() const { return is_.Tell(); }
80 
81     // Not implemented
Put(Ch)82     void Put(Ch) {}
Flush()83     void Flush() {}
PutBegin()84     Ch* PutBegin() { return 0; }
PutEnd(Ch *)85     size_t PutEnd(Ch*) { return 0; }
86 
87     MemoryStream& is_;
88 
89 private:
90     EncodedInputStream(const EncodedInputStream&);
91     EncodedInputStream& operator=(const EncodedInputStream&);
92 };
93 
94 //! Output byte stream wrapper with statically bound encoding.
95 /*!
96     \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
97     \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
98 */
99 template <typename Encoding, typename OutputByteStream>
100 class EncodedOutputStream {
101     RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
102 public:
103     typedef typename Encoding::Ch Ch;
104 
os_(os)105     EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) {
106         if (putBOM)
107             Encoding::PutBOM(os_);
108     }
109 
Put(Ch c)110     void Put(Ch c) { Encoding::Put(os_, c);  }
Flush()111     void Flush() { os_.Flush(); }
112 
113     // Not implemented
Peek()114     Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Take()115     Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
Tell()116     size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }
PutBegin()117     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
PutEnd(Ch *)118     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
119 
120 private:
121     EncodedOutputStream(const EncodedOutputStream&);
122     EncodedOutputStream& operator=(const EncodedOutputStream&);
123 
124     OutputByteStream& os_;
125 };
126 
127 #define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
128 
129 //! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
130 /*!
131     \tparam CharType Type of character for reading.
132     \tparam InputByteStream type of input byte stream to be wrapped.
133 */
134 template <typename CharType, typename InputByteStream>
135 class AutoUTFInputStream {
136     RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
137 public:
138     typedef CharType Ch;
139 
140     //! Constructor.
141     /*!
142         \param is input stream to be wrapped.
143         \param type UTF encoding type if it is not detected from the stream.
144     */
145     AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
146         RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
147         DetectType();
148         static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
149         takeFunc_ = f[type_];
150         current_ = takeFunc_(*is_);
151     }
152 
GetType()153     UTFType GetType() const { return type_; }
HasBOM()154     bool HasBOM() const { return hasBOM_; }
155 
Peek()156     Ch Peek() const { return current_; }
Take()157     Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
Tell()158     size_t Tell() const { return is_->Tell(); }
159 
160     // Not implemented
Put(Ch)161     void Put(Ch) { RAPIDJSON_ASSERT(false); }
Flush()162     void Flush() { RAPIDJSON_ASSERT(false); }
PutBegin()163     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
PutEnd(Ch *)164     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
165 
166 private:
167     AutoUTFInputStream(const AutoUTFInputStream&);
168     AutoUTFInputStream& operator=(const AutoUTFInputStream&);
169 
170     // Detect encoding type with BOM or RFC 4627
DetectType()171     void DetectType() {
172         // BOM (Byte Order Mark):
173         // 00 00 FE FF  UTF-32BE
174         // FF FE 00 00  UTF-32LE
175         // FE FF        UTF-16BE
176         // FF FE        UTF-16LE
177         // EF BB BF     UTF-8
178 
179         const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
180         if (!c)
181             return;
182 
183         unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
184         hasBOM_ = false;
185         if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
186         else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
187         else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
188         else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
189         else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
190 
191         // RFC 4627: Section 3
192         // "Since the first two characters of a JSON text will always be ASCII
193         // characters [RFC0020], it is possible to determine whether an octet
194         // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
195         // at the pattern of nulls in the first four octets."
196         // 00 00 00 xx  UTF-32BE
197         // 00 xx 00 xx  UTF-16BE
198         // xx 00 00 00  UTF-32LE
199         // xx 00 xx 00  UTF-16LE
200         // xx xx xx xx  UTF-8
201 
202         if (!hasBOM_) {
203             int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
204             switch (pattern) {
205             case 0x08: type_ = kUTF32BE; break;
206             case 0x0A: type_ = kUTF16BE; break;
207             case 0x01: type_ = kUTF32LE; break;
208             case 0x05: type_ = kUTF16LE; break;
209             case 0x0F: type_ = kUTF8;    break;
210             default: break; // Use type defined by user.
211             }
212         }
213 
214         // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
215         if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
216         if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
217     }
218 
219     typedef Ch (*TakeFunc)(InputByteStream& is);
220     InputByteStream* is_;
221     UTFType type_;
222     Ch current_;
223     TakeFunc takeFunc_;
224     bool hasBOM_;
225 };
226 
227 //! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
228 /*!
229     \tparam CharType Type of character for writing.
230     \tparam OutputByteStream type of output byte stream to be wrapped.
231 */
232 template <typename CharType, typename OutputByteStream>
233 class AutoUTFOutputStream {
234     RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
235 public:
236     typedef CharType Ch;
237 
238     //! Constructor.
239     /*!
240         \param os output stream to be wrapped.
241         \param type UTF encoding type.
242         \param putBOM Whether to write BOM at the beginning of the stream.
243     */
AutoUTFOutputStream(OutputByteStream & os,UTFType type,bool putBOM)244     AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
245         RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
246 
247         // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
248         if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
249         if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
250 
251         static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
252         putFunc_ = f[type_];
253 
254         if (putBOM)
255             PutBOM();
256     }
257 
GetType()258     UTFType GetType() const { return type_; }
259 
Put(Ch c)260     void Put(Ch c) { putFunc_(*os_, c); }
Flush()261     void Flush() { os_->Flush(); }
262 
263     // Not implemented
Peek()264     Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Take()265     Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
Tell()266     size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
PutBegin()267     Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
PutEnd(Ch *)268     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
269 
270 private:
271     AutoUTFOutputStream(const AutoUTFOutputStream&);
272     AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
273 
PutBOM()274     void PutBOM() {
275         typedef void (*PutBOMFunc)(OutputByteStream&);
276         static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
277         f[type_](*os_);
278     }
279 
280     typedef void (*PutFunc)(OutputByteStream&, Ch);
281 
282     OutputByteStream* os_;
283     UTFType type_;
284     PutFunc putFunc_;
285 };
286 
287 #undef RAPIDJSON_ENCODINGS_FUNC
288 
289 RAPIDJSON_NAMESPACE_END
290 
291 #ifdef __clang__
292 RAPIDJSON_DIAG_POP
293 #endif
294 
295 #ifdef __GNUC__
296 RAPIDJSON_DIAG_POP
297 #endif
298 
299 #endif // RAPIDJSON_FILESTREAM_H_
300