| // Copyright (C) 2011 Milo Yip |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| #ifndef RAPIDJSON_ITOA_ |
| #define RAPIDJSON_ITOA_ |
| |
| RAPIDJSON_NAMESPACE_BEGIN |
| namespace internal { |
| |
| inline const char* GetDigitsLut() { |
| static const char cDigitsLut[200] = { |
| '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9', |
| '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9', |
| '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9', |
| '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9', |
| '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9', |
| '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9', |
| '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9', |
| '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9', |
| '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9', |
| '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9' |
| }; |
| return cDigitsLut; |
| } |
| |
| inline char* u32toa(uint32_t value, char* buffer) { |
| const char* cDigitsLut = GetDigitsLut(); |
| |
| if (value < 10000) { |
| const uint32_t d1 = (value / 100) << 1; |
| const uint32_t d2 = (value % 100) << 1; |
| |
| if (value >= 1000) |
| *buffer++ = cDigitsLut[d1]; |
| if (value >= 100) |
| *buffer++ = cDigitsLut[d1 + 1]; |
| if (value >= 10) |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| } |
| else if (value < 100000000) { |
| // value = bbbbcccc |
| const uint32_t b = value / 10000; |
| const uint32_t c = value % 10000; |
| |
| const uint32_t d1 = (b / 100) << 1; |
| const uint32_t d2 = (b % 100) << 1; |
| |
| const uint32_t d3 = (c / 100) << 1; |
| const uint32_t d4 = (c % 100) << 1; |
| |
| if (value >= 10000000) |
| *buffer++ = cDigitsLut[d1]; |
| if (value >= 1000000) |
| *buffer++ = cDigitsLut[d1 + 1]; |
| if (value >= 100000) |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| |
| *buffer++ = cDigitsLut[d3]; |
| *buffer++ = cDigitsLut[d3 + 1]; |
| *buffer++ = cDigitsLut[d4]; |
| *buffer++ = cDigitsLut[d4 + 1]; |
| } |
| else { |
| // value = aabbbbcccc in decimal |
| |
| const uint32_t a = value / 100000000; // 1 to 42 |
| value %= 100000000; |
| |
| if (a >= 10) { |
| const unsigned i = a << 1; |
| *buffer++ = cDigitsLut[i]; |
| *buffer++ = cDigitsLut[i + 1]; |
| } |
| else |
| *buffer++ = static_cast<char>('0' + static_cast<char>(a)); |
| |
| const uint32_t b = value / 10000; // 0 to 9999 |
| const uint32_t c = value % 10000; // 0 to 9999 |
| |
| const uint32_t d1 = (b / 100) << 1; |
| const uint32_t d2 = (b % 100) << 1; |
| |
| const uint32_t d3 = (c / 100) << 1; |
| const uint32_t d4 = (c % 100) << 1; |
| |
| *buffer++ = cDigitsLut[d1]; |
| *buffer++ = cDigitsLut[d1 + 1]; |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| *buffer++ = cDigitsLut[d3]; |
| *buffer++ = cDigitsLut[d3 + 1]; |
| *buffer++ = cDigitsLut[d4]; |
| *buffer++ = cDigitsLut[d4 + 1]; |
| } |
| return buffer; |
| } |
| |
| inline char* i32toa(int32_t value, char* buffer) { |
| if (value < 0) { |
| *buffer++ = '-'; |
| value = -value; |
| } |
| |
| return u32toa(static_cast<uint32_t>(value), buffer); |
| } |
| |
| inline char* u64toa(uint64_t value, char* buffer) { |
| const char* cDigitsLut = GetDigitsLut(); |
| const uint64_t kTen8 = 100000000; |
| const uint64_t kTen9 = kTen8 * 10; |
| const uint64_t kTen10 = kTen8 * 100; |
| const uint64_t kTen11 = kTen8 * 1000; |
| const uint64_t kTen12 = kTen8 * 10000; |
| const uint64_t kTen13 = kTen8 * 100000; |
| const uint64_t kTen14 = kTen8 * 1000000; |
| const uint64_t kTen15 = kTen8 * 10000000; |
| const uint64_t kTen16 = kTen8 * kTen8; |
| |
| if (value < kTen8) { |
| uint32_t v = static_cast<uint32_t>(value); |
| if (v < 10000) { |
| const uint32_t d1 = (v / 100) << 1; |
| const uint32_t d2 = (v % 100) << 1; |
| |
| if (v >= 1000) |
| *buffer++ = cDigitsLut[d1]; |
| if (v >= 100) |
| *buffer++ = cDigitsLut[d1 + 1]; |
| if (v >= 10) |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| } |
| else { |
| // value = bbbbcccc |
| const uint32_t b = v / 10000; |
| const uint32_t c = v % 10000; |
| |
| const uint32_t d1 = (b / 100) << 1; |
| const uint32_t d2 = (b % 100) << 1; |
| |
| const uint32_t d3 = (c / 100) << 1; |
| const uint32_t d4 = (c % 100) << 1; |
| |
| if (value >= 10000000) |
| *buffer++ = cDigitsLut[d1]; |
| if (value >= 1000000) |
| *buffer++ = cDigitsLut[d1 + 1]; |
| if (value >= 100000) |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| |
| *buffer++ = cDigitsLut[d3]; |
| *buffer++ = cDigitsLut[d3 + 1]; |
| *buffer++ = cDigitsLut[d4]; |
| *buffer++ = cDigitsLut[d4 + 1]; |
| } |
| } |
| else if (value < kTen16) { |
| const uint32_t v0 = static_cast<uint32_t>(value / kTen8); |
| const uint32_t v1 = static_cast<uint32_t>(value % kTen8); |
| |
| const uint32_t b0 = v0 / 10000; |
| const uint32_t c0 = v0 % 10000; |
| |
| const uint32_t d1 = (b0 / 100) << 1; |
| const uint32_t d2 = (b0 % 100) << 1; |
| |
| const uint32_t d3 = (c0 / 100) << 1; |
| const uint32_t d4 = (c0 % 100) << 1; |
| |
| const uint32_t b1 = v1 / 10000; |
| const uint32_t c1 = v1 % 10000; |
| |
| const uint32_t d5 = (b1 / 100) << 1; |
| const uint32_t d6 = (b1 % 100) << 1; |
| |
| const uint32_t d7 = (c1 / 100) << 1; |
| const uint32_t d8 = (c1 % 100) << 1; |
| |
| if (value >= kTen15) |
| *buffer++ = cDigitsLut[d1]; |
| if (value >= kTen14) |
| *buffer++ = cDigitsLut[d1 + 1]; |
| if (value >= kTen13) |
| *buffer++ = cDigitsLut[d2]; |
| if (value >= kTen12) |
| *buffer++ = cDigitsLut[d2 + 1]; |
| if (value >= kTen11) |
| *buffer++ = cDigitsLut[d3]; |
| if (value >= kTen10) |
| *buffer++ = cDigitsLut[d3 + 1]; |
| if (value >= kTen9) |
| *buffer++ = cDigitsLut[d4]; |
| if (value >= kTen8) |
| *buffer++ = cDigitsLut[d4 + 1]; |
| |
| *buffer++ = cDigitsLut[d5]; |
| *buffer++ = cDigitsLut[d5 + 1]; |
| *buffer++ = cDigitsLut[d6]; |
| *buffer++ = cDigitsLut[d6 + 1]; |
| *buffer++ = cDigitsLut[d7]; |
| *buffer++ = cDigitsLut[d7 + 1]; |
| *buffer++ = cDigitsLut[d8]; |
| *buffer++ = cDigitsLut[d8 + 1]; |
| } |
| else { |
| const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844 |
| value %= kTen16; |
| |
| if (a < 10) |
| *buffer++ = static_cast<char>('0' + static_cast<char>(a)); |
| else if (a < 100) { |
| const uint32_t i = a << 1; |
| *buffer++ = cDigitsLut[i]; |
| *buffer++ = cDigitsLut[i + 1]; |
| } |
| else if (a < 1000) { |
| *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100)); |
| |
| const uint32_t i = (a % 100) << 1; |
| *buffer++ = cDigitsLut[i]; |
| *buffer++ = cDigitsLut[i + 1]; |
| } |
| else { |
| const uint32_t i = (a / 100) << 1; |
| const uint32_t j = (a % 100) << 1; |
| *buffer++ = cDigitsLut[i]; |
| *buffer++ = cDigitsLut[i + 1]; |
| *buffer++ = cDigitsLut[j]; |
| *buffer++ = cDigitsLut[j + 1]; |
| } |
| |
| const uint32_t v0 = static_cast<uint32_t>(value / kTen8); |
| const uint32_t v1 = static_cast<uint32_t>(value % kTen8); |
| |
| const uint32_t b0 = v0 / 10000; |
| const uint32_t c0 = v0 % 10000; |
| |
| const uint32_t d1 = (b0 / 100) << 1; |
| const uint32_t d2 = (b0 % 100) << 1; |
| |
| const uint32_t d3 = (c0 / 100) << 1; |
| const uint32_t d4 = (c0 % 100) << 1; |
| |
| const uint32_t b1 = v1 / 10000; |
| const uint32_t c1 = v1 % 10000; |
| |
| const uint32_t d5 = (b1 / 100) << 1; |
| const uint32_t d6 = (b1 % 100) << 1; |
| |
| const uint32_t d7 = (c1 / 100) << 1; |
| const uint32_t d8 = (c1 % 100) << 1; |
| |
| *buffer++ = cDigitsLut[d1]; |
| *buffer++ = cDigitsLut[d1 + 1]; |
| *buffer++ = cDigitsLut[d2]; |
| *buffer++ = cDigitsLut[d2 + 1]; |
| *buffer++ = cDigitsLut[d3]; |
| *buffer++ = cDigitsLut[d3 + 1]; |
| *buffer++ = cDigitsLut[d4]; |
| *buffer++ = cDigitsLut[d4 + 1]; |
| *buffer++ = cDigitsLut[d5]; |
| *buffer++ = cDigitsLut[d5 + 1]; |
| *buffer++ = cDigitsLut[d6]; |
| *buffer++ = cDigitsLut[d6 + 1]; |
| *buffer++ = cDigitsLut[d7]; |
| *buffer++ = cDigitsLut[d7 + 1]; |
| *buffer++ = cDigitsLut[d8]; |
| *buffer++ = cDigitsLut[d8 + 1]; |
| } |
| |
| return buffer; |
| } |
| |
| inline char* i64toa(int64_t value, char* buffer) { |
| if (value < 0) { |
| *buffer++ = '-'; |
| value = -value; |
| } |
| |
| return u64toa(static_cast<uint64_t>(value), buffer); |
| } |
| |
| } // namespace internal |
| RAPIDJSON_NAMESPACE_END |
| |
| #endif // RAPIDJSON_ITOA_ |