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 Io.c:2911:

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

In Io.c:3049:

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

In BitVec.c:91:

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

In BitVec.c:99:

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

In BitVec.c:107:

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

In BitVec.c:139:

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

In BitVec.c:162:

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

In BitVec.c:200:

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

In BitVec.c:201:

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

In BitVec.c:223:

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

In BitVec.c:250:

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

In BitVec.c:257:

    
    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:268:

    
    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:283:

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

In BitVec.c:294:

    
    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:310:

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

In BitVec.c:320:

    
    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:338:

    
    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:365:

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

In BitVec.c:366:

    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:394:

    
    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:424:

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

In BitVec.c:441:

    
    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:465:

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

In BitVec.c:477:

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

In BitVec.c:489:

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

In BitVec.c:514:

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

In BitVec.c:527:

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

In BitVec.c:532:

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

In BitVec.c:533:

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

In BitVec.c:534:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 min_len = MIN2(a->length, b->length);

In BitVec.c:549:

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

In BitVec.c:550:

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

In BitVec.c:551:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 max_len = MAX2(a->length, b->length);

In BitVec.c:566:

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

In BitVec.c:567:

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

In BitVec.c:568:

        ValidateBitVec(result);
        ValidateBitVec(a);
        ValidateBitVec(b);
    
        u64 max_len = MAX2(a->length, b->length);

In BitVec.c:583:

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

In BitVec.c:584:

    void BitVecNot(BitVec *result, BitVec *bitvec) {
        ValidateBitVec(result);
        ValidateBitVec(bitvec);
    
        if (!BitVecResize(result, bitvec->length)) {

In BitVec.c:597:

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

In BitVec.c:598:

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

In BitVec.c:608:

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

In BitVec.c:609:

    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:635:

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

In BitVec.c:656:

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

In BitVec.c:657:

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

In BitVec.c:678:

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

In BitVec.c:679:

    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:703:

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

In BitVec.c:704:

    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:726:

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

In BitVec.c:727:

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

In BitVec.c:742:

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

In BitVec.c:743:

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

In BitVec.c:771:

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

In BitVec.c:772:

    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:796:

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

In BitVec.c:797:

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

In BitVec.c:815:

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

In BitVec.c:833:

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

In BitVec.c:940:

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

In BitVec.c:1009:

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

In BitVec.c:1065:

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

In BitVec.c:1088:

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

In BitVec.c:1109:

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

In BitVec.c:1135:

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

In BitVec.c:1161:

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

In BitVec.c:1176:

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

In BitVec.c:1187:

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

In BitVec.c:1206:

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

In BitVec.c:1217:

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

In BitVec.c:1226:

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

In BitVec.c:1250:

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

In BitVec.c:1251:

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

In BitVec.c:1266:

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

In BitVec.c:1267:

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

In BitVec.c:1285:

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

In BitVec.c:1286:

    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:1309:

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

In BitVec.c:1310:

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

In BitVec.c:1330:

    
    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:1373:

    
    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:1403:

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

In BitVec.c:1404:

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

In BitVec.c:1424:

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

In BitVec.c:1425:

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

In BitVec.c:1451:

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

In BitVec.c:1452:

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

In BitVec.c:1469:

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

In BitVec.c:1470:

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

In BitVec.c:1485:

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

In BitVec.c:1486:

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

In BitVec.c:1564:

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

In BitVec.c:1565:

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

In BitVec.c:1592:

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

In BitVec.c:1610:

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

In BitVec.c:1611:

    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:1628:

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

In BitVec.c:1629:

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

In BitVec.c:1661:

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

In BitVec.c:1662:

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

In BitVec.c:1672:

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

In BitVec.c:1673:

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

In BitVec.c:1684:

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

In BitVec.c:1685:

    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:1704:

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

In BitVec.c:1705:

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

In BitVec.c:1722:

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

In BitVec.c:1723:

    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:1742:

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

In BitVec.c:1743:

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

In BitVec.c:1744:

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

In BitVec.c:1763:

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

In BitVec.c:1764:

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

In BitVec.c:1765:

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

In BitVec.c:1803:

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

In BitVec.c:1804:

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

In BitVec.c:1805:

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

In BitVec.c:1824:

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

In BitVec.c:1825:

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

In BitVec.c:1850:

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

In BitVec.c:1871:

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

In BitVec.c:1888:

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

In BitVec.c:1903:

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

In BitVec.c:1936:

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

In BitVec.Type.c:37:

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

In BitVec.Type.c:45:

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

In Type.h:40:

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

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);                     \

Last updated on June 4, 2026

SymbolResolverResolve ValidateMap