From 28adc0782483cadc428f400a369376a73c23417d Mon Sep 17 00:00:00 2001 From: Konstantinos Margaritis Date: Sat, 18 May 2024 15:06:10 +0300 Subject: [PATCH] Fix more C-style casts --- src/nfa/limex_compile.cpp | 41 +++++++++-------- src/nfa/mcclellancompile.cpp | 86 ++++++++++++++++++------------------ src/nfa/mpvcompile.cpp | 30 +++++++------ src/nfa/nfa_build_util.cpp | 14 +++--- 4 files changed, 86 insertions(+), 85 deletions(-) diff --git a/src/nfa/limex_compile.cpp b/src/nfa/limex_compile.cpp index 43793573..5b28e732 100644 --- a/src/nfa/limex_compile.cpp +++ b/src/nfa/limex_compile.cpp @@ -269,7 +269,7 @@ void maskClear(Mask &m) { template u8 *maskGetByte(Mask &m, u32 bit) { assert(bit < sizeof(m)*8); - u8 *m8 = (u8 *)&m; + u8 *m8 = reinterpret_cast(&m); return m8 + bit/8; } @@ -290,7 +290,7 @@ void maskSetBits(Mask &m, const NFAStateSet &bits) { template bool isMaskZero(Mask &m) { - const u8 *m8 = (u8 *)&m; + const u8 *m8 = reinterpret_cast(&m); for (u32 i = 0; i < sizeof(m); i++) { if (m8[i]) { return false; @@ -303,7 +303,7 @@ bool isMaskZero(Mask &m) { template void maskSetByte(Mask &m, const unsigned int idx, const char val) { assert(idx < sizeof(m)); - char *m8 = (char *)&m; + char *m8 = reinterpret_cast(&m); char &byte = m8[idx]; byte = val; } @@ -1702,7 +1702,7 @@ struct Factory { static void allocState(NFA *nfa, u32 repeatscratchStateSize, u32 repeatStreamState) { - const implNFA_t *limex = (implNFA_t *)getMutableImplNfa(nfa); + const implNFA_t *limex = reinterpret_cast(getMutableImplNfa(nfa)); // LimEx NFAs now store the following in state: // 1. state bitvector (always present) @@ -1768,7 +1768,7 @@ struct Factory { u32 tableOffset, tugMaskOffset; size_t len = repeatAllocSize(br, &tableOffset, &tugMaskOffset); auto info = make_zeroed_bytecode_ptr(len); - char *info_ptr = (char *)info.get(); + char *info_ptr = reinterpret_cast(info.get()); // Collect state space info. RepeatStateInfo rsi(br.type, br.repeatMin, br.repeatMax, br.minPeriod); @@ -1783,8 +1783,7 @@ struct Factory { info->tugMaskOffset = tugMaskOffset; // Fill the RepeatInfo structure. - RepeatInfo *repeat = - (RepeatInfo *)(info_ptr + sizeof(NFARepeatInfo)); + RepeatInfo *repeat = reinterpret_cast(info_ptr + sizeof(NFARepeatInfo)); repeat->type = br.type; repeat->repeatMin = depth_to_u32(br.repeatMin); repeat->repeatMax = depth_to_u32(br.repeatMax); @@ -1810,7 +1809,7 @@ struct Factory { } // Fill the tug mask. - tableRow_t *tugMask = (tableRow_t *)(info_ptr + tugMaskOffset); + tableRow_t *tugMask = reinterpret_cast(info_ptr + tugMaskOffset); for (auto v : br.tug_triggers) { u32 state_id = args.state_ids.at(v); assert(state_id != NO_STATE); @@ -1931,7 +1930,7 @@ struct Factory { const u32 reportListOffset) { DEBUG_PRINTF("exceptionsOffset=%u\n", exceptionsOffset); - exception_t *etable = (exception_t *)((char *)limex + exceptionsOffset); + exception_t *etable = reinterpret_cast(reinterpret_cast(limex) + exceptionsOffset); assert(ISALIGNED(etable)); map exception_by_state; @@ -1979,10 +1978,10 @@ struct Factory { limex->exceptionCount = ecount; if (args.num_states > 64 && args.cc.target_info.has_avx512vbmi()) { - const u8 *exceptionMask = (const u8 *)(&limex->exceptionMask); - u8 *shufMask = (u8 *)&limex->exceptionShufMask; - u8 *bitMask = (u8 *)&limex->exceptionBitMask; - u8 *andMask = (u8 *)&limex->exceptionAndMask; + const u8 *exceptionMask = reinterpret_cast(&limex->exceptionMask); + u8 *shufMask = reinterpret_cast(&limex->exceptionShufMask); + u8 *bitMask = reinterpret_cast(&limex->exceptionBitMask); + u8 *andMask = reinterpret_cast(&limex->exceptionAndMask); u32 tot_cnt = 0; u32 pos = 0; @@ -2042,7 +2041,7 @@ struct Factory { copy(reachMap.begin(), reachMap.end(), &limex->reachMap[0]); // Reach table is right after the LimEx structure. - tableRow_t *reachMask = (tableRow_t *)((char *)limex + reachOffset); + tableRow_t *reachMask = reinterpret_cast(reinterpret_cast(limex) + reachOffset); assert(ISALIGNED(reachMask)); for (size_t i = 0, end = reach.size(); i < end; i++) { maskSetBits(reachMask[i], reach[i]); @@ -2056,7 +2055,7 @@ struct Factory { DEBUG_PRINTF("topsOffset=%u\n", topsOffset); limex->topOffset = topsOffset; - tableRow_t *topMasks = (tableRow_t *)((char *)limex + topsOffset); + tableRow_t *topMasks = reinterpret_cast(reinterpret_cast(limex) + topsOffset); assert(ISALIGNED(topMasks)); for (size_t i = 0, end = tops.size(); i < end; i++) { @@ -2068,8 +2067,8 @@ struct Factory { static void writeAccelSsse3Masks(const NFAStateSet &accelMask, implNFA_t *limex) { - char *perm_base = (char *)&limex->accelPermute; - char *comp_base = (char *)&limex->accelCompare; + char *perm_base = reinterpret_cast(&limex->accelPermute); + char *comp_base = reinterpret_cast(&limex->accelCompare); u32 num = 0; // index in accel table. for (size_t i = accelMask.find_first(); i != accelMask.npos; @@ -2080,8 +2079,8 @@ struct Factory { // PSHUFB permute and compare masks size_t mask_idx = sizeof(u_128) * (state_id / 128U); DEBUG_PRINTF("mask_idx=%zu\n", mask_idx); - u_128 *perm = (u_128 *)(perm_base + mask_idx); - u_128 *comp = (u_128 *)(comp_base + mask_idx); + u_128 *perm = reinterpret_cast(perm_base + mask_idx); + u_128 *comp = reinterpret_cast(comp_base + mask_idx); maskSetByte(*perm, num, ((state_id % 128U) / 8U)); maskSetByte(*comp, num, ~(1U << (state_id % 8U))); } @@ -2099,11 +2098,11 @@ struct Factory { // Write accel lookup table. limex->accelTableOffset = accelTableOffset; copy(accelTable.begin(), accelTable.end(), - (u8 *)((char *)limex + accelTableOffset)); + reinterpret_cast(reinterpret_cast(limex) + accelTableOffset)); // Write accel aux structures. limex->accelAuxOffset = accelAuxOffset; - AccelAux *auxTable = (AccelAux *)((char *)limex + accelAuxOffset); + AccelAux *auxTable = reinterpret_cast(reinterpret_cast(limex) + accelAuxOffset); assert(ISALIGNED(auxTable)); copy(accelAux.begin(), accelAux.end(), auxTable); diff --git a/src/nfa/mcclellancompile.cpp b/src/nfa/mcclellancompile.cpp index bf9b407a..26e22627 100644 --- a/src/nfa/mcclellancompile.cpp +++ b/src/nfa/mcclellancompile.cpp @@ -176,11 +176,11 @@ static mstate_aux *getAux(NFA *n, dstate_id_t i) { assert(isMcClellanType(n->type)); - const mcclellan *m = (mcclellan *)getMutableImplNfa(n); - mstate_aux *aux_base = (mstate_aux *)((char *)n + m->aux_offset); + const mcclellan *m = reinterpret_cast(getImplNfa(n)); + mstate_aux *aux_base = reinterpret_cast(reinterpret_cast(n) + m->aux_offset); mstate_aux *aux = aux_base + i; - assert((const char *)aux < (const char *)n + m->length); + assert(reinterpret_cast(aux) < reinterpret_cast(n) + m->length); return aux; } @@ -190,7 +190,7 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { assert(n->type == MCCLELLAN_NFA_16); u8 alphaShift = info.getAlphaShift(); u16 alphaSize = info.impl_alpha_size; - mcclellan *m = (mcclellan *)getMutableImplNfa(n); + mcclellan *m = reinterpret_cast(getMutableImplNfa(n)); /* handle the normal states */ for (u32 i = 0; i < m->sherman_limit; i++) { @@ -215,17 +215,17 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { } /* handle the sherman states */ - char *sherman_base_offset = (char *)n + m->sherman_offset; + char *sherman_base_offset = reinterpret_cast(n) + m->sherman_offset; u16 sherman_ceil = m->has_wide == 1 ? m->wide_limit : m->state_count; for (u16 j = m->sherman_limit; j < sherman_ceil; j++) { char *sherman_cur = findMutableShermanState(sherman_base_offset, m->sherman_limit, j); assert(*(sherman_cur + SHERMAN_TYPE_OFFSET) == SHERMAN_STATE); - u8 len = *(u8 *)(sherman_cur + SHERMAN_LEN_OFFSET); - u16 *succs = (u16 *)(sherman_cur + SHERMAN_STATES_OFFSET(len)); + u8 len = *(reinterpret_cast(sherman_cur + SHERMAN_LEN_OFFSET)); + u16 *succs = reinterpret_cast(sherman_cur + SHERMAN_STATES_OFFSET(len)); for (u8 i = 0; i < len; i++) { - u16 succ_i = unaligned_load_u16((u8 *)&succs[i]); + u16 succ_i = unaligned_load_u16(reinterpret_cast(&succs[i])); // wide state has no aux structure. if (m->has_wide && succ_i >= m->wide_limit) { continue; @@ -241,25 +241,25 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { succ_i |= ACCEL_FLAG; } - unaligned_store_u16((u8 *)&succs[i], succ_i); + unaligned_store_u16(reinterpret_cast(&succs[i]), succ_i); } } /* handle the wide states */ if (m->has_wide) { u32 wide_limit = m->wide_limit; - char *wide_base = (char *)n + m->wide_offset; + char *wide_base = reinterpret_cast(n) + m->wide_offset; assert(*wide_base == WIDE_STATE); u16 wide_number = verify_u16(info.wide_symbol_chain.size()); // traverse over wide head states. for (u16 j = wide_limit; j < wide_limit + wide_number; j++) { char *wide_cur = findMutableWideEntry16(wide_base, wide_limit, j); - u16 width = *(const u16 *)(wide_cur + WIDE_WIDTH_OFFSET); - u16 *trans = (u16 *)(wide_cur + WIDE_TRANSITION_OFFSET16(width)); + u16 width = *(reinterpret_cast(wide_cur + WIDE_WIDTH_OFFSET)); + u16 *trans = reinterpret_cast(wide_cur + WIDE_TRANSITION_OFFSET16(width)); // check successful transition - u16 next = unaligned_load_u16((u8 *)trans); + u16 next = unaligned_load_u16(reinterpret_cast(trans)); if (next < wide_limit) { const mstate_aux *aux = getAux(n, next); if (aux->accept) { @@ -268,13 +268,13 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { if (aux->accel_offset) { next |= ACCEL_FLAG; } - unaligned_store_u16((u8 *)trans, next); + unaligned_store_u16(reinterpret_cast(trans), next); } trans++; // check failure transition for (symbol_t k = 0; k < alphaSize; k++) { - u16 next_k = unaligned_load_u16((u8 *)&trans[k]); + u16 next_k = unaligned_load_u16(reinterpret_cast(&trans[k])); if (next_k >= wide_limit) { continue; } @@ -285,7 +285,7 @@ void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { if (aux_k->accel_offset) { next_k |= ACCEL_FLAG; } - unaligned_store_u16((u8 *)&trans[k], next_k); + unaligned_store_u16(reinterpret_cast(&trans[k]), next_k); } } } @@ -321,7 +321,7 @@ void populateBasicInfo(size_t state_size, const dfa_info &info, nfa->type = MCCLELLAN_NFA_16; } - mcclellan *m = (mcclellan *)getMutableImplNfa(nfa); + mcclellan *m = reinterpret_cast(getMutableImplNfa(nfa)); for (u32 i = 0; i < 256; i++) { m->remap[i] = verify_u8(info.alpha_remap[i]); } @@ -485,7 +485,7 @@ void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset, for (const auto &reps : rl) { ro.emplace_back(base_offset); - report_list *p = (report_list *)((char *)n + base_offset); + report_list *p = reinterpret_cast(reinterpret_cast(n) + base_offset); u32 i = 0; for (const ReportID report : reps.reports) { @@ -665,7 +665,7 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, DEBUG_PRINTF("total_size %zu\n", total_size); auto nfa = make_zeroed_bytecode_ptr(total_size); - char *nfa_base = (char *)nfa.get(); + char *nfa_base = reinterpret_cast(nfa.get()); populateBasicInfo(sizeof(u16), info, total_size, aux_offset, accel_offset, accel_escape_info.size(), arb, single, nfa.get()); @@ -674,9 +674,9 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, ri->fillReportLists(nfa.get(), aux_offset + aux_size, reportOffsets); - u16 *succ_table = (u16 *)(nfa_base + sizeof(NFA) + sizeof(mcclellan)); - mstate_aux *aux = (mstate_aux *)(nfa_base + aux_offset); - mcclellan *m = (mcclellan *)getMutableImplNfa(nfa.get()); + u16 *succ_table = reinterpret_cast(nfa_base + sizeof(NFA) + sizeof(mcclellan)); + mstate_aux *aux = reinterpret_cast(nfa_base + aux_offset); + mcclellan *m = reinterpret_cast(getMutableImplNfa(nfa.get())); m->wide_limit = wide_limit; m->wide_offset = wide_offset; @@ -710,7 +710,7 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, assert(accel_offset + sizeof(NFA) <= sherman_offset); assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); info.strat.buildAccel(i, accel_escape_info.at(i), - (void *)((char *)m + this_aux->accel_offset)); + reinterpret_cast(reinterpret_cast(m) + this_aux->accel_offset)); } } @@ -740,17 +740,17 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, assert(accel_offset + sizeof(NFA) <= sherman_offset); assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); info.strat.buildAccel(i, accel_escape_info.at(i), - (void *)((char *)m + this_aux->accel_offset)); + reinterpret_cast(reinterpret_cast(m) + this_aux->accel_offset)); } u8 len = verify_u8(info.impl_alpha_size - info.extra[i].daddytaken); assert(len <= 9); dstate_id_t d = info.states[i].daddy; - *(u8 *)(curr_sherman_entry + SHERMAN_TYPE_OFFSET) = SHERMAN_STATE; - *(u8 *)(curr_sherman_entry + SHERMAN_LEN_OFFSET) = len; - *(u16 *)(curr_sherman_entry + SHERMAN_DADDY_OFFSET) = info.implId(d); - u8 *chars = (u8 *)(curr_sherman_entry + SHERMAN_CHARS_OFFSET); + *(reinterpret_cast(curr_sherman_entry + SHERMAN_TYPE_OFFSET)) = SHERMAN_STATE; + *(reinterpret_cast(curr_sherman_entry + SHERMAN_LEN_OFFSET)) = len; + *(reinterpret_cast(curr_sherman_entry + SHERMAN_DADDY_OFFSET)) = info.implId(d); + u8 *chars = reinterpret_cast(curr_sherman_entry + SHERMAN_CHARS_OFFSET); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { @@ -758,13 +758,13 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, } } - u16 *states = (u16 *)(curr_sherman_entry + SHERMAN_STATES_OFFSET(len)); + u16 *states = reinterpret_cast(curr_sherman_entry + SHERMAN_STATES_OFFSET(len)); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { DEBUG_PRINTF("s overrider %hu dad %hu char next %hu\n", fs, info.implId(d), info.implId(info.states[i].next[s])); - unaligned_store_u16((u8 *)states++, + unaligned_store_u16(reinterpret_cast(states++), info.implId(info.states[i].next[s])); } } @@ -777,13 +777,13 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, assert(ISALIGNED_16(wide_base)); char *wide_top = wide_base; - *(u8 *)(wide_top++) = WIDE_STATE; + *(reinterpret_cast(wide_top++)) = WIDE_STATE; wide_top = ROUNDUP_PTR(wide_top, 2); - *(u16 *)(wide_top) = wide_number; + *(reinterpret_cast(wide_top)) = wide_number; wide_top += 2; char *curr_wide_entry = wide_top + wide_number * sizeof(u32); - u32 *wide_offset_list = (u32 *)wide_top; + u32 *wide_offset_list = reinterpret_cast(wide_top); /* get the order of writing wide states */ vector order(wide_number); @@ -798,8 +798,8 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, const vector &symbol_chain = info.wide_symbol_chain[i]; u16 width = verify_u16(symbol_chain.size()); - *(u16 *)(curr_wide_entry + WIDE_WIDTH_OFFSET) = width; - u8 *chars = (u8 *)(curr_wide_entry + WIDE_SYMBOL_OFFSET16); + *(reinterpret_cast(curr_wide_entry + WIDE_WIDTH_OFFSET)) = width; + u8 *chars = reinterpret_cast(curr_wide_entry + WIDE_SYMBOL_OFFSET16); // store wide state symbol chain for (size_t j = 0; j < width; j++) { @@ -807,7 +807,7 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, } // store wide state transition table - u16 *trans = (u16 *)(curr_wide_entry + u16 *trans = reinterpret_cast(curr_wide_entry + WIDE_TRANSITION_OFFSET16(width)); dstate_id_t tail = state_chain[width - 1]; symbol_t last = symbol_chain[width -1]; @@ -831,7 +831,7 @@ bytecode_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, *wide_offset_list++ = verify_u32(curr_wide_entry - wide_base); - curr_wide_entry = (char *)trans; + curr_wide_entry = reinterpret_cast(trans); } } @@ -953,9 +953,9 @@ bytecode_ptr mcclellanCompile8(dfa_info &info, const CompileContext &cc, assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); auto nfa = make_zeroed_bytecode_ptr(total_size); - char *nfa_base = (char *)nfa.get(); + char *nfa_base = reinterpret_cast(nfa.get()); - mcclellan *m = (mcclellan *)getMutableImplNfa(nfa.get()); + mcclellan *m = reinterpret_cast(getMutableImplNfa(nfa.get())); allocateFSN8(info, accel_escape_info, &m->accel_limit_8, &m->accept_limit_8); @@ -967,8 +967,8 @@ bytecode_ptr mcclellanCompile8(dfa_info &info, const CompileContext &cc, ri->fillReportLists(nfa.get(), aux_offset + aux_size, reportOffsets); /* copy in the state information */ - u8 *succ_table = (u8 *)(nfa_base + sizeof(NFA) + sizeof(mcclellan)); - mstate_aux *aux = (mstate_aux *)(nfa_base + aux_offset); + u8 *succ_table = reinterpret_cast(nfa_base + sizeof(NFA) + sizeof(mcclellan)); + mstate_aux *aux = reinterpret_cast(nfa_base + aux_offset); for (size_t i = 0; i < info.size(); i++) { if (contains(accel_escape_info, i)) { @@ -978,7 +978,7 @@ bytecode_ptr mcclellanCompile8(dfa_info &info, const CompileContext &cc, accel_offset += info.strat.accelSize(); info.strat.buildAccel(i, accel_escape_info.at(i), - (void *)((char *)m + aux[j].accel_offset)); + reinterpret_cast(reinterpret_cast(m) + aux[j].accel_offset)); } fillInBasicState8(info, aux, succ_table, reportOffsets, reports, @@ -1550,7 +1550,7 @@ u32 mcclellanStartReachSize(const raw_dfa *raw) { } bool has_accel_mcclellan(const NFA *nfa) { - const mcclellan *m = (const mcclellan *)getImplNfa(nfa); + const mcclellan *m = reinterpret_cast(getImplNfa(nfa)); return m->has_accel; } diff --git a/src/nfa/mpvcompile.cpp b/src/nfa/mpvcompile.cpp index d85c90b0..69ddfdcb 100644 --- a/src/nfa/mpvcompile.cpp +++ b/src/nfa/mpvcompile.cpp @@ -180,25 +180,27 @@ void writeKiloPuff(const map>::const_iterator &it, #ifdef HAVE_SVE2 } else if (reach.count() >= 240) { kp->type = MPV_VERM16; - vermicelli16Build(~reach, (u8 *)&kp->u.verm16.mask); + vermicelli16Build(~reach, reinterpret_casT(&kp->u.verm16.mask)); } else if (reach.count() <= 16) { kp->type = MPV_NVERM16; - vermicelli16Build(reach, (u8 *)&kp->u.verm16.mask); + vermicelli16Build(reach, reinterpret_cast(&kp->u.verm16.mask)); #endif // HAVE_SVE2 - } else if (shuftiBuildMasks(~reach, (u8 *)&kp->u.shuf.mask_lo, - (u8 *)&kp->u.shuf.mask_hi) != -1) { + } else if (shuftiBuildMasks(~reach, + reinterpret_cast(&kp->u.shuf.mask_lo), + reinterpret_cast(&kp->u.shuf.mask_hi)) != -1) { kp->type = MPV_SHUFTI; } else { kp->type = MPV_TRUFFLE; - truffleBuildMasks(~reach, (u8 *)&kp->u.truffle.mask1, - (u8 *)&kp->u.truffle.mask2); + truffleBuildMasks(~reach, + reinterpret_cast(&kp->u.truffle.mask1), + reinterpret_cast(&kp->u.truffle.mask2)); } kp->count = verify_u32(puffs.size()); kp->counter_offset = counter_offset; /* start of real puffette array */ - kp->puffette_offset = verify_u32((char *)*pa - (char *)m); + kp->puffette_offset = verify_u32(reinterpret_cast(*pa) - reinterpret_cast(m)); for (size_t i = 0; i < puffs.size(); i++) { assert(!it->first.auto_restart || puffs[i].unbounded); writePuffette(*pa + i, puffs[i], rm); @@ -355,8 +357,8 @@ bytecode_ptr mpvCompile(const vector &puffs_in, auto nfa = make_zeroed_bytecode_ptr(len); - mpv_puffette *pa_base = (mpv_puffette *) - ((char *)nfa.get() + sizeof(NFA) + sizeof(mpv) + char *nfa_base = reinterpret_cast(nfa.get()); + mpv_puffette *pa_base = reinterpret_cast(nfa_base + sizeof(NFA) + sizeof(mpv) + sizeof(mpv_kilopuff) * puff_clusters.size() + sizeof(mpv_counter_info) * counters.size()); mpv_puffette *pa = pa_base; @@ -373,7 +375,7 @@ bytecode_ptr mpvCompile(const vector &puffs_in, min_repeat = min(min_repeat, puffs.front().repeats); } - mpv *m = (mpv *)getMutableImplNfa(nfa.get()); + mpv *m = reinterpret_cast(getMutableImplNfa(nfa.get())); m->kilo_count = verify_u32(puff_clusters.size()); m->counter_count = verify_u32(counters.size()); m->puffette_count = puffette_count; @@ -384,7 +386,7 @@ bytecode_ptr mpvCompile(const vector &puffs_in, m->top_kilo_begin = verify_u32(triggered_puffs.size()); m->top_kilo_end = verify_u32(puff_clusters.size()); - mpv_kilopuff *kp_begin = (mpv_kilopuff *)(m + 1); + mpv_kilopuff *kp_begin = reinterpret_cast(m + 1); mpv_kilopuff *kp = kp_begin; for (auto it = puff_clusters.begin(); it != puff_clusters.end(); ++it) { writeKiloPuff(it, rm, @@ -392,14 +394,14 @@ bytecode_ptr mpvCompile(const vector &puffs_in, kp, &pa); ++kp; } - assert((char *)pa == (char *)nfa.get() + len); + assert(reinterpret_cast(pa) == nfa_base + len); - mpv_counter_info *out_ci = (mpv_counter_info *)kp; + mpv_counter_info *out_ci = reinterpret_cast(kp); for (const auto &counter : counters) { *out_ci = counter; ++out_ci; } - assert((char *)out_ci == (char *)pa_base); + assert(reinterpret_cast(out_ci) == reinterpret_cast(pa_base)); writeCoreNfa(nfa.get(), len, min_repeat, max_counter, curr_comp_offset, curr_decomp_offset); diff --git a/src/nfa/nfa_build_util.cpp b/src/nfa/nfa_build_util.cpp index 522ab231..7139ce99 100644 --- a/src/nfa/nfa_build_util.cpp +++ b/src/nfa/nfa_build_util.cpp @@ -86,14 +86,14 @@ typedef bool (*nfa_dispatch_fn)(const NFA *nfa); template static bool has_accel_limex(const NFA *nfa) { - const T *limex = (const T *)getImplNfa(nfa); + const T *limex = reinterpret_cast(getImplNfa(nfa)); return limex->accelCount; } template static bool has_repeats_limex(const NFA *nfa) { - const T *limex = (const T *)getImplNfa(nfa); + const T *limex = reinterpret_cast(getImplNfa(nfa)); return limex->repeatCount; } @@ -101,16 +101,16 @@ bool has_repeats_limex(const NFA *nfa) { template static bool has_repeats_other_than_firsts_limex(const NFA *nfa) { - const T *limex = (const T *)getImplNfa(nfa); - const char *ptr = (const char *)limex; + const T *limex = reinterpret_cast(getImplNfa(nfa)); + const char *ptr = reinterpret_cast(limex); - const u32 *repeatOffset = (const u32 *)(ptr + limex->repeatOffset); + const u32 *repeatOffset = reinterpret_cast(ptr + limex->repeatOffset); for (u32 i = 0; i < limex->repeatCount; i++) { u32 offset = repeatOffset[i]; - const NFARepeatInfo *info = (const NFARepeatInfo *)(ptr + offset); + const NFARepeatInfo *info = reinterpret_cast(ptr + offset); const RepeatInfo *repeat = - (const RepeatInfo *)((const char *)info + sizeof(*info)); + reinterpret_cast(reinterpret_cast(info) + sizeof(*info)); if (repeat->type != REPEAT_FIRST) { return true; }