itoa.h
Go to the documentation of this file.
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_ITOA_
16 #define RAPIDJSON_ITOA_
17 
18 #include "../rapidjson.h"
19 
20 RAPIDJSON_NAMESPACE_BEGIN
21 namespace internal
22 {
23 inline const char* GetDigitsLut()
24 {
25  static const char cDigitsLut[200] = {
26  '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '1', '0', '1',
27  '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2', '2',
28  '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', '3', '0', '3', '1', '3', '2', '3', '3', '3',
29  '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', '4', '5',
30  '4', '6', '4', '7', '4', '8', '4', '9', '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5',
31  '7', '5', '8', '5', '9', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8',
32  '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '8',
33  '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '9', '0', '9', '1',
34  '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
35  };
36  return cDigitsLut;
37 }
38 
39 inline char* u32toa(uint32_t value, char* buffer)
40 {
41  RAPIDJSON_ASSERT(buffer != 0);
42 
43  const char* cDigitsLut = GetDigitsLut();
44 
45  if (value < 10000)
46  {
47  const uint32_t d1 = (value / 100) << 1;
48  const uint32_t d2 = (value % 100) << 1;
49 
50  if (value >= 1000)
51  *buffer++ = cDigitsLut[d1];
52  if (value >= 100)
53  *buffer++ = cDigitsLut[d1 + 1];
54  if (value >= 10)
55  *buffer++ = cDigitsLut[d2];
56  *buffer++ = cDigitsLut[d2 + 1];
57  }
58  else if (value < 100000000)
59  {
60  // value = bbbbcccc
61  const uint32_t b = value / 10000;
62  const uint32_t c = value % 10000;
63 
64  const uint32_t d1 = (b / 100) << 1;
65  const uint32_t d2 = (b % 100) << 1;
66 
67  const uint32_t d3 = (c / 100) << 1;
68  const uint32_t d4 = (c % 100) << 1;
69 
70  if (value >= 10000000)
71  *buffer++ = cDigitsLut[d1];
72  if (value >= 1000000)
73  *buffer++ = cDigitsLut[d1 + 1];
74  if (value >= 100000)
75  *buffer++ = cDigitsLut[d2];
76  *buffer++ = cDigitsLut[d2 + 1];
77 
78  *buffer++ = cDigitsLut[d3];
79  *buffer++ = cDigitsLut[d3 + 1];
80  *buffer++ = cDigitsLut[d4];
81  *buffer++ = cDigitsLut[d4 + 1];
82  }
83  else
84  {
85  // value = aabbbbcccc in decimal
86 
87  const uint32_t a = value / 100000000; // 1 to 42
88  value %= 100000000;
89 
90  if (a >= 10)
91  {
92  const unsigned i = a << 1;
93  *buffer++ = cDigitsLut[i];
94  *buffer++ = cDigitsLut[i + 1];
95  }
96  else
97  *buffer++ = static_cast<char>('0' + static_cast<char>(a));
98 
99  const uint32_t b = value / 10000; // 0 to 9999
100  const uint32_t c = value % 10000; // 0 to 9999
101 
102  const uint32_t d1 = (b / 100) << 1;
103  const uint32_t d2 = (b % 100) << 1;
104 
105  const uint32_t d3 = (c / 100) << 1;
106  const uint32_t d4 = (c % 100) << 1;
107 
108  *buffer++ = cDigitsLut[d1];
109  *buffer++ = cDigitsLut[d1 + 1];
110  *buffer++ = cDigitsLut[d2];
111  *buffer++ = cDigitsLut[d2 + 1];
112  *buffer++ = cDigitsLut[d3];
113  *buffer++ = cDigitsLut[d3 + 1];
114  *buffer++ = cDigitsLut[d4];
115  *buffer++ = cDigitsLut[d4 + 1];
116  }
117  return buffer;
118 }
119 
120 inline char* i32toa(int32_t value, char* buffer)
121 {
122  RAPIDJSON_ASSERT(buffer != 0);
123  uint32_t u = static_cast<uint32_t>(value);
124  if (value < 0)
125  {
126  *buffer++ = '-';
127  u = ~u + 1;
128  }
129 
130  return u32toa(u, buffer);
131 }
132 
133 inline char* u64toa(uint64_t value, char* buffer)
134 {
135  RAPIDJSON_ASSERT(buffer != 0);
136  const char* cDigitsLut = GetDigitsLut();
137  const uint64_t kTen8 = 100000000;
138  const uint64_t kTen9 = kTen8 * 10;
139  const uint64_t kTen10 = kTen8 * 100;
140  const uint64_t kTen11 = kTen8 * 1000;
141  const uint64_t kTen12 = kTen8 * 10000;
142  const uint64_t kTen13 = kTen8 * 100000;
143  const uint64_t kTen14 = kTen8 * 1000000;
144  const uint64_t kTen15 = kTen8 * 10000000;
145  const uint64_t kTen16 = kTen8 * kTen8;
146 
147  if (value < kTen8)
148  {
149  uint32_t v = static_cast<uint32_t>(value);
150  if (v < 10000)
151  {
152  const uint32_t d1 = (v / 100) << 1;
153  const uint32_t d2 = (v % 100) << 1;
154 
155  if (v >= 1000)
156  *buffer++ = cDigitsLut[d1];
157  if (v >= 100)
158  *buffer++ = cDigitsLut[d1 + 1];
159  if (v >= 10)
160  *buffer++ = cDigitsLut[d2];
161  *buffer++ = cDigitsLut[d2 + 1];
162  }
163  else
164  {
165  // value = bbbbcccc
166  const uint32_t b = v / 10000;
167  const uint32_t c = v % 10000;
168 
169  const uint32_t d1 = (b / 100) << 1;
170  const uint32_t d2 = (b % 100) << 1;
171 
172  const uint32_t d3 = (c / 100) << 1;
173  const uint32_t d4 = (c % 100) << 1;
174 
175  if (value >= 10000000)
176  *buffer++ = cDigitsLut[d1];
177  if (value >= 1000000)
178  *buffer++ = cDigitsLut[d1 + 1];
179  if (value >= 100000)
180  *buffer++ = cDigitsLut[d2];
181  *buffer++ = cDigitsLut[d2 + 1];
182 
183  *buffer++ = cDigitsLut[d3];
184  *buffer++ = cDigitsLut[d3 + 1];
185  *buffer++ = cDigitsLut[d4];
186  *buffer++ = cDigitsLut[d4 + 1];
187  }
188  }
189  else if (value < kTen16)
190  {
191  const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
192  const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
193 
194  const uint32_t b0 = v0 / 10000;
195  const uint32_t c0 = v0 % 10000;
196 
197  const uint32_t d1 = (b0 / 100) << 1;
198  const uint32_t d2 = (b0 % 100) << 1;
199 
200  const uint32_t d3 = (c0 / 100) << 1;
201  const uint32_t d4 = (c0 % 100) << 1;
202 
203  const uint32_t b1 = v1 / 10000;
204  const uint32_t c1 = v1 % 10000;
205 
206  const uint32_t d5 = (b1 / 100) << 1;
207  const uint32_t d6 = (b1 % 100) << 1;
208 
209  const uint32_t d7 = (c1 / 100) << 1;
210  const uint32_t d8 = (c1 % 100) << 1;
211 
212  if (value >= kTen15)
213  *buffer++ = cDigitsLut[d1];
214  if (value >= kTen14)
215  *buffer++ = cDigitsLut[d1 + 1];
216  if (value >= kTen13)
217  *buffer++ = cDigitsLut[d2];
218  if (value >= kTen12)
219  *buffer++ = cDigitsLut[d2 + 1];
220  if (value >= kTen11)
221  *buffer++ = cDigitsLut[d3];
222  if (value >= kTen10)
223  *buffer++ = cDigitsLut[d3 + 1];
224  if (value >= kTen9)
225  *buffer++ = cDigitsLut[d4];
226 
227  *buffer++ = cDigitsLut[d4 + 1];
228  *buffer++ = cDigitsLut[d5];
229  *buffer++ = cDigitsLut[d5 + 1];
230  *buffer++ = cDigitsLut[d6];
231  *buffer++ = cDigitsLut[d6 + 1];
232  *buffer++ = cDigitsLut[d7];
233  *buffer++ = cDigitsLut[d7 + 1];
234  *buffer++ = cDigitsLut[d8];
235  *buffer++ = cDigitsLut[d8 + 1];
236  }
237  else
238  {
239  const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
240  value %= kTen16;
241 
242  if (a < 10)
243  *buffer++ = static_cast<char>('0' + static_cast<char>(a));
244  else if (a < 100)
245  {
246  const uint32_t i = a << 1;
247  *buffer++ = cDigitsLut[i];
248  *buffer++ = cDigitsLut[i + 1];
249  }
250  else if (a < 1000)
251  {
252  *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
253 
254  const uint32_t i = (a % 100) << 1;
255  *buffer++ = cDigitsLut[i];
256  *buffer++ = cDigitsLut[i + 1];
257  }
258  else
259  {
260  const uint32_t i = (a / 100) << 1;
261  const uint32_t j = (a % 100) << 1;
262  *buffer++ = cDigitsLut[i];
263  *buffer++ = cDigitsLut[i + 1];
264  *buffer++ = cDigitsLut[j];
265  *buffer++ = cDigitsLut[j + 1];
266  }
267 
268  const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
269  const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
270 
271  const uint32_t b0 = v0 / 10000;
272  const uint32_t c0 = v0 % 10000;
273 
274  const uint32_t d1 = (b0 / 100) << 1;
275  const uint32_t d2 = (b0 % 100) << 1;
276 
277  const uint32_t d3 = (c0 / 100) << 1;
278  const uint32_t d4 = (c0 % 100) << 1;
279 
280  const uint32_t b1 = v1 / 10000;
281  const uint32_t c1 = v1 % 10000;
282 
283  const uint32_t d5 = (b1 / 100) << 1;
284  const uint32_t d6 = (b1 % 100) << 1;
285 
286  const uint32_t d7 = (c1 / 100) << 1;
287  const uint32_t d8 = (c1 % 100) << 1;
288 
289  *buffer++ = cDigitsLut[d1];
290  *buffer++ = cDigitsLut[d1 + 1];
291  *buffer++ = cDigitsLut[d2];
292  *buffer++ = cDigitsLut[d2 + 1];
293  *buffer++ = cDigitsLut[d3];
294  *buffer++ = cDigitsLut[d3 + 1];
295  *buffer++ = cDigitsLut[d4];
296  *buffer++ = cDigitsLut[d4 + 1];
297  *buffer++ = cDigitsLut[d5];
298  *buffer++ = cDigitsLut[d5 + 1];
299  *buffer++ = cDigitsLut[d6];
300  *buffer++ = cDigitsLut[d6 + 1];
301  *buffer++ = cDigitsLut[d7];
302  *buffer++ = cDigitsLut[d7 + 1];
303  *buffer++ = cDigitsLut[d8];
304  *buffer++ = cDigitsLut[d8 + 1];
305  }
306 
307  return buffer;
308 }
309 
310 inline char* i64toa(int64_t value, char* buffer)
311 {
312  RAPIDJSON_ASSERT(buffer != 0);
313  uint64_t u = static_cast<uint64_t>(value);
314  if (value < 0)
315  {
316  *buffer++ = '-';
317  u = ~u + 1;
318  }
319 
320  return u64toa(u, buffer);
321 }
322 
323 } // namespace internal
324 RAPIDJSON_NAMESPACE_END
325 
326 #endif // RAPIDJSON_ITOA_
internal::u64toa
char * u64toa(uint64_t value, char *buffer)
Definition: itoa.h:133
RAPIDJSON_ASSERT
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:416
RAPIDJSON_NAMESPACE_END
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Definition: rapidjson.h:126
internal::GetDigitsLut
const char * GetDigitsLut()
Definition: itoa.h:23
RAPIDJSON_NAMESPACE_BEGIN
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
Definition: rapidjson.h:121
uint32_t
unsigned int uint32_t
Definition: stdint.h:126
uint64_t
unsigned __int64 uint64_t
Definition: stdint.h:136
internal::u32toa
char * u32toa(uint32_t value, char *buffer)
Definition: itoa.h:39
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1422
value
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1563
int64_t
signed __int64 int64_t
Definition: stdint.h:135
int32_t
signed int int32_t
Definition: stdint.h:123
internal::i64toa
char * i64toa(int64_t value, char *buffer)
Definition: itoa.h:310
internal::i32toa
char * i32toa(int32_t value, char *buffer)
Definition: itoa.h:120

xbot_talker
Author(s): wangxiaoyun
autogenerated on Sat Oct 10 2020 03:27:53