ValidateBitVec

Documentation

API Reference

ValidateBitVec

Description

Validate whether a given BitVec object is valid. Not foolproof but will work most of the time. Aborts if provided BitVec is not valid.

Parameters

Name	Direction	Description
`bv`	in	Pointer to `BitVec` object to validate.

Success

Continue execution, meaning given BitVec object is most probably valid.

Failure

abort

Usage example (Cross-references)

Usage examples (Cross-references)

In Foreach.h:30:

    #define BitVecForeachIdx(bv, var, idx)                                                                                 \
        for (TYPE_OF(bv) UNPL(pbv) = (bv); UNPL(pbv); UNPL(pbv) = NULL)                                                    \
            if ((ValidateBitVec(UNPL(pbv)), 1) && UNPL(pbv)->length > 0)                                                   \
                for (u64 idx = 0, UNPL(d) = 1; UNPL(d); UNPL(d)--)                                                         \
                    for (bool var = 0; idx < UNPL(pbv)->length && (var = BitVecGet(UNPL(pbv), idx), 1); idx++)

In Foreach.h:51:

    #define BitVecForeachReverseIdx(bv, var, idx)                                                                          \
        for (TYPE_OF(bv) UNPL(pbv) = (bv); UNPL(pbv); UNPL(pbv) = NULL)                                                    \
            if ((ValidateBitVec(UNPL(pbv)), 1) && UNPL(pbv)->length > 0)                                                   \
                for (u64 idx = UNPL(pbv)->length; idx-- > 0 && idx < UNPL(pbv)->length;)                                   \
                    for (u8 UNPL(run_once) = 1; UNPL(run_once); UNPL(run_once) = 0)                                        \

In Foreach.h:108:

    #define BitVecForeachInRangeIdx(bv, var, idx, start, end)                                                              \
        for (TYPE_OF(bv) UNPL(pbv) = (bv); UNPL(pbv); UNPL(pbv) = NULL)                                                    \
            if ((ValidateBitVec(UNPL(pbv)), 1) && UNPL(pbv)->length > 0)                                                   \
                for (u64 UNPL(s) = (start), UNPL(e) = (end), idx = UNPL(s), UNPL(d) = 1;                                   \
                     UNPL(s) <= idx && idx < UNPL(e) && idx < UNPL(pbv)->length && UNPL(s) <= UNPL(e);                     \

In Type.h:40:

    ///
    static inline void ValidateInt(const Int *value) {
        ValidateBitVec(value ? &value->bits : NULL);
    }

In Io.c:3045:

    
        ValidateStr(o);
        ValidateBitVec(bv);
    
        // Snapshot the pre-render length so post-render padding sees the

In Io.c:3183:

        }
    
        ValidateBitVec(bv);
    
        StrIter si = StrIterFromZstr(i);

In BitVec.c:112:

    
    void BitVecDeinit(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (bitvec->data) {
            AllocatorFree(bitvec->allocator, bitvec->data);

In BitVec.c:120:

    
    void BitVecClear(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        bitvec->length = 0;
        if (bitvec->data && bitvec->byte_size > 0) {

In BitVec.c:128:

    
    bool BitVecResize(BitVec *bitvec, u64 new_size) {
        ValidateBitVec(bitvec);
        if (new_size > bitvec->capacity) {
            if (!BitVecReserve(bitvec, new_size)) {

In BitVec.c:160:

    
    bool BitVecReserve(BitVec *bitvec, u64 n) {
        ValidateBitVec(bitvec);
        if (n <= bitvec->capacity)
            return true;

In BitVec.c:183:

    
    void BitVecShrinkToFit(BitVec *bv) {
        ValidateBitVec(bv);
        if (bv->length == 0) {
            AllocatorFree(bv->allocator, bv->data);

In BitVec.c:221:

    
    void BitVecSwap(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:222:

    void BitVecSwap(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u8 *temp_data = bv1->data;

In BitVec.c:244:

    
    bool BitVecTryClone(BitVec *out, BitVec *bv) {
        ValidateBitVec(bv);
        if (!out) {
            LOG_FATAL("Invalid arguments");

In BitVec.c:278:

        BitVec clone;
    
        ValidateBitVec(bv);
        clone = BitVecInit(bv->allocator);
        (void)BitVecTryClone(&clone, bv);

In BitVec.c:285:

    
    bool BitVecGet(const BitVec *bitvec, u64 idx) {
        ValidateBitVec(bitvec);
        if (idx >= bitvec->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length);

In BitVec.c:296:

    
    void BitVecSet(BitVec *bitvec, u64 idx, bool value) {
        ValidateBitVec(bitvec);
        if (idx >= bitvec->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length);

In BitVec.c:311:

    
    void BitVecFlip(BitVec *bitvec, u64 idx) {
        ValidateBitVec(bitvec);
        if (idx >= bitvec->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length);

In BitVec.c:322:

    
    bool BitVecPush(BitVec *bitvec, bool value) {
        ValidateBitVec(bitvec);
        if (bitvec->length >= bitvec->capacity) {
            u64 new_capacity = bitvec->capacity == 0 ? 8 : bitvec->capacity * 2;

In BitVec.c:338:

    
    bool BitVecPop(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (bitvec->length == 0) {
            LOG_FATAL("Cannot pop from empty bitvector");

In BitVec.c:348:

    
    bool BitVecInsert(BitVec *bitvec, u64 idx, bool value) {
        ValidateBitVec(bitvec);
        if (idx > bitvec->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length);

In BitVec.c:366:

    
    bool BitVecInsertRange(BitVec *bv, u64 idx, u64 count, bool value) {
        ValidateBitVec(bv);
        if (idx > bv->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length);

In BitVec.c:393:

    
    bool BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other) {
        ValidateBitVec(bv);
        ValidateBitVec(other);
        if (idx > bv->length) {

In BitVec.c:394:

    bool BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other) {
        ValidateBitVec(bv);
        ValidateBitVec(other);
        if (idx > bv->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length);

In BitVec.c:422:

    
    bool BitVecInsertPattern(BitVec *bv, u64 idx, u8 pattern, u64 pattern_bits) {
        ValidateBitVec(bv);
        if (idx > bv->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length);

In BitVec.c:452:

    
    bool BitVecRemove(BitVec *bv, u64 idx) {
        ValidateBitVec(bv);
        if (idx >= bv->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length);

In BitVec.c:469:

    
    void BitVecRemoveRange(BitVec *bv, u64 idx, u64 count) {
        ValidateBitVec(bv);
        if (idx >= bv->length) {
            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length);

In BitVec.c:493:

    
    bool BitVecRemoveFirst(BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        u64 pos = BitVecFind(bv, value);

In BitVec.c:505:

    
    bool BitVecRemoveLast(BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        u64 pos = BitVecFindLast(bv, value);

In BitVec.c:517:

    
    u64 BitVecRemoveAll(BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        u64 removed_count = 0;

In BitVec.c:542:

    
    u64 BitVecCountOnes(const BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (!bitvec->data)
            return 0;

In BitVec.c:567:

    
    u64 BitVecCountZeros(const BitVec *bitvec) {
        ValidateBitVec(bitvec);
        return bitvec->length - BitVecCountOnes(bitvec);
    }

In BitVec.c:572:

    
    void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:573:

    void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:574:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 a_len   = a->length;

In BitVec.c:593:

    
    void BitVecOr(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:594:

    void BitVecOr(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:595:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 a_len   = a->length;

In BitVec.c:614:

    
    void BitVecXor(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:615:

    void BitVecXor(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);

In BitVec.c:616:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 a_len   = a->length;

In BitVec.c:635:

    
    void BitVecNot(BitVec *result, BitVec *bitvec) {
        ValidateBitVec(result);
        ValidateBitVec(bitvec);

In BitVec.c:636:

    void BitVecNot(BitVec *result, BitVec *bitvec) {
        ValidateBitVec(result);
        ValidateBitVec(bitvec);
    
        u64 len   = bitvec->length;

In BitVec.c:652:

    
    bool BitVecEquals(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:653:

    bool BitVecEquals(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (bv1->length != bv2->length) {

In BitVec.c:663:

    
    bool BitVecEqualsRange(const BitVec *bv1, u64 start1, const BitVec *bv2, u64 start2, u64 len) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:664:

    bool BitVecEqualsRange(const BitVec *bv1, u64 start1, const BitVec *bv2, u64 start2, u64 len) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (start1 + len > bv1->length) {

In BitVec.c:690:

    
        (void)size;
        ValidateBitVec(bv);
    
        u64       bit_count  = bv->length;

In BitVec.c:711:

    
    int BitVecCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:712:

    int BitVecCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 min_len = MIN2(bv1->length, bv2->length);

In BitVec.c:733:

    
    int BitVecCompareRange(const BitVec *bv1, u64 start1, const BitVec *bv2, u64 start2, u64 len) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:734:

    int BitVecCompareRange(const BitVec *bv1, u64 start1, const BitVec *bv2, u64 start2, u64 len) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (start1 + len > bv1->length) {

In BitVec.c:758:

    
    int BitVecNumericalCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:759:

    int BitVecNumericalCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        // LSB-first storage means the most significant magnitude bit lives

In BitVec.c:781:

    
    int BitVecWeightCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:782:

    int BitVecWeightCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 weight1 = BitVecCountOnes(bv1);

In BitVec.c:797:

    
    int BitVecSignedCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:798:

    int BitVecSignedCompare(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (bv1->length == 0 && bv2->length == 0) {

In BitVec.c:826:

    
    bool BitVecIsSubset(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:827:

    bool BitVecIsSubset(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        // Subset = every 1-bit position in bv1 also has a 1 in bv2. Out-of-

In BitVec.c:851:

    
    bool BitVecDisjoint(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:852:

    bool BitVecDisjoint(const BitVec *bv1, const BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 min_len = MIN2(bv1->length, bv2->length);

In BitVec.c:870:

    
    bool BitVecIsSorted(const BitVec *bv) {
        ValidateBitVec(bv);
    
        bool found_one = false;

In BitVec.c:888:

    
    bool bitvec_try_to_str(Str *out, BitVec *bv, Allocator *alloc) {
        ValidateBitVec(bv);
        if (!out) {
            LOG_FATAL("out is NULL");

In BitVec.c:995:

    
    u64 BitVecToBytes(BitVec *bv, u8 *bytes, u64 max_len) {
        ValidateBitVec(bv);
        if (!bytes) {
            LOG_FATAL("bytes is NULL");

In BitVec.c:1064:

    
    u64 BitVecToInteger(const BitVec *bv) {
        ValidateBitVec(bv);
        if (bv->length == 0) {
            return 0;

In BitVec.c:1120:

    
    void BitVecShiftLeft(BitVec *bv, u64 positions) {
        ValidateBitVec(bv);
        if (positions == 0 || bv->length == 0) {
            return;

In BitVec.c:1143:

    
    void BitVecShiftRight(BitVec *bv, u64 positions) {
        ValidateBitVec(bv);
        if (positions == 0 || bv->length == 0) {
            return;

In BitVec.c:1164:

    
    void BitVecRotateLeft(BitVec *bv, u64 positions) {
        ValidateBitVec(bv);
        if (positions == 0 || bv->length == 0) {
            return;

In BitVec.c:1190:

    
    void BitVecRotateRight(BitVec *bv, u64 positions) {
        ValidateBitVec(bv);
        if (positions == 0 || bv->length == 0) {
            return;

In BitVec.c:1216:

    
    void BitVecReverse(BitVec *bv) {
        ValidateBitVec(bv);
        if (bv->length <= 1) {
            return;

In BitVec.c:1231:

    
    u64 BitVecFind(const BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        for (u64 i = 0; i < bv->length; i++) {

In BitVec.c:1242:

    
    u64 BitVecFindLast(const BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        if (bv->length == 0) {

In BitVec.c:1261:

    
    bool BitVecAll(const BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        for (u64 i = 0; i < bv->length; i++) {

In BitVec.c:1272:

    
    bool BitVecAny(const BitVec *bv, bool value) {
        ValidateBitVec(bv);
        return BitVecFind(bv, value) != SIZE_MAX;
    }

In BitVec.c:1281:

    
    u64 BitVecLongestRun(const BitVec *bv, bool value) {
        ValidateBitVec(bv);
    
        if (bv->length == 0) {

In BitVec.c:1305:

    
    u64 BitVecFindPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1306:

    u64 BitVecFindPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (pattern->length == 0 || pattern->length > bv->length) {

In BitVec.c:1321:

    
    u64 BitVecFindLastPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1322:

    u64 BitVecFindLastPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (pattern->length == 0 || pattern->length > bv->length) {

In BitVec.c:1340:

    
    u64 bitvec_find_all_pattern_raw(BitVec *bv, BitVec *pattern, size *results, u64 max_results) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1341:

    u64 bitvec_find_all_pattern_raw(BitVec *bv, BitVec *pattern, size *results, u64 max_results) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (!results || max_results == 0) {

In BitVec.c:1364:

    
    bool bitvec_find_all_pattern_vec(BitVec *bv, BitVec *pattern, BitVecMatchIndices *out) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1365:

    bool bitvec_find_all_pattern_vec(BitVec *bv, BitVec *pattern, BitVecMatchIndices *out) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (!out || !out->allocator) {

In BitVec.c:1385:

    
    u64 bitvec_run_lengths_raw(BitVec *bv, u64 *runs, bool *values, u64 max_runs) {
        ValidateBitVec(bv);
        if (!runs || !values || max_runs == 0) {
            LOG_FATAL("invalid arguments");

In BitVec.c:1428:

    
    bool bitvec_run_lengths_vec(BitVec *bv, BitVecRuns *out) {
        ValidateBitVec(bv);
        if (!out || !out->allocator) {
            LOG_FATAL("output BitVecRuns is NULL or uninitialized");

In BitVec.c:1458:

    
    u64 BitVecHammingDistance(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1459:

    u64 BitVecHammingDistance(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 min_length = MIN2(bv1->length, bv2->length);

In BitVec.c:1479:

    
    double BitVecJaccardSimilarity(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1480:

    double BitVecJaccardSimilarity(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (bv1->length == 0 && bv2->length == 0) {

In BitVec.c:1506:

    
    double BitVecCosineSimilarity(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1507:

    double BitVecCosineSimilarity(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 dot_product = BitVecDotProduct(bv1, bv2);

In BitVec.c:1524:

    
    u64 BitVecDotProduct(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1525:

    u64 BitVecDotProduct(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 min_length = MIN2(bv1->length, bv2->length);

In BitVec.c:1540:

    
    bool BitVecTryEditDistance(BitVec *bv1, BitVec *bv2, u64 *out) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
        if (!out) {

In BitVec.c:1541:

    bool BitVecTryEditDistance(BitVec *bv1, BitVec *bv2, u64 *out) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
        if (!out) {
            LOG_FATAL("out is NULL");

In BitVec.c:1619:

    
    double BitVecCorrelation(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1620:

    double BitVecCorrelation(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 max_length = MAX2(bv1->length, bv2->length);

In BitVec.c:1647:

    
    double BitVecEntropy(BitVec *bv) {
        ValidateBitVec(bv);
    
        if (bv->length == 0)

In BitVec.c:1665:

    
    int BitVecAlignmentScore(BitVec *bv1, BitVec *bv2, int match, int mismatch) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1666:

    int BitVecAlignmentScore(BitVec *bv1, BitVec *bv2, int match, int mismatch) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        u64 min_length = MIN2(bv1->length, bv2->length);

In BitVec.c:1683:

    
    u64 BitVecBestAlignment(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);

In BitVec.c:1684:

    u64 BitVecBestAlignment(BitVec *bv1, BitVec *bv2) {
        ValidateBitVec(bv1);
        ValidateBitVec(bv2);
    
        if (bv1->length == 0 || bv2->length == 0) {

In BitVec.c:1716:

    
    bool BitVecStartsWith(BitVec *bv, BitVec *prefix) {
        ValidateBitVec(bv);
        ValidateBitVec(prefix);

In BitVec.c:1717:

    bool BitVecStartsWith(BitVec *bv, BitVec *prefix) {
        ValidateBitVec(bv);
        ValidateBitVec(prefix);
    
        if (prefix->length > bv->length) {

In BitVec.c:1727:

    
    bool BitVecEndsWith(BitVec *bv, BitVec *suffix) {
        ValidateBitVec(bv);
        ValidateBitVec(suffix);

In BitVec.c:1728:

    bool BitVecEndsWith(BitVec *bv, BitVec *suffix) {
        ValidateBitVec(bv);
        ValidateBitVec(suffix);
    
        if (suffix->length > bv->length) {

In BitVec.c:1739:

    
    bool BitVecContainsAt(BitVec *bv, BitVec *pattern, u64 idx) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1740:

    bool BitVecContainsAt(BitVec *bv, BitVec *pattern, u64 idx) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        // Subtractive form so `idx + pattern->length` wrapping near UINT64_MAX

In BitVec.c:1759:

    
    u64 BitVecCountPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1760:

    u64 BitVecCountPattern(BitVec *bv, BitVec *pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (pattern->length == 0 || pattern->length > bv->length) {

In BitVec.c:1777:

    
    u64 BitVecRFindPattern(BitVec *bv, BitVec *pattern, u64 start) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1778:

    u64 BitVecRFindPattern(BitVec *bv, BitVec *pattern, u64 start) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (pattern->length == 0 || pattern->length > bv->length || start >= bv->length) {

In BitVec.c:1797:

    
    bool BitVecReplace(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);

In BitVec.c:1798:

    bool BitVecReplace(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);

In BitVec.c:1799:

        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);
    
        u64 pos = BitVecFindPattern(bv, old_pattern);

In BitVec.c:1818:

    
    u64 BitVecReplaceAll(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);

In BitVec.c:1819:

    u64 BitVecReplaceAll(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) {
        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);

In BitVec.c:1820:

        ValidateBitVec(bv);
        ValidateBitVec(old_pattern);
        ValidateBitVec(new_pattern);
    
        u64 replacements = 0;

In BitVec.c:1858:

    
    bool BitVecMatches(BitVec *bv, BitVec *pattern, BitVec *wildcard) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
        ValidateBitVec(wildcard);

In BitVec.c:1859:

    bool BitVecMatches(BitVec *bv, BitVec *pattern, BitVec *wildcard) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
        ValidateBitVec(wildcard);

In BitVec.c:1860:

        ValidateBitVec(bv);
        ValidateBitVec(pattern);
        ValidateBitVec(wildcard);
    
        if (bv->length != pattern->length || pattern->length != wildcard->length) {

In BitVec.c:1879:

    
    u64 BitVecFuzzyMatch(BitVec *bv, BitVec *pattern, u64 max_errors) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);

In BitVec.c:1880:

    u64 BitVecFuzzyMatch(BitVec *bv, BitVec *pattern, u64 max_errors) {
        ValidateBitVec(bv);
        ValidateBitVec(pattern);
    
        if (pattern->length > bv->length) {

In BitVec.c:1905:

    
    bool bitvec_regex_match_zstr(BitVec *bv, Zstr pattern) {
        ValidateBitVec(bv);
        if (!pattern) {
            LOG_FATAL("pattern is NULL");

In BitVec.c:1926:

    
    bool bitvec_regex_match_str(BitVec *bv, const Str *pattern) {
        ValidateBitVec(bv);
        if (!pattern) {
            LOG_FATAL("pattern is NULL");

In BitVec.c:1943:

    
    u64 BitVecPrefixMatch(BitVec *bv, BitVecs *patterns) {
        ValidateBitVec(bv);
        if (!patterns) {
            LOG_FATAL("invalid BitVecs object provided");

In BitVec.c:1958:

    
    u64 BitVecSuffixMatch(BitVec *bv, BitVecs *patterns) {
        ValidateBitVec(bv);
        if (!patterns) {
            LOG_FATAL("invalid arguments");

In BitVec.c:1991:

    }
    
    void ValidateBitVec(const BitVec *bv) {
        if (!bv) {
            LOG_FATAL("Invalid bitvec object: NULL.");

In Pattern.Deadend.c:480:

        WriteFmt("Testing BitVecReplaceAll(uninitialized, old, new) - should fatal\n");
    
        BitVec bad         = {0}; // magic mismatch -> ValidateBitVec aborts
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In Type.c:39:

    // Test ValidateBitVec macro
    bool test_bitvec_validate(void) {
        WriteFmt("Testing ValidateBitVec macro\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Type.c:47:

    
        // This should not abort
        ValidateBitVec(&bitvec);
    
        // Clean up

In Type.c:69:

    // real code and dies (longjmp) under the mutant.
    bool test_validate_memoization_skips_structural(void) {
        WriteFmt("Testing ValidateBitVec honours the validated-bit memoization (1943:23)\n");
    
        BitVec bv = {0};

In Type.c:86:

        // Real: validated bit clear -> early return, no structural check, no abort.
        // Mutant: always runs structural -> 1*8 < 400 -> LOG_FATAL.
        ValidateBitVec(&bv);
    
        return true; // reached only when no abort occurred (real code)

In Type.c:111:

    
        // Real code aborts here; the mutant returns normally.
        ValidateBitVec(&bv);
    
        return false; // should never reach here on real code

In Convert.c:885:

        WriteFmt("Testing BitVecToBytes aborts on an invalid (zeroed) bitvec\n");
    
        BitVec bv = {0}; // bad magic -> ValidateBitVec must abort
        u8     bytes[4];

Last updated on July 1, 2026

IntTryClone VecAllocator