BitVecContainsAt

Documentation

API Reference

BitVecContainsAt

Description

Check if bitvector contains the given pattern at a specific position.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to check
`pattern`	in	Pattern to match
`idx`	in	Position to check at

Usage example (from documentation)

  bool at_pos = BitVecContainsAt(&flags, &pattern, 5);

Returns

true if pattern matches at the given position

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:1063:

    
        for (u64 i = 0; i <= bv->length - pattern->length; i++) {
            if (BitVecContainsAt(bv, pattern, i)) {
                return i;
            }

In BitVec.c:1079:

    
        for (u64 i = bv->length - pattern->length; i < bv->length; i--) { // i < bv->length handles underflow
            if (BitVecContainsAt(bv, pattern, i)) {
                return i;
            }

In BitVec.c:1103:

    
        for (u64 i = 0; i <= bv->length - pattern->length && found_count < max_results; i++) {
            if (BitVecContainsAt(bv, pattern, i)) {
                results[found_count] = i;
                found_count++;

In BitVec.c:1405:

        }
    
        return BitVecContainsAt(bv, prefix, 0);
    }

In BitVec.c:1417:

    
        u64 start_pos = bv->length - suffix->length;
        return BitVecContainsAt(bv, suffix, start_pos);
    }

In BitVec.c:1422:

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

In BitVec.c:1449:

        u64 count = 0;
        for (u64 i = 0; i <= bv->length - pattern->length; i++) {
            if (BitVecContainsAt(bv, pattern, i)) {
                count++;
            }

In BitVec.c:1469:

        for (u64 i = start + 1; i > search_end; i--) {
            u64 pos = i - 1;
            if (BitVecContainsAt(bv, pattern, pos)) {
                return pos;
            }

In BitVec.c:1513:

            if (search_pos + old_pattern->length <= bv->length) {
                for (u64 i = search_pos; i <= bv->length - old_pattern->length; i++) {
                    if (BitVecContainsAt(bv, old_pattern, i)) {
                        match_pos = i;
                        found     = true;

In BitVec.Pattern.Deadend.c:189:

    
    bool test_bitvec_contains_at_null_source(void) {
        WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:192:

        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);
        BitVecContainsAt(NULL, &pattern, 0);
        BitVecDeinit(&pattern);
        return true;

In BitVec.Pattern.Deadend.c:198:

    
    bool test_bitvec_contains_at_null_pattern(void) {
        WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
        BitVec source = BitVecInit();
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:201:

        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecContainsAt(&source, NULL, 0);
        BitVecDeinit(&source);
        return true;

In BitVec.Pattern.c:633:

    // BitVecContainsAt tests
    bool test_bitvec_contains_at_basic(void) {
        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit();

In BitVec.Pattern.c:653:

        BitVecPush(&pattern, true);
    
        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match

In BitVec.Pattern.c:654:

    
        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match

In BitVec.Pattern.c:655:

        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match
    
        BitVecDeinit(&source);

In BitVec.Pattern.c:663:

    
    bool test_bitvec_contains_at_edge_cases(void) {
        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit();

In BitVec.Pattern.c:678:

        BitVecPush(&pattern, true);
    
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
    
        BitVecDeinit(&source);

In BitVec.Pattern.c:1061:

    
    bool test_bitvec_contains_at_null_source(void) {
        WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);

In BitVec.Pattern.c:1064:

        BitVec pattern = BitVecInit();
        BitVecPush(&pattern, true);
        BitVecContainsAt(NULL, &pattern, 0);
        BitVecDeinit(&pattern);
        return true;

In BitVec.Pattern.c:1070:

    
    bool test_bitvec_contains_at_null_pattern(void) {
        WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
        BitVec source = BitVecInit();
        BitVecPush(&source, true);

In BitVec.Pattern.c:1073:

        BitVec source = BitVecInit();
        BitVecPush(&source, true);
        BitVecContainsAt(&source, NULL, 0);
        BitVecDeinit(&source);
        return true;

In BitVec.Pattern.Simple.c:517:

    // BitVecContainsAt tests
    bool test_bitvec_contains_at_basic(void) {
        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit();

In BitVec.Pattern.Simple.c:537:

        BitVecPush(&pattern, true);
    
        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match

In BitVec.Pattern.Simple.c:538:

    
        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match

In BitVec.Pattern.Simple.c:539:

        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Should not match
        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match
    
        BitVecDeinit(&source);

In BitVec.Pattern.Simple.c:547:

    
    bool test_bitvec_contains_at_edge_cases(void) {
        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit();

In BitVec.Pattern.Simple.c:562:

        BitVecPush(&pattern, true);
    
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
    
        BitVecDeinit(&source);

Last updated on April 20, 2026

BitVecClone BitVecCountOnes