mirror of
https://github.com/VectorCamp/vectorscan.git
synced 2025-06-28 16:41:01 +03:00
cStyleCasts
This commit is contained in:
gtsoul-tech
parent
db92a42681
commit
2fa06dd9ed
@ -72,7 +72,7 @@ u32 depth_to_u32(const depth &d) {
|
||||
|
||||
template<class LbrStruct> static
|
||||
u64a* getTable(NFA *nfa) {
|
||||
char *ptr = (char *)nfa + sizeof(struct NFA) + sizeof(LbrStruct) +
|
||||
char *ptr = reinterpret_cast<char *>(nfa) + sizeof(struct NFA) + sizeof(LbrStruct) +
|
||||
sizeof(RepeatInfo);
|
||||
ptr = ROUNDUP_PTR(ptr, alignof(u64a));
|
||||
return (u64a *)ptr;
|
||||
@ -95,7 +95,7 @@ void fillNfa(NFA *nfa, lbr_common *c, ReportID report, const depth &repeatMin,
|
||||
c->repeatInfoOffset = info_offset;
|
||||
c->report = report;
|
||||
|
||||
RepeatInfo *info = (RepeatInfo *)((char *)c + info_offset);
|
||||
RepeatInfo *info = reinterpret_cast<RepeatInfo *>(reinterpret_cast<char *>(c) + info_offset);
|
||||
info->type = verify_u8(rtype);
|
||||
info->repeatMin = depth_to_u32(repeatMin);
|
||||
info->repeatMax = depth_to_u32(repeatMax);
|
||||
@ -160,7 +160,7 @@ bytecode_ptr<NFA> buildLbrDot(const CharReach &cr, const depth &repeatMin,
|
||||
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
|
||||
is_reset);
|
||||
auto nfa = makeLbrNfa<lbr_dot>(LBR_NFA_DOT, rtype, repeatMax);
|
||||
struct lbr_dot *ld = (struct lbr_dot *)getMutableImplNfa(nfa.get());
|
||||
struct lbr_dot *ld = reinterpret_cast<struct lbr_dot *>getMutableImplNfa(nfa.get());
|
||||
|
||||
fillNfa<lbr_dot>(nfa.get(), &ld->common, report, repeatMin, repeatMax,
|
||||
minPeriod, rtype);
|
||||
@ -205,7 +205,8 @@ bytecode_ptr<NFA> buildLbrNVerm(const CharReach &cr, const depth &repeatMin,
|
||||
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
|
||||
is_reset);
|
||||
auto nfa = makeLbrNfa<lbr_verm>(LBR_NFA_NVERM, rtype, repeatMax);
|
||||
struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get());
|
||||
struct lbr_verm *lv = reinterpret_cast<struct lbr_verm *>getMutableImplNfa(nfa.get());
|
||||
|
||||
lv->c = escapes.find_first();
|
||||
|
||||
fillNfa<lbr_verm>(nfa.get(), &lv->common, report, repeatMin, repeatMax,
|
||||
@ -222,12 +223,12 @@ bytecode_ptr<NFA> buildLbrShuf(const CharReach &cr, const depth &repeatMin,
|
||||
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
|
||||
is_reset);
|
||||
auto nfa = makeLbrNfa<lbr_shuf>(LBR_NFA_SHUF, rtype, repeatMax);
|
||||
struct lbr_shuf *ls = (struct lbr_shuf *)getMutableImplNfa(nfa.get());
|
||||
struct lbr_shuf *ls = reinterpret_cast<struct lbr_shuf *>getMutableImplNfa(nfa.get());
|
||||
|
||||
fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax,
|
||||
minPeriod, rtype);
|
||||
|
||||
if (shuftiBuildMasks(~cr, (u8 *)&ls->mask_lo, (u8 *)&ls->mask_hi) == -1) {
|
||||
if (shuftiBuildMasks(~cr, reinterpret_cast<u8 *>(&ls->mask_lo), reinterpret_cast<u8 *>(&ls->mask_hi)) == -1) {
|
||||
return bytecode_ptr<NFA>(nullptr);
|
||||
}
|
||||
|
||||
@ -242,12 +243,12 @@ bytecode_ptr<NFA> buildLbrTruf(const CharReach &cr, const depth &repeatMin,
|
||||
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
|
||||
is_reset);
|
||||
auto nfa = makeLbrNfa<lbr_truf>(LBR_NFA_TRUF, rtype, repeatMax);
|
||||
struct lbr_truf *lc = (struct lbr_truf *)getMutableImplNfa(nfa.get());
|
||||
struct lbr_truf *lc = reinterpret_cast<struct lbr_truf *>getMutableImplNfa(nfa.get());
|
||||
|
||||
fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax,
|
||||
minPeriod, rtype);
|
||||
|
||||
truffleBuildMasks(~cr, (u8 *)&lc->mask1, (u8 *)&lc->mask2);
|
||||
truffleBuildMasks(~cr, reinterpret_cast<u8 *>(&lc->mask1), reinterpret_cast<u8 *>(&lc->mask2));
|
||||
|
||||
DEBUG_PRINTF("built truffle lbr\n");
|
||||
return nfa;
|
||||
|
||||
@ -264,11 +264,11 @@ u32 anchoredStateSize(const anchored_matcher_info &atable) {
|
||||
// Walk the list until we find the last element; total state size will be
|
||||
// that engine's state offset plus its state requirement.
|
||||
while (curr->next_offset) {
|
||||
curr = (const anchored_matcher_info *)
|
||||
((const char *)curr + curr->next_offset);
|
||||
curr = reinterpret_cast<const anchored_matcher_info *>
|
||||
(reinterpret_cast<const char *>(curr) + curr->next_offset);
|
||||
}
|
||||
|
||||
const NFA *nfa = (const NFA *)((const char *)curr + sizeof(*curr));
|
||||
const NFA *nfa = reinterpret_cast<const NFA *>(reinterpret_cast<const char *>(curr) + sizeof(*curr));
|
||||
return curr->state_offset + nfa->streamStateSize;
|
||||
}
|
||||
|
||||
@ -890,12 +890,12 @@ buildAnchoredMatcher(const RoseBuildImpl &build, const vector<LitFragment> &frag
|
||||
|
||||
auto atable =
|
||||
make_zeroed_bytecode_ptr<anchored_matcher_info>(total_size, 64);
|
||||
char *curr = (char *)atable.get();
|
||||
char *curr = reinterpret_cast<char *>(atable.get());
|
||||
|
||||
u32 state_offset = 0;
|
||||
for (size_t i = 0; i < nfas.size(); i++) {
|
||||
const NFA *nfa = nfas[i].get();
|
||||
anchored_matcher_info *ami = (anchored_matcher_info *)curr;
|
||||
anchored_matcher_info *ami = reinterpret_cast<anchored_matcher_info *>(curr);
|
||||
const char *prev_curr = curr;
|
||||
|
||||
curr += sizeof(anchored_matcher_info);
|
||||
|
||||
@ -2019,7 +2019,7 @@ void buildCountingMiracles(build_context &bc) {
|
||||
rcm.c = cr.find_first();
|
||||
} else {
|
||||
rcm.shufti = 1;
|
||||
int rv = shuftiBuildMasks(cr, (u8 *)&rcm.lo, (u8 *)&rcm.hi);
|
||||
int rv = shuftiBuildMasks(cr, reinterpret_cast<u8 *>(&rcm.lo), reinterpret_cast<u8 *>(&rcm.hi));
|
||||
if (rv == -1) {
|
||||
DEBUG_PRINTF("failed to build shufti\n");
|
||||
lbi.countingMiracleCount = 0; /* remove counting miracle */
|
||||
@ -3504,7 +3504,7 @@ bytecode_ptr<RoseEngine> addSmallWriteEngine(const RoseBuildImpl &build,
|
||||
const size_t newSize = smwrOffset + smallWriteSize;
|
||||
|
||||
auto rose2 = make_zeroed_bytecode_ptr<RoseEngine>(newSize, 64);
|
||||
char *ptr = (char *)rose2.get();
|
||||
char *ptr = reinterpret_cast<char *>(rose2.get());
|
||||
memcpy(ptr, rose.get(), mainSize);
|
||||
memcpy(ptr + smwrOffset, smwr_engine.get(), smallWriteSize);
|
||||
|
||||
@ -3869,7 +3869,7 @@ bytecode_ptr<RoseEngine> RoseBuildImpl::buildFinalEngine(u32 minWidth) {
|
||||
// Copy in our prototype engine data.
|
||||
memcpy(engine.get(), &proto, sizeof(proto));
|
||||
|
||||
write_out(&engine->state_init, (char *)engine.get(), state_scatter,
|
||||
write_out(&engine->state_init, reinterpret_cast<char *>(engine.get()), state_scatter,
|
||||
state_scatter_aux_offset);
|
||||
|
||||
// Copy in the engine blob.
|
||||
|
||||
@ -566,7 +566,7 @@ const void *loadFromByteCodeOffset(const RoseEngine *t, u32 offset) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char *lt = (const char *)t + offset;
|
||||
const char *lt = reinterpret_cast<const char *>(t) + offset;
|
||||
return lt;
|
||||
}
|
||||
|
||||
@ -623,9 +623,9 @@ void dumpLookaround(ofstream &os, const RoseEngine *t,
|
||||
const ROSE_STRUCT_CHECK_LOOKAROUND *ri) {
|
||||
assert(ri);
|
||||
|
||||
const u8 *base = (const u8 *)t;
|
||||
const u8 *base = reinterpret_cast<const u8 *>(t);
|
||||
|
||||
const s8 *look = (const s8 *)base + ri->look_index;
|
||||
const s8 *look = reinterpret_cast<const s8 *>(base) + ri->look_index;
|
||||
const s8 *look_end = look + ri->count;
|
||||
const u8 *reach = base + ri->reach_index;
|
||||
|
||||
@ -644,9 +644,9 @@ void dumpMultipathLookaround(ofstream &os, const RoseEngine *t,
|
||||
const ROSE_STRUCT_MULTIPATH_LOOKAROUND *ri) {
|
||||
assert(ri);
|
||||
|
||||
const u8 *base = (const u8 *)t;
|
||||
const u8 *base = reinterpret_cast<const u8 *>(t);
|
||||
|
||||
const s8 *look_begin = (const s8 *)base + ri->look_index;
|
||||
const s8 *look_begin = reinterpret_cast<const s8 *>(base) + ri->look_index;
|
||||
const s8 *look_end = look_begin + ri->count;
|
||||
const u8 *reach_begin = base + ri->reach_index;
|
||||
|
||||
@ -707,8 +707,8 @@ static
|
||||
void dumpJumpTable(ofstream &os, const RoseEngine *t,
|
||||
const ROSE_STRUCT_SPARSE_ITER_BEGIN *ri) {
|
||||
auto *it =
|
||||
(const mmbit_sparse_iter *)loadFromByteCodeOffset(t, ri->iter_offset);
|
||||
auto *jumps = (const u32 *)loadFromByteCodeOffset(t, ri->jump_table);
|
||||
reinterpret_cast<const mmbit_sparse_iter *>(loadFromByteCodeOffset(t, ri->iter_offset));
|
||||
auto *jumps = reinterpret_cast<const u32 *>(loadFromByteCodeOffset(t, ri->jump_table));
|
||||
|
||||
for (const auto &key : sparseIterValues(it, t->rolesWithStateCount)) {
|
||||
os << " " << std::setw(4) << std::setfill(' ') << key << " : +"
|
||||
@ -865,7 +865,7 @@ void dumpMultipathShufti(ofstream &os, u32 len, const u8 *lo, const u8 *hi,
|
||||
case ROSE_INSTR_##name: { \
|
||||
os << " " << std::setw(4) << std::setfill('0') << (pc - pc_base) \
|
||||
<< ": " #name "\n"; \
|
||||
const auto *ri = (const struct ROSE_STRUCT_##name *)pc;
|
||||
const auto *ri = reinterpret_cast<const struct ROSE_STRUCT_##name *>(pc);
|
||||
|
||||
#define PROGRAM_NEXT_INSTRUCTION \
|
||||
pc += ROUNDUP_N(sizeof(*ri), ROSE_INSTR_MIN_ALIGN); \
|
||||
@ -877,7 +877,7 @@ static
|
||||
void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
const char *pc_base = pc;
|
||||
for (;;) {
|
||||
u8 code = *(const u8 *)pc;
|
||||
u8 code = *(reinterpret_cast<const u8 *>(pc));
|
||||
assert(code <= LAST_ROSE_INSTRUCTION);
|
||||
const size_t offset = pc - pc_base;
|
||||
switch (code) {
|
||||
@ -926,7 +926,7 @@ void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
os << " offset " << int{ri->offset} << endl;
|
||||
os << " reach_index " << ri->reach_index << endl;
|
||||
os << " fail_jump " << offset + ri->fail_jump << endl;
|
||||
const u8 *reach = (const u8 *)t + ri->reach_index;
|
||||
const u8 *reach = reinterpret_cast<const u8 *>(t) + ri->reach_index;
|
||||
os << " contents ";
|
||||
describeClass(os, bitvectorToReach(reach), 1000, CC_OUT_TEXT);
|
||||
os << endl;
|
||||
@ -1347,7 +1347,7 @@ void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
PROGRAM_CASE(CHECK_LONG_LIT) {
|
||||
os << " lit_offset " << ri->lit_offset << endl;
|
||||
os << " lit_length " << ri->lit_length << endl;
|
||||
const char *lit = (const char *)t + ri->lit_offset;
|
||||
const char *lit = reinterpret_cast<const char *>(t) + ri->lit_offset;
|
||||
os << " literal: \""
|
||||
<< escapeString(string(lit, ri->lit_length)) << "\"" << endl;
|
||||
os << " fail_jump " << offset + ri->fail_jump << endl;
|
||||
@ -1357,7 +1357,7 @@ void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
PROGRAM_CASE(CHECK_LONG_LIT_NOCASE) {
|
||||
os << " lit_offset " << ri->lit_offset << endl;
|
||||
os << " lit_length " << ri->lit_length << endl;
|
||||
const char *lit = (const char *)t + ri->lit_offset;
|
||||
const char *lit = reinterpret_cast<const char *>(t) + ri->lit_offset;
|
||||
os << " literal: \""
|
||||
<< escapeString(string(lit, ri->lit_length)) << "\"" << endl;
|
||||
os << " fail_jump " << offset + ri->fail_jump << endl;
|
||||
@ -1367,7 +1367,7 @@ void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
PROGRAM_CASE(CHECK_MED_LIT) {
|
||||
os << " lit_offset " << ri->lit_offset << endl;
|
||||
os << " lit_length " << ri->lit_length << endl;
|
||||
const char *lit = (const char *)t + ri->lit_offset;
|
||||
const char *lit = reinterpret_cast<const char *>(t) + ri->lit_offset;
|
||||
os << " literal: \""
|
||||
<< escapeString(string(lit, ri->lit_length)) << "\"" << endl;
|
||||
os << " fail_jump " << offset + ri->fail_jump << endl;
|
||||
@ -1377,7 +1377,7 @@ void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) {
|
||||
PROGRAM_CASE(CHECK_MED_LIT_NOCASE) {
|
||||
os << " lit_offset " << ri->lit_offset << endl;
|
||||
os << " lit_length " << ri->lit_length << endl;
|
||||
const char *lit = (const char *)t + ri->lit_offset;
|
||||
const char *lit = reinterpret_cast<const char *>(t) + ri->lit_offset;
|
||||
os << " literal: \""
|
||||
<< escapeString(string(lit, ri->lit_length)) << "\"" << endl;
|
||||
os << " fail_jump " << offset + ri->fail_jump << endl;
|
||||
@ -1585,7 +1585,7 @@ void dumpRoseLitPrograms(const vector<LitFragment> &fragments,
|
||||
|
||||
for (u32 prog_offset : programs) {
|
||||
os << "Program @ " << prog_offset << ":" << endl;
|
||||
const char *prog = (const char *)loadFromByteCodeOffset(t, prog_offset);
|
||||
const char *prog = reinterpret_cast<const char *>(loadFromByteCodeOffset(t, prog_offset));
|
||||
dumpProgram(os, t, prog);
|
||||
os << endl;
|
||||
}
|
||||
@ -1596,7 +1596,7 @@ void dumpRoseLitPrograms(const vector<LitFragment> &fragments,
|
||||
static
|
||||
void dumpRoseEodPrograms(const RoseEngine *t, const string &filename) {
|
||||
ofstream os(filename);
|
||||
const char *base = (const char *)t;
|
||||
const char *base = reinterpret_cast<const char *>(t);
|
||||
|
||||
if (t->eodProgramOffset) {
|
||||
os << "EOD Program @ " << t->eodProgramOffset << ":" << endl;
|
||||
@ -1612,7 +1612,7 @@ void dumpRoseEodPrograms(const RoseEngine *t, const string &filename) {
|
||||
static
|
||||
void dumpRoseFlushCombPrograms(const RoseEngine *t, const string &filename) {
|
||||
ofstream os(filename);
|
||||
const char *base = (const char *)t;
|
||||
const char *base = reinterpret_cast<const char *>(t);
|
||||
|
||||
if (t->flushCombProgramOffset) {
|
||||
os << "Flush Combination Program @ " << t->flushCombProgramOffset
|
||||
@ -1630,7 +1630,7 @@ static
|
||||
void dumpRoseLastFlushCombPrograms(const RoseEngine *t,
|
||||
const string &filename) {
|
||||
ofstream os(filename);
|
||||
const char *base = (const char *)t;
|
||||
const char *base = reinterpret_cast<const char *>(t);
|
||||
|
||||
if (t->lastFlushCombProgramOffset) {
|
||||
os << "Last Flush Combination Program @ "
|
||||
@ -1649,8 +1649,8 @@ static
|
||||
void dumpRoseReportPrograms(const RoseEngine *t, const string &filename) {
|
||||
ofstream os(filename);
|
||||
|
||||
const u32 *programs =
|
||||
(const u32 *)loadFromByteCodeOffset(t, t->reportProgramOffset);
|
||||
const u32 *programs = reinterpret_cast<const u32 *>
|
||||
(loadFromByteCodeOffset(t, t->reportProgramOffset));
|
||||
|
||||
for (u32 i = 0; i < t->reportProgramCount; i++) {
|
||||
os << "Report " << i << endl;
|
||||
@ -1659,7 +1659,7 @@ void dumpRoseReportPrograms(const RoseEngine *t, const string &filename) {
|
||||
if (programs[i]) {
|
||||
os << "Program @ " << programs[i] << ":" << endl;
|
||||
const char *prog =
|
||||
(const char *)loadFromByteCodeOffset(t, programs[i]);
|
||||
reinterpret_cast<const char *>(loadFromByteCodeOffset(t, programs[i]));
|
||||
dumpProgram(os, t, prog);
|
||||
} else {
|
||||
os << "<No Program>" << endl;
|
||||
@ -1674,7 +1674,7 @@ void dumpRoseAnchoredPrograms(const RoseEngine *t, const string &filename) {
|
||||
ofstream os(filename);
|
||||
|
||||
const u32 *programs =
|
||||
(const u32 *)loadFromByteCodeOffset(t, t->anchoredProgramOffset);
|
||||
reinterpret_cast<const u32 *>(loadFromByteCodeOffset(t, t->anchoredProgramOffset));
|
||||
|
||||
for (u32 i = 0; i < t->anchored_count; i++) {
|
||||
os << "Anchored entry " << i << endl;
|
||||
@ -1683,7 +1683,7 @@ void dumpRoseAnchoredPrograms(const RoseEngine *t, const string &filename) {
|
||||
if (programs[i]) {
|
||||
os << "Program @ " << programs[i] << ":" << endl;
|
||||
const char *prog =
|
||||
(const char *)loadFromByteCodeOffset(t, programs[i]);
|
||||
reinterpret_cast<const char *>(loadFromByteCodeOffset(t, programs[i]));
|
||||
dumpProgram(os, t, prog);
|
||||
} else {
|
||||
os << "<No Program>" << endl;
|
||||
@ -1699,7 +1699,7 @@ void dumpRoseDelayPrograms(const RoseEngine *t, const string &filename) {
|
||||
ofstream os(filename);
|
||||
|
||||
const u32 *programs =
|
||||
(const u32 *)loadFromByteCodeOffset(t, t->delayProgramOffset);
|
||||
reinterpret_cast<const u32 *>(loadFromByteCodeOffset(t, t->delayProgramOffset));
|
||||
|
||||
for (u32 i = 0; i < t->delay_count; i++) {
|
||||
os << "Delay entry " << i << endl;
|
||||
@ -1708,7 +1708,7 @@ void dumpRoseDelayPrograms(const RoseEngine *t, const string &filename) {
|
||||
if (programs[i]) {
|
||||
os << "Program @ " << programs[i] << ":" << endl;
|
||||
const char *prog =
|
||||
(const char *)loadFromByteCodeOffset(t, programs[i]);
|
||||
reinterpret_cast<const char *>(loadFromByteCodeOffset(t, programs[i]));
|
||||
dumpProgram(os, t, prog);
|
||||
} else {
|
||||
os << "<No Program>" << endl;
|
||||
@ -1767,7 +1767,7 @@ void dumpNfaNotes(ofstream &fout, const RoseEngine *t, const NFA *n) {
|
||||
}
|
||||
if (left->countingMiracleOffset) {
|
||||
const RoseCountingMiracle *cm
|
||||
= (const RoseCountingMiracle *)((const char *)t
|
||||
= reinterpret_cast<const RoseCountingMiracle *>(reinterpret_cast<const char *>(t)
|
||||
+ left->countingMiracleOffset);
|
||||
fout << " counting_miracle:" << (int)cm->count
|
||||
<< (cm->shufti ? "s" : "v");
|
||||
@ -1794,7 +1794,7 @@ void dumpComponentInfo(const RoseEngine *t, const string &base) {
|
||||
|
||||
fout << left << setw(6) << i << " ";
|
||||
|
||||
fout << left << ((const char *)n - (const char *)t) << "\t"; /* offset */
|
||||
fout << left << (reinterpret_cast<const char *>(n) - reinterpret_cast<const char *>(t)) << "\t"; /* offset */
|
||||
|
||||
fout << left << setw(16) << describe(*n) << "\t";
|
||||
|
||||
@ -1855,8 +1855,8 @@ void dumpComponentInfoCsv(const RoseEngine *t, const string &base) {
|
||||
notes << "miracles;";
|
||||
}
|
||||
if (left->countingMiracleOffset) {
|
||||
auto cm = (const RoseCountingMiracle *)
|
||||
((const char *)t + left->countingMiracleOffset);
|
||||
auto cm = reinterpret_cast<const RoseCountingMiracle *>
|
||||
(reinterpret_cast<const char *>(t) + left->countingMiracleOffset);
|
||||
notes << "counting_miracle:" << (int)cm->count
|
||||
<< (cm->shufti ? "s" : "v") << ";";
|
||||
}
|
||||
@ -1869,7 +1869,7 @@ void dumpComponentInfoCsv(const RoseEngine *t, const string &base) {
|
||||
}
|
||||
|
||||
fprintf(f, "%u,%zd,\"%s\",%u,%u,%u,%s,%s\n", i,
|
||||
(const char *)n - (const char *)t, describe(*n).c_str(),
|
||||
(reinterpret_cast<const char *>(n) - reinterpret_cast<const char *>(t)), describe(*n).c_str(),
|
||||
n->nPositions, n->streamStateSize, n->length,
|
||||
to_string(kind).c_str(), notes.str().c_str());
|
||||
}
|
||||
@ -1880,7 +1880,7 @@ void dumpExhaust(const RoseEngine *t, const string &base) {
|
||||
StdioFile f(base + "/rose_exhaust.csv", "w");
|
||||
|
||||
const NfaInfo *infos
|
||||
= (const NfaInfo *)((const char *)t + t->nfaInfoOffset);
|
||||
= reinterpret_cast<const NfaInfo *>(reinterpret_cast<const char *>(t) + t->nfaInfoOffset);
|
||||
|
||||
u32 queue_count = t->activeArrayCount;
|
||||
|
||||
@ -1890,7 +1890,7 @@ void dumpExhaust(const RoseEngine *t, const string &base) {
|
||||
fprintf(f, "%u (%u):", i, ekey_offset);
|
||||
|
||||
if (ekey_offset) {
|
||||
const u32 *ekeys = (const u32 *)((const char *)t + ekey_offset);
|
||||
const u32 *ekeys = reinterpret_cast<const u32 *>(reinterpret_cast<const char *>(t) + ekey_offset);
|
||||
while (1) {
|
||||
u32 e = *ekeys;
|
||||
++ekeys;
|
||||
@ -1934,12 +1934,12 @@ void dumpRevComponentInfo(const RoseEngine *t, const string &base) {
|
||||
|
||||
fout << "Index Offset\tEngine \tStates S.State Bytes\n";
|
||||
|
||||
const char *tp = (const char *)t;
|
||||
const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset);
|
||||
const char *tp = reinterpret_cast<const char *>(t);
|
||||
const u32 *rev_offsets = reinterpret_cast<const u32 *>(tp + t->somRevOffsetOffset);
|
||||
|
||||
for (u32 i = 0; i < t->somRevCount; i++) {
|
||||
u32 offset = rev_offsets[i];
|
||||
const NFA *n = (const NFA *)(tp + offset);
|
||||
const NFA *n = reinterpret_cast<const NFA *>(tp + offset);
|
||||
|
||||
fout << left << setw(6) << i << " ";
|
||||
|
||||
@ -1956,11 +1956,11 @@ void dumpRevComponentInfo(const RoseEngine *t, const string &base) {
|
||||
|
||||
static
|
||||
void dumpRevNfas(const RoseEngine *t, bool dump_raw, const string &base) {
|
||||
const char *tp = (const char *)t;
|
||||
const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset);
|
||||
const char *tp = reinterpret_cast<const char *>(t);
|
||||
const u32 *rev_offsets = reinterpret_cast<const u32 *>(tp + t->somRevOffsetOffset);
|
||||
|
||||
for (u32 i = 0; i < t->somRevCount; i++) {
|
||||
const NFA *n = (const NFA *)(tp + rev_offsets[i]);
|
||||
const NFA *n = reinterpret_cast<const NFA *>(tp + rev_offsets[i]);
|
||||
|
||||
stringstream ssbase;
|
||||
ssbase << base << "som_rev_nfa_" << i;
|
||||
@ -1979,17 +1979,17 @@ static
|
||||
void dumpAnchored(const RoseEngine *t, const string &base) {
|
||||
u32 i = 0;
|
||||
const anchored_matcher_info *curr
|
||||
= (const anchored_matcher_info *)getALiteralMatcher(t);
|
||||
= reinterpret_cast<const anchored_matcher_info *>(getALiteralMatcher(t));
|
||||
|
||||
while (curr) {
|
||||
const NFA *n = (const NFA *)((const char *)curr + sizeof(*curr));
|
||||
const NFA *n = reinterpret_cast<const NFA *>(reinterpret_cast<const char *>(curr) + sizeof(*curr));
|
||||
|
||||
stringstream ssbase;
|
||||
ssbase << base << "anchored_" << i;
|
||||
nfaGenerateDumpFiles(n, ssbase.str());
|
||||
|
||||
curr = curr->next_offset ? (const anchored_matcher_info *)
|
||||
((const char *)curr + curr->next_offset) : nullptr;
|
||||
curr = curr->next_offset ? reinterpret_cast<const anchored_matcher_info *>
|
||||
(reinterpret_cast<const char *>(curr) + curr->next_offset) : nullptr;
|
||||
i++;
|
||||
};
|
||||
}
|
||||
@ -1999,16 +1999,16 @@ void dumpAnchoredStats(const void *atable, FILE *f) {
|
||||
assert(atable);
|
||||
|
||||
u32 i = 0;
|
||||
const anchored_matcher_info *curr = (const anchored_matcher_info *)atable;
|
||||
const anchored_matcher_info *curr = reinterpret_cast<const anchored_matcher_info *>(atable);
|
||||
|
||||
while (curr) {
|
||||
const NFA *n = (const NFA *)((const char *)curr + sizeof(*curr));
|
||||
const NFA *n = reinterpret_cast<const NFA *>(reinterpret_cast<const char *>(curr) + sizeof(*curr));
|
||||
|
||||
fprintf(f, " NFA %u: %s, %u states (%u bytes)\n", i,
|
||||
describe(*n).c_str(), n->nPositions, n->length);
|
||||
|
||||
curr = curr->next_offset ? (const anchored_matcher_info *)
|
||||
((const char *)curr + curr->next_offset) : nullptr;
|
||||
curr = curr->next_offset ? reinterpret_cast<const anchored_matcher_info *>
|
||||
(reinterpret_cast<const char *>(curr) + curr->next_offset) : nullptr;
|
||||
i++;
|
||||
};
|
||||
|
||||
@ -2022,11 +2022,11 @@ void dumpLongLiteralSubtable(const RoseLongLitTable *ll_table,
|
||||
return;
|
||||
}
|
||||
|
||||
const char *base = (const char *)ll_table;
|
||||
const char *base = reinterpret_cast<const char *>(ll_table);
|
||||
|
||||
u32 nbits = ll_sub->hashBits;
|
||||
u32 num_entries = 1U << nbits;
|
||||
const auto *tab = (const RoseLongLitHashEntry *)(base + ll_sub->hashOffset);
|
||||
const auto *tab = reinterpret_cast<const RoseLongLitHashEntry *>(base + ll_sub->hashOffset);
|
||||
u32 hash_occ =
|
||||
count_if(tab, tab + num_entries, [](const RoseLongLitHashEntry &ent) {
|
||||
return ent.str_offset != 0;
|
||||
@ -2038,7 +2038,7 @@ void dumpLongLiteralSubtable(const RoseLongLitTable *ll_table,
|
||||
|
||||
u32 bloom_bits = ll_sub->bloomBits;
|
||||
u32 bloom_size = 1U << bloom_bits;
|
||||
const u8 *bloom = (const u8 *)base + ll_sub->bloomOffset;
|
||||
const u8 *bloom = reinterpret_cast<const u8 *>(base) + ll_sub->bloomOffset;
|
||||
u32 bloom_occ = accumulate(bloom, bloom + bloom_size / 8, 0,
|
||||
[](const u32 &sum, const u8 &elem) { return sum + popcount32(elem); });
|
||||
float bloom_occ_percent = ((float)bloom_occ / (float)(bloom_size)) * 100;
|
||||
@ -2057,8 +2057,8 @@ void dumpLongLiteralTable(const RoseEngine *t, FILE *f) {
|
||||
fprintf(f, "Long literal table (streaming):\n");
|
||||
|
||||
const auto *ll_table =
|
||||
(const struct RoseLongLitTable *)loadFromByteCodeOffset(
|
||||
t, t->longLitTableOffset);
|
||||
reinterpret_cast<const struct RoseLongLitTable *>(loadFromByteCodeOffset(
|
||||
t, t->longLitTableOffset));
|
||||
|
||||
fprintf(f, " total size : %u bytes\n", ll_table->size);
|
||||
fprintf(f, " longest len : %u\n", ll_table->maxLen);
|
||||
|
||||
@ -454,7 +454,7 @@ void findForwardAccelScheme(const vector<AccelString> &lits,
|
||||
#endif // HAVE_SVE2
|
||||
|
||||
if (-1 !=
|
||||
shuftiBuildMasks(cr, (u8 *)&aux->shufti.lo, (u8 *)&aux->shufti.hi)) {
|
||||
shuftiBuildMasks(cr, reinterpret_cast<u8 *>(&aux->shufti.lo), reinterpret_cast<u8 *>(&aux->shufti.hi))) {
|
||||
DEBUG_PRINTF("built shufti for %s (%zu chars, offset %u)\n",
|
||||
describeClass(cr).c_str(), cr.count(), min_offset);
|
||||
aux->shufti.accel_type = ACCEL_SHUFTI;
|
||||
@ -462,7 +462,7 @@ void findForwardAccelScheme(const vector<AccelString> &lits,
|
||||
return;
|
||||
}
|
||||
|
||||
truffleBuildMasks(cr, (u8 *)&aux->truffle.mask1, (u8 *)&aux->truffle.mask2);
|
||||
truffleBuildMasks(cr, reinterpret_cast<u8 *>(&aux->truffle.mask1), reinterpret_cast<u8 *>(&aux->truffle.mask2));
|
||||
DEBUG_PRINTF("built truffle for %s (%zu chars, offset %u)\n",
|
||||
describeClass(cr).c_str(), cr.count(), min_offset);
|
||||
aux->truffle.accel_type = ACCEL_TRUFFLE;
|
||||
|
||||
@ -134,7 +134,7 @@ vector<u8> buildBloomFilter(const vector<ue2_case_string> &lits, size_t max_len,
|
||||
continue;
|
||||
}
|
||||
for (u32 offset = 1; offset < lit.s.size() - max_len + 1; offset++) {
|
||||
const u8 *substr = (const u8 *)lit.s.c_str() + offset;
|
||||
const u8 *substr = reinterpret_cast<const u8 *>(lit.s.c_str()) + offset;
|
||||
addToBloomFilter(bloom, substr, nocase);
|
||||
}
|
||||
}
|
||||
@ -234,7 +234,7 @@ map<u32, LitOffsetVector> computeLitHashes(const vector<ue2_case_string> &lits,
|
||||
continue;
|
||||
}
|
||||
for (u32 offset = 1; offset < lit.s.size() - max_len + 1; offset++) {
|
||||
const u8 *substr = (const u8 *)lit.s.c_str() + offset;
|
||||
const u8 *substr = reinterpret_cast<const u8 *>(lit.s.c_str()) + offset;
|
||||
u32 hash = hashLongLiteral(substr, max_len, lit.nocase);
|
||||
hashToLitOffPairs[hash].emplace_back(lit_id, offset);
|
||||
}
|
||||
@ -413,7 +413,7 @@ u32 buildLongLiteralTable(const RoseBuildImpl &build, RoseEngineBlob &blob,
|
||||
assert(table); // otherwise would have thrown std::bad_alloc
|
||||
|
||||
// Fill in the RoseLongLitTable header structure.
|
||||
RoseLongLitTable *header = (RoseLongLitTable *)(table.get());
|
||||
RoseLongLitTable *header = reinterpret_cast<RoseLongLitTable *>(table.get());
|
||||
header->size = verify_u32(tabSize);
|
||||
header->maxLen = verify_u8(max_len); // u8 so doesn't matter; won't go > 255
|
||||
header->caseful.hashOffset = verify_u32(htOffsetCase);
|
||||
|
||||
@ -68,7 +68,7 @@ void two_aligned_free(void *mem) {
|
||||
return;
|
||||
}
|
||||
// Allocated with two_aligned_malloc above.
|
||||
free((char *)mem - 2);
|
||||
free(static_cast<char *>(mem) - 2);
|
||||
}
|
||||
|
||||
TEST(CustomAllocator, TwoAlignedCompile) {
|
||||
|
||||
@ -58,14 +58,14 @@ TEST(ExtParam, LargeMinOffset) {
|
||||
// ensure it doesn't match.
|
||||
string corpus = "hatstand" + string(80000, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(0U, c.matches.size());
|
||||
|
||||
// Try exactly at the min_offset.
|
||||
corpus = "hatstand" + string(99983, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(100000, 0), c.matches[0]);
|
||||
@ -97,7 +97,7 @@ TEST(ExtParam, LargeExactOffset) {
|
||||
// ensure it doesn't match.
|
||||
string corpus = "hatstand" + string(199982, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(0U, c.matches.size());
|
||||
|
||||
@ -113,7 +113,7 @@ TEST(ExtParam, LargeExactOffset) {
|
||||
c.clear();
|
||||
corpus = "hatstand" + string(199984, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(0U, c.matches.size());
|
||||
|
||||
@ -143,14 +143,14 @@ TEST(ExtParam, LargeMinLength) {
|
||||
// short.
|
||||
string corpus = string(10000, '_') + "hatstand" + string(80000, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(0U, c.matches.size());
|
||||
|
||||
// Now, a match of the right length.
|
||||
corpus = string(10000, '_') + "hatstand" + string(99983, '_') + "teakettle";
|
||||
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(110000, 0), c.matches[0]);
|
||||
|
||||
@ -87,7 +87,7 @@ protected:
|
||||
static
|
||||
int count_cb(unsigned, unsigned long long, unsigned long long, unsigned,
|
||||
void *ctxt) {
|
||||
size_t *count = (size_t *)ctxt;
|
||||
size_t *count = static_cast<size_t *>(ctxt);
|
||||
(*count)++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -60,7 +60,7 @@ TEST(LogicalCombination, SingleComb1) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(16U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
|
||||
@ -108,7 +108,7 @@ TEST(LogicalCombination, SingleCombQuietSub1) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(8U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(18, 1001), c.matches[0]);
|
||||
@ -151,7 +151,7 @@ TEST(LogicalCombination, MultiCombQuietSub1) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(10U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
|
||||
@ -198,7 +198,7 @@ TEST(LogicalCombination, MultiHighlanderCombQuietSub1) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(4U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
|
||||
@ -237,7 +237,7 @@ TEST(LogicalCombination, MultiQuietCombQuietSub1) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(2U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
|
||||
@ -270,7 +270,7 @@ TEST(LogicalCombination, SingleComb2) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(13U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(6, 202), c.matches[0]);
|
||||
@ -315,7 +315,7 @@ TEST(LogicalCombination, SingleCombQuietSub2) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(8U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(18, 1002), c.matches[0]);
|
||||
@ -354,7 +354,7 @@ TEST(LogicalCombination, SingleComb3) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(17U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 301), c.matches[0]);
|
||||
@ -403,7 +403,7 @@ TEST(LogicalCombination, SingleCombQuietSub3) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(8U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(23, 303), c.matches[0]);
|
||||
@ -445,7 +445,7 @@ TEST(LogicalCombination, MultiCombDupSub4) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(23U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(6, 202), c.matches[0]);
|
||||
@ -503,7 +503,7 @@ TEST(LogicalCombination, MultiCombQuietDupSub4) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(17U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(18, 1002), c.matches[0]);
|
||||
@ -564,7 +564,7 @@ TEST(LogicalCombination, MultiCombUniSub5) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(46U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
|
||||
@ -656,7 +656,7 @@ TEST(LogicalCombination, MultiCombQuietUniSub5) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(30U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
|
||||
@ -717,7 +717,7 @@ TEST(LogicalCombination, SingleCombPurelyNegative6) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(53, 1002), c.matches[0]);
|
||||
@ -749,7 +749,7 @@ TEST(LogicalCombination, SingleCombQuietPurelyNegative6) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(0U, c.matches.size());
|
||||
|
||||
@ -793,7 +793,7 @@ TEST(LogicalCombination, MultiCombPurelyNegativeUniSub6) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(3U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(106, 202), c.matches[0]);
|
||||
@ -841,7 +841,7 @@ TEST(LogicalCombination, MultiCombPurelyNegativeUniSubEOD6) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(8U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(106, 102), c.matches[0]);
|
||||
@ -897,7 +897,7 @@ TEST(LogicalCombination, MultiCombStream1) {
|
||||
int i;
|
||||
for (i = 0; i < 11; i++) {
|
||||
err = hs_scan_stream(stream, data[i].c_str(), data[i].size(), 0,
|
||||
scratch, record_cb, (void *)&c);
|
||||
scratch, record_cb, reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
}
|
||||
err = hs_close_stream(stream, scratch, dummy_cb, nullptr);
|
||||
|
||||
@ -59,7 +59,7 @@ TEST(MMAdaptor, norm_cont1) { // UE-901
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(3U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
|
||||
@ -92,7 +92,7 @@ TEST(MMAdaptor, norm_cont2) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(3U, c.matches.size());
|
||||
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30)));
|
||||
@ -125,7 +125,7 @@ TEST(MMAdaptor, norm_halt1) {
|
||||
|
||||
c.halt = 1;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SCAN_TERMINATED, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
|
||||
@ -156,7 +156,7 @@ TEST(MMAdaptor, norm_halt2) { // UE-901
|
||||
|
||||
c.halt = 1;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SCAN_TERMINATED, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(20, 30), c.matches[0]);
|
||||
@ -187,7 +187,7 @@ TEST(MMAdaptor, high_cont1) { // UE-901
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(2U, c.matches.size());
|
||||
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(4, 30)));
|
||||
@ -219,7 +219,7 @@ TEST(MMAdaptor, high_cont2) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(2U, c.matches.size());
|
||||
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30)));
|
||||
@ -251,7 +251,7 @@ TEST(MMAdaptor, high_halt1) {
|
||||
|
||||
c.halt = 1;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SCAN_TERMINATED, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
|
||||
@ -282,7 +282,7 @@ TEST(MMAdaptor, high_halt2) {
|
||||
|
||||
c.halt = 1;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SCAN_TERMINATED, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_TRUE(MatchRecord(20, 30) == c.matches[0]
|
||||
@ -311,7 +311,7 @@ TEST(MPV, UE_2395) {
|
||||
|
||||
CallBackContext c;
|
||||
err = hs_scan(db, data.data(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
|
||||
unsigned seen = 39;
|
||||
@ -358,7 +358,7 @@ TEST(MMRoseLiteralPath, issue_141) {
|
||||
|
||||
c.halt = 0;
|
||||
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
|
||||
(void *)&c);
|
||||
reinterpret_cast<void *>(&c));
|
||||
ASSERT_EQ(HS_SUCCESS, err);
|
||||
ASSERT_EQ(1U, c.matches.size());
|
||||
ASSERT_EQ(MatchRecord(19, 0), c.matches[0]);
|
||||
|
||||
@ -148,7 +148,7 @@ void runVectoredTest(match_event_handler cb_func) {
|
||||
static
|
||||
int rescan_block_cb(unsigned, unsigned long long, unsigned long long, unsigned,
|
||||
void *ctx) {
|
||||
RescanContext *rctx = (RescanContext *)ctx;
|
||||
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
|
||||
rctx->matches++;
|
||||
|
||||
const string data = "___foo___bar_";
|
||||
@ -168,7 +168,7 @@ TEST(ScratchInUse, Block) {
|
||||
static
|
||||
int rescan_stream_cb(unsigned, unsigned long long, unsigned long long, unsigned,
|
||||
void *ctx) {
|
||||
RescanContext *rctx = (RescanContext *)ctx;
|
||||
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
|
||||
rctx->matches++;
|
||||
|
||||
const string data = "___foo___bar_";
|
||||
@ -197,7 +197,7 @@ TEST(ScratchInUse, Streaming) {
|
||||
static
|
||||
int rescan_vector_cb(unsigned, unsigned long long, unsigned long long, unsigned,
|
||||
void *ctx) {
|
||||
RescanContext *rctx = (RescanContext *)ctx;
|
||||
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
|
||||
rctx->matches++;
|
||||
|
||||
const string data1 = "___foo_";
|
||||
@ -221,7 +221,7 @@ TEST(ScratchInUse, Vectored) {
|
||||
static
|
||||
int rescan_realloc_cb(unsigned, unsigned long long, unsigned long long,
|
||||
unsigned, void *ctx) {
|
||||
RescanContext *rctx = (RescanContext *)ctx;
|
||||
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
|
||||
rctx->matches++;
|
||||
|
||||
auto db = makeDatabase("another db", 0, HS_MODE_BLOCK);
|
||||
@ -251,7 +251,7 @@ TEST(ScratchInUse, ReallocScratchVector) {
|
||||
static
|
||||
int rescan_free_cb(unsigned, unsigned long long, unsigned long long,
|
||||
unsigned, void *ctx) {
|
||||
RescanContext *rctx = (RescanContext *)ctx;
|
||||
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
|
||||
rctx->matches++;
|
||||
|
||||
hs_error_t err = hs_free_scratch(rctx->scratch);
|
||||
|
||||
@ -41,7 +41,7 @@ using namespace std;
|
||||
|
||||
int record_cb(unsigned id, unsigned long long, unsigned long long to,
|
||||
unsigned, void *ctxt) {
|
||||
CallBackContext *c = (CallBackContext *)ctxt;
|
||||
CallBackContext *c = reinterpret_cast<CallBackContext *>(ctxt);
|
||||
|
||||
c->matches.emplace_back(to, id);
|
||||
|
||||
@ -189,8 +189,8 @@ void *count_malloc(size_t n) {
|
||||
}
|
||||
|
||||
allocated_count += n;
|
||||
*(size_t *)pp = n;
|
||||
void *p = (char *)pp + 16;
|
||||
*(reinterpret_cast<size_t *>(pp)) = n;
|
||||
void *p = static_cast<char *>(pp) + 16;
|
||||
|
||||
return p;
|
||||
}
|
||||
@ -200,8 +200,8 @@ void count_free(void *p) {
|
||||
return;
|
||||
}
|
||||
|
||||
void *pp = (char *)p - 16;
|
||||
size_t n = *(size_t *)pp;
|
||||
void *pp = static_cast<char *>(p) - 16;
|
||||
size_t n = *(reinterpret_cast<size_t *>(pp));
|
||||
|
||||
allocated_count -= n;
|
||||
|
||||
@ -215,8 +215,8 @@ void *count_malloc_b(size_t n) {
|
||||
}
|
||||
|
||||
allocated_count_b += n;
|
||||
*(size_t *)pp = n;
|
||||
void *p = (char *)pp + 32;
|
||||
*(reinterpret_cast<size_t *>(pp)) = n;
|
||||
void *p = static_cast<char *>(pp) + 32;
|
||||
|
||||
return p;
|
||||
}
|
||||
@ -226,8 +226,8 @@ void count_free_b(void *p) {
|
||||
return;
|
||||
}
|
||||
|
||||
void *pp = (char *)p - 32;
|
||||
size_t n = *(size_t *)pp;
|
||||
void *pp = static_cast<char *>(p) - 32;
|
||||
size_t n = *(reinterpret_cast<size_t *>(pp));
|
||||
|
||||
allocated_count_b -= n;
|
||||
|
||||
|
||||
@ -70,7 +70,7 @@ TEST(CRC, alignments) {
|
||||
|
||||
// test the crc32c function at different alignments
|
||||
for (u8 i = 0; i < 32; i++) {
|
||||
u32 crc = Crc32c_ComputeBuf(0, (u8 *)a.data() + i, 4000);
|
||||
u32 crc = Crc32c_ComputeBuf(0, reinterpret_cast<u8 *>(a.data()) + i, 4000);
|
||||
ASSERT_EQ(crc, 0x94f04377U);
|
||||
}
|
||||
}
|
||||
|
||||
@ -73,7 +73,7 @@ struct LbrTestParams {
|
||||
|
||||
static
|
||||
int onMatch(u64a, u64a, ReportID, void *ctx) {
|
||||
unsigned *matches = (unsigned *)ctx;
|
||||
unsigned *matches = reinterpret_cast<unsigned *>(ctx);
|
||||
(*matches)++;
|
||||
return MO_CONTINUE_MATCHING;
|
||||
}
|
||||
@ -191,7 +191,7 @@ TEST_P(LbrTest, MatchMin) {
|
||||
const string corpus = matchingCorpus(params.min);
|
||||
|
||||
initQueue();
|
||||
q.buffer = (const u8 *)corpus.c_str();
|
||||
q.buffer = reinterpret_cast<const u8 *>(corpus.c_str());
|
||||
q.length = corpus.length();
|
||||
u64a end = corpus.length();
|
||||
|
||||
@ -238,7 +238,7 @@ TEST_P(LbrTest, QueueExecToMatch) {
|
||||
const string corpus = matchingCorpus(params.min);
|
||||
|
||||
initQueue();
|
||||
q.buffer = (const u8 *)corpus.c_str();
|
||||
q.buffer = reinterpret_cast<const u8 *>(corpus.c_str());
|
||||
q.length = corpus.length();
|
||||
u64a end = corpus.length();
|
||||
|
||||
|
||||
@ -305,7 +305,7 @@ TEST(MultiBit, It3) {
|
||||
const size_t test_size = 60;
|
||||
mmbit_holder ba(test_size, 4);
|
||||
|
||||
fill_n((u8 *)ba, mmbit_size(test_size) + 4, 0xff);
|
||||
fill_n(static_cast<u8 *>(ba), mmbit_size(test_size) + 4, 0xff);
|
||||
|
||||
mmbit_clear(ba, test_size);
|
||||
|
||||
|
||||
@ -66,13 +66,13 @@ void pack_bits<u64a>(char *out, const u64a *v, const u32 *bits,
|
||||
template <>
|
||||
void unpack_bits<u32>(u32 *v, const char *in, const u32 *bits,
|
||||
unsigned elements) {
|
||||
return unpack_bits_32(v, (const u8 *)in, bits, elements);
|
||||
return unpack_bits_32(v, reinterpret_cast<const u8 *>(in), bits, elements);
|
||||
}
|
||||
|
||||
template <>
|
||||
void unpack_bits<u64a>(u64a *v, const char *in, const u32 *bits,
|
||||
unsigned elements) {
|
||||
return unpack_bits_64(v, (const u8 *)in, bits, elements);
|
||||
return unpack_bits_64(v, reinterpret_cast<const u8 *>(in), bits, elements);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
|
||||
@ -738,7 +738,7 @@ protected:
|
||||
ptr = new char[sizeof(RepeatInfo) +
|
||||
sizeof(u64a) * (rsi.patchSize + 2)];
|
||||
|
||||
info = (struct RepeatInfo *)ptr;
|
||||
info = reinterpret_cast<struct RepeatInfo *>(ptr);
|
||||
|
||||
info->type = REPEAT_SPARSE_OPTIMAL_P;
|
||||
info->repeatMin = test_info.repeatMin;
|
||||
@ -756,7 +756,7 @@ protected:
|
||||
info->patchesOffset = rsi.patchesOffset;
|
||||
|
||||
u32 repeatMax = info->patchSize;
|
||||
u64a *table = (u64a *)(ROUNDUP_PTR((ptr + sizeof(RepeatInfo)),
|
||||
u64a *table = reinterpret_cast<u64a *>(ROUNDUP_PTR((ptr + sizeof(RepeatInfo)),
|
||||
alignof(u64a)));
|
||||
for (u32 i = 0; i < repeatMax + 1; i++) {
|
||||
table[i] = rsi.table[i];
|
||||
@ -859,8 +859,8 @@ TEST_P(SparseOptimalTest, TwoTopsNeg) {
|
||||
}
|
||||
}
|
||||
|
||||
const struct RepeatRingControl *xs = (const struct RepeatRingControl *)
|
||||
ctrl;
|
||||
const struct RepeatRingControl *xs = reinterpret_cast<const struct RepeatRingControl *>
|
||||
(ctrl);
|
||||
ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state,
|
||||
MAX(xs->offset, exit)));
|
||||
ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state,
|
||||
|
||||
@ -39,8 +39,8 @@ TEST(RVermicelli, ExecNoMatch1) {
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
for (size_t j = 0; j < 16; j++) {
|
||||
const u8 *begin = (const u8 *)t1 + i;
|
||||
const u8 *end = (const u8 *)t1 + strlen(t1) - j;
|
||||
const u8 *begin = reinterpret_cast<const u8 *>(t1) + i;
|
||||
const u8 *end = reinterpret_cast<const u8 *>(t1) + strlen(t1) - j;
|
||||
|
||||
const u8 *rv = rvermicelliExec('a', 0, begin, end);
|
||||
ASSERT_EQ(begin - 1, rv);
|
||||
@ -58,12 +58,12 @@ TEST(RVermicelli, Exec1) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
|
||||
|
||||
rv = rvermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1) + i, reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
|
||||
}
|
||||
@ -73,12 +73,12 @@ TEST(RVermicelli, Exec2) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
|
||||
|
||||
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
|
||||
}
|
||||
@ -88,12 +88,12 @@ TEST(RVermicelli, Exec3) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1)+ strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 47, (size_t)rv);
|
||||
|
||||
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
|
||||
}
|
||||
@ -104,11 +104,11 @@ TEST(RVermicelli, Exec4) {
|
||||
|
||||
for (size_t i = 0; i < 31; i++) {
|
||||
t1[16 + i] = 'a';
|
||||
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1));
|
||||
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv);
|
||||
|
||||
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv);
|
||||
}
|
||||
@ -116,7 +116,7 @@ TEST(RVermicelli, Exec4) {
|
||||
|
||||
TEST(RNVermicelli, ExecNoMatch1) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
|
||||
const u8 *buf = (const u8 *)t1;
|
||||
const u8 *buf = reinterpret_cast<const u8 *>(t1);
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
SCOPED_TRACE(i);
|
||||
@ -136,7 +136,7 @@ TEST(RNVermicelli, ExecNoMatch1) {
|
||||
|
||||
TEST(RNVermicelli, Exec1) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
|
||||
const u8 *buf = (const u8 *)t1;
|
||||
const u8 *buf = reinterpret_cast<const u8 *>(t1);
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
SCOPED_TRACE(i);
|
||||
@ -152,7 +152,7 @@ TEST(RNVermicelli, Exec1) {
|
||||
|
||||
TEST(RNVermicelli, Exec2) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbb";
|
||||
const u8 *buf = (const u8 *)t1;
|
||||
const u8 *buf = reinterpret_cast<const u8 *>(t1);
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
SCOPED_TRACE(i);
|
||||
@ -168,7 +168,7 @@ TEST(RNVermicelli, Exec2) {
|
||||
|
||||
TEST(RNVermicelli, Exec3) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbb";
|
||||
const u8 *buf = (const u8 *)t1;
|
||||
const u8 *buf = reinterpret_cast<const u8 *>(t1);
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
SCOPED_TRACE(i);
|
||||
@ -184,7 +184,7 @@ TEST(RNVermicelli, Exec3) {
|
||||
|
||||
TEST(RNVermicelli, Exec4) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
|
||||
const u8 *buf = (const u8 *)t1;
|
||||
const u8 *buf = reinterpret_cast<const u8 *>(t1);
|
||||
|
||||
for (size_t i = 0; i < 31; i++) {
|
||||
SCOPED_TRACE(i);
|
||||
@ -204,23 +204,23 @@ TEST(RDoubleVermicelli, Exec1) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'b', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'b', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 50, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i,
|
||||
(u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliDoubleExec('A', 'B', 1, reinterpret_cast<const u8 *>(t1)+ i,
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 50, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1 + i,
|
||||
(u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliDoubleExec('b', 'a', 0, reinterpret_cast<const u8 *>(t1) + i,
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 49, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i,
|
||||
(u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliDoubleExec('B', 'A', 1, reinterpret_cast<const u8 *>(t1) + i,
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 49, (size_t)rv);
|
||||
}
|
||||
@ -230,13 +230,13 @@ TEST(RDoubleVermicelli, Exec2) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
|
||||
}
|
||||
@ -247,23 +247,23 @@ TEST(RDoubleVermicelli, Exec3) {
|
||||
char t1[] = "bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb";
|
||||
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
const u8 *rv = rvermicelliDoubleExec('A', 'a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i );
|
||||
const u8 *rv = rvermicelliDoubleExec('A', 'a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i );
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 23, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('A', 'A', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliDoubleExec('A', 'A', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 22, (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('a', 'A', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
rv = rvermicelliDoubleExec('a', 'A', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)t1 + 21, (size_t)rv);
|
||||
}
|
||||
@ -275,11 +275,11 @@ TEST(RDoubleVermicelli, Exec4) {
|
||||
for (size_t i = 0; i < 31; i++) {
|
||||
t1[32 + i] = 'a';
|
||||
t1[32 + i - 1] = 'a';
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1));
|
||||
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1));
|
||||
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
|
||||
|
||||
ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv);
|
||||
}
|
||||
@ -291,13 +291,13 @@ TEST(RDoubleVermicelli, Exec5) {
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
for (size_t j = 1; j <= 16; j++) {
|
||||
t1[strlen(t1) - i - j] = 'a';
|
||||
const u8 *rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) - i);
|
||||
const u8 *rv = rvermicelliDoubleExec('b', 'a', 0, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
|
||||
|
||||
ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv);
|
||||
|
||||
rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1,
|
||||
(u8 *)t1 + strlen(t1) -i );
|
||||
rv = rvermicelliDoubleExec('B', 'A', 1, reinterpret_cast<const u8 *>(t1),
|
||||
reinterpret_cast<const u8 *>(t1) + strlen(t1) -i );
|
||||
|
||||
ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user