diff --git a/benchmark/linux/linux-perf-events.h b/benchmark/linux/linux-perf-events.h index 905e3bb17..34d7b4437 100644 --- a/benchmark/linux/linux-perf-events.h +++ b/benchmark/linux/linux-perf-events.h @@ -88,5 +88,3 @@ private: } }; #endif - -#endif diff --git a/benchmark/statisticalmodel.cpp b/benchmark/statisticalmodel.cpp index f04361f9e..15ae97de1 100644 --- a/benchmark/statisticalmodel.cpp +++ b/benchmark/statisticalmodel.cpp @@ -51,9 +51,9 @@ stat_t simdjson_computestats(const std::string_view &p) { if (!answer.valid) { return answer; } - answer.backslash_count = count_backslash((const uint8_t *)p.data(), p.size()); + answer.backslash_count = count_backslash(reinterpret_cast(p.data()), p.size()); answer.nonasciibyte_count = - count_nonasciibytes((const uint8_t *)p.data(), p.size()); + count_nonasciibytes(reinterpret_cast(p.data()), p.size()); answer.byte_count = p.size(); answer.integer_count = 0; answer.float_count = 0; diff --git a/include/simdjson/jsonformatutils.h b/include/simdjson/jsonformatutils.h index aba9df7d0..c3eb6883c 100644 --- a/include/simdjson/jsonformatutils.h +++ b/include/simdjson/jsonformatutils.h @@ -81,7 +81,7 @@ static inline void print_with_escapes(const unsigned char *src, std::ostream &os default: if (*src <= 0x1F) { std::ios::fmtflags f(os.flags()); - os << std::hex << std::setw(4) << std::setfill('0') << (int) *src; + os << std::hex << std::setw(4) << std::setfill('0') << static_cast(*src); os.flags(f); } else { os << *src; @@ -92,7 +92,7 @@ static inline void print_with_escapes(const unsigned char *src, std::ostream &os } static inline void print_with_escapes(const char *src, std::ostream &os) { - print_with_escapes((const unsigned char *)src, os); + print_with_escapes(reinterpret_cast(src), os); } #endif diff --git a/include/simdjson/jsonminifier.h b/include/simdjson/jsonminifier.h index acc8d79f8..29cd815ba 100644 --- a/include/simdjson/jsonminifier.h +++ b/include/simdjson/jsonminifier.h @@ -11,7 +11,7 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out); static inline size_t jsonminify(const char *buf, size_t len, char *out) { - return jsonminify((const uint8_t *)buf, len, (uint8_t *)out); + return jsonminify(reinterpret_cast(buf), len, reinterpret_cast(out)); } diff --git a/include/simdjson/jsonparser.h b/include/simdjson/jsonparser.h index ab1cff463..53c3420d5 100644 --- a/include/simdjson/jsonparser.h +++ b/include/simdjson/jsonparser.h @@ -31,7 +31,7 @@ bool json_parse(const uint8_t *buf, size_t len, ParsedJson &pj, bool reallocifne // all bytes at and after buf + len are ignored (can be garbage). WARN_UNUSED inline bool json_parse(const char * buf, size_t len, ParsedJson &pj, bool reallocifneeded = true) { - return json_parse((const uint8_t *) buf, len, pj, reallocifneeded); + return json_parse(reinterpret_cast(buf), len, pj, reallocifneeded); } // Parse a document found in buf, need to preallocate ParsedJson. @@ -66,7 +66,7 @@ WARN_UNUSED // The input buf should be readable up to buf + len + SIMDJSON_PADDING if reallocifneeded is false, // all bytes at and after buf + len are ignored (can be garbage). inline ParsedJson build_parsed_json(const char * buf, size_t len, bool reallocifneeded = true) { - return build_parsed_json((const uint8_t *) buf, len, reallocifneeded); + return build_parsed_json(reinterpret_cast(buf), len, reallocifneeded); } // convenience function diff --git a/include/simdjson/numberparsing.h b/include/simdjson/numberparsing.h index 9070d0b30..0ca02eaae 100644 --- a/include/simdjson/numberparsing.h +++ b/include/simdjson/numberparsing.h @@ -141,7 +141,7 @@ static inline uint32_t parse_eight_digits_unrolled(const char *chars) { const __m128i mul_1_100 = _mm_setr_epi16(100, 1, 100, 1, 100, 1, 100, 1); const __m128i mul_1_10000 = _mm_setr_epi16(10000, 1, 10000, 1, 10000, 1, 10000, 1); - const __m128i input = _mm_sub_epi8(_mm_loadu_si128((const __m128i *)chars), ascii0); + const __m128i input = _mm_sub_epi8(_mm_loadu_si128(reinterpret_cast(chars)), ascii0); const __m128i t1 = _mm_maddubs_epi16(input, mul_1_10); const __m128i t2 = _mm_madd_epi16(t1, mul_1_100); const __m128i t3 = _mm_packus_epi32(t2, t2); @@ -166,7 +166,7 @@ static never_inline bool parse_float(const uint8_t *const buf, ParsedJson &pj, const uint32_t offset, bool found_minus) { - const char *p = (const char *)(buf + offset); + const char *p = reinterpret_cast(buf + offset); bool negative = false; if (found_minus) { ++p; @@ -280,7 +280,7 @@ static never_inline bool parse_large_integer(const uint8_t *const buf, ParsedJson &pj, const uint32_t offset, bool found_minus) { - const char *p = (const char *)(buf + offset); + const char *p = reinterpret_cast(buf + offset); bool negative = false; if (found_minus) { @@ -352,7 +352,7 @@ static really_inline bool parse_number(const uint8_t *const buf, pj.write_tape_s64(0); // always write zero return true; // always succeeds #else - const char *p = (const char *)(buf + offset); + const char *p = reinterpret_cast(buf + offset); bool negative = false; if (found_minus) { ++p; diff --git a/include/simdjson/parsedjson.h b/include/simdjson/parsedjson.h index 35239cc63..d0f564f31 100644 --- a/include/simdjson/parsedjson.h +++ b/include/simdjson/parsedjson.h @@ -68,12 +68,12 @@ public: // this should be considered a private function really_inline void write_tape(uint64_t val, uint8_t c) { - tape[current_loc++] = val | (((uint64_t)c) << 56); + tape[current_loc++] = val | ((static_cast(c)) << 56); } really_inline void write_tape_s64(int64_t i) { write_tape(0, 'l'); - tape[current_loc++] = *((uint64_t *)&i); + tape[current_loc++] = *(reinterpret_cast(&i)); } really_inline void write_tape_double(double d) { @@ -238,14 +238,14 @@ private : // dump bits low to high inline void dumpbits_always(uint64_t v, const std::string &msg) { for (uint32_t i = 0; i < 64; i++) { - std::cout << (((v >> (uint64_t)i) & 0x1ULL) != 0u ? "1" : "_"); + std::cout << (((v >> static_cast(i)) & 0x1ULL) != 0u ? "1" : "_"); } std::cout << " " << msg.c_str() << "\n"; } inline void dumpbits32_always(uint32_t v, const std::string &msg) { for (uint32_t i = 0; i < 32; i++) { - std::cout << (((v >> (uint32_t)i) & 0x1ULL) != 0u ? "1" : "_"); + std::cout << (((v >> i) & 0x1ULL) != 0u ? "1" : "_"); } std::cout << " " << msg.c_str() << "\n"; } diff --git a/include/simdjson/portability.h b/include/simdjson/portability.h index 936ddb1b8..e866959ed 100644 --- a/include/simdjson/portability.h +++ b/include/simdjson/portability.h @@ -46,10 +46,10 @@ static inline int hamming(uint64_t input_num) { #include static inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) { - return __builtin_uaddll_overflow(value1, value2, (unsigned long long*)result); + return __builtin_uaddll_overflow(value1, value2, static_cast(result)); } static inline bool mul_overflow(uint64_t value1, uint64_t value2, uint64_t *result) { - return __builtin_umulll_overflow(value1, value2, (unsigned long long *)result); + return __builtin_umulll_overflow(value1, value2, static_cast(result)); } /* result might be undefined when input_num is zero */ diff --git a/include/simdjson/stage1_find_marks.h b/include/simdjson/stage1_find_marks.h index 684d5502d..999725869 100644 --- a/include/simdjson/stage1_find_marks.h +++ b/include/simdjson/stage1_find_marks.h @@ -9,7 +9,7 @@ bool find_structural_bits(const uint8_t *buf, size_t len, ParsedJson &pj); WARN_UNUSED static inline bool find_structural_bits(const char *buf, size_t len, ParsedJson &pj) { - return find_structural_bits((const uint8_t *)buf, len, pj); + return find_structural_bits(reinterpret_cast(buf), len, pj); } #endif diff --git a/include/simdjson/stage2_build_tape.h b/include/simdjson/stage2_build_tape.h index 0854c5c60..c929801a9 100644 --- a/include/simdjson/stage2_build_tape.h +++ b/include/simdjson/stage2_build_tape.h @@ -12,7 +12,7 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj); WARN_UNUSED static inline bool unified_machine(const char *buf, size_t len, ParsedJson &pj) { - return unified_machine((const uint8_t *)buf,len,pj); + return unified_machine(reinterpret_cast(buf),len,pj); } #endif diff --git a/include/simdjson/stringparsing.h b/include/simdjson/stringparsing.h index 97c6972d9..1431fa265 100644 --- a/include/simdjson/stringparsing.h +++ b/include/simdjson/stringparsing.h @@ -72,11 +72,11 @@ really_inline bool parse_string(const uint8_t *buf, UNUSED size_t len, uint8_t *const start_of_string = dst; #endif while (1) { - __m256i v = _mm256_loadu_si256((const __m256i *)(src)); + __m256i v = _mm256_loadu_si256(reinterpret_cast(src)); auto bs_bits = - (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, _mm256_set1_epi8('\\'))); + static_cast(_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, _mm256_set1_epi8('\\')))); auto quote_bits = - (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, _mm256_set1_epi8('"'))); + static_cast(_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, _mm256_set1_epi8('"')))); #define CHECKUNESCAPED // All Unicode characters may be placed within the // quotation marks, except for the characters that MUST be escaped: @@ -92,7 +92,7 @@ really_inline bool parse_string(const uint8_t *buf, UNUSED size_t len, uint32_t bs_dist = trailingzeroes(bs_bits); // store to dest unconditionally - we can overwrite the bits we don't like // later - _mm256_storeu_si256((__m256i *)(dst), v); + _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst), v); if (quote_dist < bs_dist) { // we encountered quotes first. Move dst to point to quotes and exit dst[quote_dist] = 0; // null terminate and get out @@ -102,7 +102,7 @@ really_inline bool parse_string(const uint8_t *buf, UNUSED size_t len, pj.current_string_buf_loc = dst + quote_dist + 1; // the +1 is due to the 0 value #ifdef CHECKUNESCAPED // check that there is no unescaped char before the quote - auto unescaped_bits = (uint32_t)_mm256_movemask_epi8(unescaped_vec); + auto unescaped_bits = static_cast(_mm256_movemask_epi8(unescaped_vec)); bool is_ok = ((quote_bits - 1) & (~ quote_bits) & unescaped_bits) == 0; #ifdef JSON_TEST_STRINGS // for unit testing if(is_ok) foundString(buf + offset,start_of_string,pj.current_string_buf_loc - 1); @@ -119,7 +119,7 @@ really_inline bool parse_string(const uint8_t *buf, UNUSED size_t len, uint8_t escape_char = src[bs_dist + 1]; #ifdef CHECKUNESCAPED // we are going to need the unescaped_bits to check for unescaped chars - auto unescaped_bits = (uint32_t)_mm256_movemask_epi8(unescaped_vec); + auto unescaped_bits = static_cast(_mm256_movemask_epi8(unescaped_vec)); if(((bs_bits - 1) & (~ bs_bits) & unescaped_bits) != 0) { #ifdef JSON_TEST_STRINGS // for unit testing foundBadString(buf + offset); diff --git a/src/jsonioutil.cpp b/src/jsonioutil.cpp index c4e38815d..5ec51b676 100644 --- a/src/jsonioutil.cpp +++ b/src/jsonioutil.cpp @@ -13,7 +13,7 @@ char * allocate_padded_buffer(size_t length) { #elif defined(__MINGW32__) || defined(__MINGW64__) padded_buffer = __mingw_aligned_malloc(totalpaddedlength, 64); #else - if (posix_memalign((void **)&padded_buffer, 64, totalpaddedlength) != 0) { return nullptr; + if (posix_memalign(reinterpret_cast(&padded_buffer), 64, totalpaddedlength) != 0) { return nullptr; } #endif return padded_buffer; diff --git a/src/jsonminifier.cpp b/src/jsonminifier.cpp index 016699c14..20872921b 100644 --- a/src/jsonminifier.cpp +++ b/src/jsonminifier.cpp @@ -66,7 +66,7 @@ size_t jsonminify(const unsigned char *bytes, size_t howmany, static uint64_t cmp_mask_against_input_mini(__m256i input_lo, __m256i input_hi, __m256i mask) { __m256i cmp_res_0 = _mm256_cmpeq_epi8(input_lo, mask); - uint64_t res_0 = (uint32_t)_mm256_movemask_epi8(cmp_res_0); + uint64_t res_0 = static_cast(_mm256_movemask_epi8(cmp_res_0)); __m256i cmp_res_1 = _mm256_cmpeq_epi8(input_hi, mask); uint64_t res_1 = _mm256_movemask_epi8(cmp_res_1); return res_0 | (res_1 << 32); @@ -87,8 +87,8 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { size_t avxlen = len - 63; for (; idx < avxlen; idx += 64) { - __m256i input_lo = _mm256_loadu_si256((const __m256i *)(buf + idx + 0)); - __m256i input_hi = _mm256_loadu_si256((const __m256i *)(buf + idx + 32)); + __m256i input_lo = _mm256_loadu_si256(reinterpret_cast(buf + idx + 0)); + __m256i input_hi = _mm256_loadu_si256(reinterpret_cast(buf + idx + 32)); uint64_t bs_bits = cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('\\')); uint64_t start_edges = bs_bits & ~(bs_bits << 1); @@ -112,7 +112,7 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { uint64_t quote_mask = _mm_cvtsi128_si64(_mm_clmulepi64_si128( _mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFF), 0)); quote_mask ^= prev_iter_inside_quote; - prev_iter_inside_quote = (uint64_t)((int64_t)quote_mask >> 63);// might be undefined behavior, should be fully defined in C++20, ok according to John Regher from Utah University + prev_iter_inside_quote = static_cast(static_cast(quote_mask) >> 63);// might be undefined behavior, should be fully defined in C++20, ok according to John Regher from Utah University const __m256i low_nibble_mask = _mm256_setr_epi8( // 0 9 a b c d 16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0, 16, 0, 0, 0, 0, 0, @@ -138,7 +138,7 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { __m256i tmp_ws_hi = _mm256_cmpeq_epi8( _mm256_and_si256(v_hi, whitespace_shufti_mask), _mm256_set1_epi8(0)); - uint64_t ws_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_ws_lo); + uint64_t ws_res_0 = static_cast(_mm256_movemask_epi8(tmp_ws_lo)); uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi); uint64_t whitespace = ~(ws_res_0 | (ws_res_1 << 32)); whitespace &= ~quote_mask; @@ -151,15 +151,15 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { int pop3 = hamming((~whitespace) & UINT64_C(0xFFFFFFFFFFFF)); int pop4 = hamming((~whitespace)); __m256i vmask1 = - _mm256_loadu2_m128i((const __m128i *)mask128_epi8 + (mask2 & 0x7FFF), - (const __m128i *)mask128_epi8 + (mask1 & 0x7FFF)); + _mm256_loadu2_m128i(reinterpret_cast(mask128_epi8) + (mask2 & 0x7FFF), + reinterpret_cast(mask128_epi8) + (mask1 & 0x7FFF)); __m256i vmask2 = - _mm256_loadu2_m128i((const __m128i *)mask128_epi8 + (mask4 & 0x7FFF), - (const __m128i *)mask128_epi8 + (mask3 & 0x7FFF)); + _mm256_loadu2_m128i(reinterpret_cast(mask128_epi8) + (mask4 & 0x7FFF), + reinterpret_cast(mask128_epi8) + (mask3 & 0x7FFF)); __m256i result1 = _mm256_shuffle_epi8(input_lo, vmask1); __m256i result2 = _mm256_shuffle_epi8(input_hi, vmask2); - _mm256_storeu2_m128i((__m128i *)(out + pop1), (__m128i *)out, result1); - _mm256_storeu2_m128i((__m128i *)(out + pop3), (__m128i *)(out + pop2), + _mm256_storeu2_m128i(reinterpret_cast<__m128i *>(out + pop1), reinterpret_cast<__m128i *>(out), result1); + _mm256_storeu2_m128i(reinterpret_cast<__m128i *>(out + pop3), reinterpret_cast<__m128i *>(out + pop2), result2); out += pop4; } @@ -170,8 +170,8 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { uint8_t buffer[64]; memset(buffer, 0, 64); memcpy(buffer, buf + idx, len - idx); - __m256i input_lo = _mm256_loadu_si256((const __m256i *)(buffer)); - __m256i input_hi = _mm256_loadu_si256((const __m256i *)(buffer + 32)); + __m256i input_lo = _mm256_loadu_si256(reinterpret_cast(buffer)); + __m256i input_hi = _mm256_loadu_si256(reinterpret_cast(buffer + 32)); uint64_t bs_bits = cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('\\')); uint64_t start_edges = bs_bits & ~(bs_bits << 1); @@ -213,7 +213,7 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { __m256i tmp_ws_hi = _mm256_or_si256( _mm256_cmpeq_epi8(mask_20, input_hi), _mm256_shuffle_epi8(lut_cntrl, _mm256_adds_epu8(mask_70, input_hi))); - uint64_t ws_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_ws_lo); + uint64_t ws_res_0 = static_cast(_mm256_movemask_epi8(tmp_ws_lo)); uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi); uint64_t whitespace = (ws_res_0 | (ws_res_1 << 32)); whitespace &= ~quote_mask; @@ -230,16 +230,16 @@ size_t jsonminify(const uint8_t *buf, size_t len, uint8_t *out) { int pop3 = hamming((~whitespace) & UINT64_C(0xFFFFFFFFFFFF)); int pop4 = hamming((~whitespace)); __m256i vmask1 = - _mm256_loadu2_m128i((const __m128i *)mask128_epi8 + (mask2 & 0x7FFF), - (const __m128i *)mask128_epi8 + (mask1 & 0x7FFF)); + _mm256_loadu2_m128i(reinterpret_cast(mask128_epi8) + (mask2 & 0x7FFF), + reinterpret_cast(mask128_epi8) + (mask1 & 0x7FFF)); __m256i vmask2 = - _mm256_loadu2_m128i((const __m128i *)mask128_epi8 + (mask4 & 0x7FFF), - (const __m128i *)mask128_epi8 + (mask3 & 0x7FFF)); + _mm256_loadu2_m128i(reinterpret_cast(mask128_epi8) + (mask4 & 0x7FFF), + reinterpret_cast(mask128_epi8) + (mask3 & 0x7FFF)); __m256i result1 = _mm256_shuffle_epi8(input_lo, vmask1); __m256i result2 = _mm256_shuffle_epi8(input_hi, vmask2); - _mm256_storeu2_m128i((__m128i *)(buffer + pop1), (__m128i *)buffer, + _mm256_storeu2_m128i(reinterpret_cast<__m128i *>(buffer + pop1), reinterpret_cast<__m128i *>(buffer), result1); - _mm256_storeu2_m128i((__m128i *)(buffer + pop3), (__m128i *)(buffer + pop2), + _mm256_storeu2_m128i(reinterpret_cast<__m128i *>(buffer + pop3), reinterpret_cast<__m128i *>(buffer + pop2), result2); memcpy(out, buffer, pop4); out += pop4; diff --git a/src/jsonparser.cpp b/src/jsonparser.cpp index 88e304241..cc977344a 100644 --- a/src/jsonparser.cpp +++ b/src/jsonparser.cpp @@ -33,7 +33,7 @@ bool json_parse(const uint8_t *buf, size_t len, ParsedJson &pj, bool reallocifne #endif if ( (reinterpret_cast(buf + len - 1) % pagesize ) < SIMDJSON_PADDING ) { const uint8_t *tmpbuf = buf; - buf = (uint8_t *) allocate_padded_buffer(len); + buf = reinterpret_cast(allocate_padded_buffer(len)); if(buf == nullptr) { return false; } memcpy((void*)buf,tmpbuf,len); diff --git a/src/parsedjson.cpp b/src/parsedjson.cpp index e8551137b..201de085a 100644 --- a/src/parsedjson.cpp +++ b/src/parsedjson.cpp @@ -164,7 +164,7 @@ bool ParsedJson::printjson(std::ostream &os) { if (tapeidx + 1 >= howmany) { return false; } - os << (int64_t)tape[++tapeidx]; + os << static_cast(tape[++tapeidx]); break; case 'd': // we have a double if (tapeidx + 1 >= howmany) { @@ -254,7 +254,7 @@ bool ParsedJson::dump_raw_tape(std::ostream &os) { if (tapeidx + 1 >= howmany) { return false; } - os << "integer " << (int64_t)tape[++tapeidx] << "\n"; + os << "integer " << static_cast(tape[++tapeidx]) << "\n"; break; case 'd': // we have a double os << "float "; diff --git a/src/parsedjsoniterator.cpp b/src/parsedjsoniterator.cpp index b3e244812..f5657b3ab 100644 --- a/src/parsedjsoniterator.cpp +++ b/src/parsedjsoniterator.cpp @@ -109,7 +109,7 @@ uint8_t ParsedJson::iterator::get_type() const { int64_t ParsedJson::iterator::get_integer() const { if(location + 1 >= tape_length) { return 0;// default value in case of error } - return (int64_t) pj.tape[location + 1]; + return static_cast(pj.tape[location + 1]); } double ParsedJson::iterator::get_double() const { @@ -121,7 +121,7 @@ double ParsedJson::iterator::get_double() const { } const char * ParsedJson::iterator::get_string() const { - return (const char *)(pj.string_buf + (current_val & JSONVALUEMASK)) ; + return reinterpret_cast(pj.string_buf + (current_val & JSONVALUEMASK)) ; } @@ -292,7 +292,7 @@ bool ParsedJson::iterator::print(std::ostream &os, bool escape_strings) const { case '}': // we end an object case '[': // we start an array case ']': // we end an array - os << (char) current_type; + os << static_cast(current_type); break; default: return false; diff --git a/src/stage1_find_marks.cpp b/src/stage1_find_marks.cpp index 2db2ab2cf..e0b83d5c3 100644 --- a/src/stage1_find_marks.cpp +++ b/src/stage1_find_marks.cpp @@ -21,7 +21,7 @@ using namespace std; really_inline uint64_t cmp_mask_against_input(__m256i input_lo, __m256i input_hi, __m256i mask) { __m256i cmp_res_0 = _mm256_cmpeq_epi8(input_lo, mask); - uint64_t res_0 = (uint32_t)_mm256_movemask_epi8(cmp_res_0); + uint64_t res_0 = static_cast(_mm256_movemask_epi8(cmp_res_0)); __m256i cmp_res_1 = _mm256_cmpeq_epi8(input_hi, mask); uint64_t res_1 = _mm256_movemask_epi8(cmp_res_1); return res_0 | (res_1 << 32); @@ -66,8 +66,8 @@ WARN_UNUSED #ifndef _MSC_VER __builtin_prefetch(buf + idx + 128); #endif - __m256i input_lo = _mm256_loadu_si256((const __m256i *)(buf + idx + 0)); - __m256i input_hi = _mm256_loadu_si256((const __m256i *)(buf + idx + 32)); + __m256i input_lo = _mm256_loadu_si256(reinterpret_cast(buf + idx + 0)); + __m256i input_hi = _mm256_loadu_si256(reinterpret_cast(buf + idx + 32)); #ifdef SIMDJSON_UTF8VALIDATE __m256i highbit = _mm256_set1_epi8(0x80); if((_mm256_testz_si256(_mm256_or_si256(input_lo, input_hi),highbit)) == 1) { @@ -131,28 +131,28 @@ WARN_UNUSED uint32_t cnt = hamming(structurals); uint32_t next_base = base + cnt; while (structurals != 0u) { - base_ptr[base + 0] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 0] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 1] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 1] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 2] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 2] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 3] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 3] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 4] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 4] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 5] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 5] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 6] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 6] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 7] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 7] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); base += 8; } base = next_base; quote_mask ^= prev_iter_inside_quote; - prev_iter_inside_quote = (uint64_t)((int64_t)quote_mask >> 63); // right shift of a signed value expected to be well-defined and standard compliant as of C++20, John Regher from Utah U. says this is fine code + prev_iter_inside_quote = static_cast(static_cast(quote_mask) >> 63); // right shift of a signed value expected to be well-defined and standard compliant as of C++20, John Regher from Utah U. says this is fine code // How do we build up a user traversable data structure // first, do a 'shufti' to detect structural JSON characters @@ -190,7 +190,7 @@ WARN_UNUSED __m256i tmp_hi = _mm256_cmpeq_epi8( _mm256_and_si256(v_hi, structural_shufti_mask), _mm256_set1_epi8(0)); - uint64_t structural_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_lo); + uint64_t structural_res_0 = static_cast(_mm256_movemask_epi8(tmp_lo)); uint64_t structural_res_1 = _mm256_movemask_epi8(tmp_hi); structurals = ~(structural_res_0 | (structural_res_1 << 32)); @@ -201,7 +201,7 @@ WARN_UNUSED __m256i tmp_ws_hi = _mm256_cmpeq_epi8( _mm256_and_si256(v_hi, whitespace_shufti_mask), _mm256_set1_epi8(0)); - uint64_t ws_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_ws_lo); + uint64_t ws_res_0 = static_cast(_mm256_movemask_epi8(tmp_ws_lo)); uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi); uint64_t whitespace = ~(ws_res_0 | (ws_res_1 << 32)); // mask off anything inside quotes @@ -244,8 +244,8 @@ WARN_UNUSED uint8_t tmpbuf[64]; memset(tmpbuf,0x20,64); memcpy(tmpbuf,buf+idx,len - idx); - __m256i input_lo = _mm256_loadu_si256((const __m256i *)(tmpbuf + 0)); - __m256i input_hi = _mm256_loadu_si256((const __m256i *)(tmpbuf + 32)); + __m256i input_lo = _mm256_loadu_si256(reinterpret_cast(tmpbuf + 0)); + __m256i input_hi = _mm256_loadu_si256(reinterpret_cast(tmpbuf + 32)); #ifdef SIMDJSON_UTF8VALIDATE __m256i highbit = _mm256_set1_epi8(0x80); if((_mm256_testz_si256(_mm256_or_si256(input_lo, input_hi),highbit)) == 1) { @@ -309,21 +309,21 @@ WARN_UNUSED uint32_t cnt = hamming(structurals); uint32_t next_base = base + cnt; while (structurals != 0u) { - base_ptr[base + 0] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 0] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 1] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 1] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 2] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 2] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 3] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 3] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 4] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 4] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 5] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 5] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 6] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 6] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 7] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 7] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); base += 8; } @@ -364,7 +364,7 @@ WARN_UNUSED __m256i tmp_hi = _mm256_cmpeq_epi8( _mm256_and_si256(v_hi, structural_shufti_mask), _mm256_set1_epi8(0)); - uint64_t structural_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_lo); + uint64_t structural_res_0 = static_cast(_mm256_movemask_epi8(tmp_lo)); uint64_t structural_res_1 = _mm256_movemask_epi8(tmp_hi); structurals = ~(structural_res_0 | (structural_res_1 << 32)); @@ -375,7 +375,7 @@ WARN_UNUSED __m256i tmp_ws_hi = _mm256_cmpeq_epi8( _mm256_and_si256(v_hi, whitespace_shufti_mask), _mm256_set1_epi8(0)); - uint64_t ws_res_0 = (uint32_t)_mm256_movemask_epi8(tmp_ws_lo); + uint64_t ws_res_0 = static_cast(_mm256_movemask_epi8(tmp_ws_lo)); uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi); uint64_t whitespace = ~(ws_res_0 | (ws_res_1 << 32)); @@ -413,21 +413,21 @@ WARN_UNUSED uint32_t cnt = hamming(structurals); uint32_t next_base = base + cnt; while (structurals != 0u) { - base_ptr[base + 0] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 0] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 1] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 1] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 2] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 2] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 3] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 3] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 4] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 4] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 5] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 5] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 6] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 6] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); - base_ptr[base + 7] = (uint32_t)idx - 64 + trailingzeroes(structurals); + base_ptr[base + 7] = static_cast(idx) - 64 + trailingzeroes(structurals); structurals = structurals & (structurals - 1); base += 8; } diff --git a/src/stage2_build_tape.cpp b/src/stage2_build_tape.cpp index a3cbaa4d6..4e9ab9c0d 100644 --- a/src/stage2_build_tape.cpp +++ b/src/stage2_build_tape.cpp @@ -22,7 +22,7 @@ using namespace std; WARN_UNUSED really_inline bool is_valid_true_atom(const uint8_t *loc) { - uint64_t tv = *(const uint64_t *)"true "; + uint64_t tv = *reinterpret_cast("true "); uint64_t mask4 = 0x00000000ffffffff; uint32_t error = 0; uint64_t locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++) @@ -34,7 +34,7 @@ really_inline bool is_valid_true_atom(const uint8_t *loc) { WARN_UNUSED really_inline bool is_valid_false_atom(const uint8_t *loc) { - uint64_t fv = *(const uint64_t *)"false "; + uint64_t fv = *reinterpret_cast("false "); uint64_t mask5 = 0x000000ffffffffff; uint32_t error = 0; uint64_t locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++) @@ -46,7 +46,7 @@ really_inline bool is_valid_false_atom(const uint8_t *loc) { WARN_UNUSED really_inline bool is_valid_null_atom(const uint8_t *loc) { - uint64_t nv = *(const uint64_t *)"null "; + uint64_t nv = *reinterpret_cast("null "); uint64_t mask4 = 0x00000000ffffffff; uint32_t error = 0; uint64_t locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++) @@ -141,12 +141,12 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj) { // we need to make a copy to make sure that the string is NULL terminated. // this only applies to the JSON document made solely of the true value. // this will almost never be called in practice - char * copy = (char *) malloc(len + SIMDJSON_PADDING); + char * copy = static_cast(malloc(len + SIMDJSON_PADDING)); if(copy == nullptr) { goto fail; } memcpy(copy, buf, len); copy[len] = '\0'; - if (!is_valid_true_atom((const uint8_t *)copy + idx)) { + if (!is_valid_true_atom(reinterpret_cast(copy) + idx)) { free(copy); goto fail; } @@ -158,12 +158,12 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj) { // we need to make a copy to make sure that the string is NULL terminated. // this only applies to the JSON document made solely of the false value. // this will almost never be called in practice - char * copy = (char *) malloc(len + SIMDJSON_PADDING); + char * copy = static_cast(malloc(len + SIMDJSON_PADDING)); if(copy == nullptr) { goto fail; } memcpy(copy, buf, len); copy[len] = '\0'; - if (!is_valid_false_atom((const uint8_t *)copy + idx)) { + if (!is_valid_false_atom(reinterpret_cast(copy) + idx)) { free(copy); goto fail; } @@ -175,12 +175,12 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj) { // we need to make a copy to make sure that the string is NULL terminated. // this only applies to the JSON document made solely of the null value. // this will almost never be called in practice - char * copy = (char *) malloc(len + SIMDJSON_PADDING); + char * copy = static_cast(malloc(len + SIMDJSON_PADDING)); if(copy == nullptr) { goto fail; } memcpy(copy, buf, len); copy[len] = '\0'; - if (!is_valid_null_atom((const uint8_t *)copy + idx)) { + if (!is_valid_null_atom(reinterpret_cast(copy) + idx)) { free(copy); goto fail; } @@ -201,12 +201,12 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj) { // we need to make a copy to make sure that the string is NULL terminated. // this is done only for JSON documents made of a sole number // this will almost never be called in practice - char * copy = (char *) malloc(len + SIMDJSON_PADDING); + char * copy = static_cast(malloc(len + SIMDJSON_PADDING)); if(copy == nullptr) { goto fail; } memcpy(copy, buf, len); copy[len] = '\0'; - if (!parse_number((const uint8_t *)copy, pj, idx, false)) { + if (!parse_number(reinterpret_cast(copy), pj, idx, false)) { free(copy); goto fail; } @@ -217,12 +217,12 @@ bool unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj) { // we need to make a copy to make sure that the string is NULL terminated. // this is done only for JSON documents made of a sole number // this will almost never be called in practice - char * copy = (char *) malloc(len + SIMDJSON_PADDING); + char * copy = static_cast(malloc(len + SIMDJSON_PADDING)); if(copy == nullptr) { goto fail; } memcpy(copy, buf, len); copy[len] = '\0'; - if (!parse_number((const uint8_t *)copy, pj, idx, true)) { + if (!parse_number(reinterpret_cast(copy), pj, idx, true)) { free(copy); goto fail; } diff --git a/tests/jsoncheck.cpp b/tests/jsoncheck.cpp index 6b981d3e6..781522b1d 100644 --- a/tests/jsoncheck.cpp +++ b/tests/jsoncheck.cpp @@ -57,7 +57,7 @@ bool validate(const char *dirname) { printf("validating: file %s ", name); fflush(nullptr); size_t filelen = strlen(name); - char *fullpath = (char *)malloc(dirlen + filelen + 1 + 1); + char *fullpath = static_cast(malloc(dirlen + filelen + 1 + 1)); strcpy(fullpath, dirname); if (needsep) { fullpath[dirlen] = '/'; diff --git a/tools/jsonstats.cpp b/tools/jsonstats.cpp index 3124323ac..96668e762 100644 --- a/tools/jsonstats.cpp +++ b/tools/jsonstats.cpp @@ -50,8 +50,8 @@ stat_t simdjson_computestats(const std::string_view &p) { if (!answer.valid) { return answer; } - answer.backslash_count = count_backslash((const uint8_t*)p.data(), p.size()); - answer.nonasciibyte_count = count_nonasciibytes((const uint8_t*)p.data(), p.size()); + answer.backslash_count = count_backslash(reinterpret_cast(p.data()), p.size()); + answer.nonasciibyte_count = count_nonasciibytes(reinterpret_cast(p.data()), p.size()); answer.byte_count = p.size(); answer.integer_count = 0; answer.float_count = 0; diff --git a/tools/minify.cpp b/tools/minify.cpp index e91ec6a9e..a81ce49ab 100644 --- a/tools/minify.cpp +++ b/tools/minify.cpp @@ -16,7 +16,7 @@ int main(int argc, char *argv[]) { std::cout << "Could not load the file " << filename << std::endl; return EXIT_FAILURE; } - jsonminify(p, (char *)p.data()); + jsonminify(p, const_cast(p.data())); printf("%s",p.data()); aligned_free((void*)p.data()); }