BitVecToInteger

Documentation

API Reference

BitVecToInteger

Description

Convert bitvector to integer (up to 64 bits). Treats the bitvector as an unsigned integer with LSB first.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to convert (must be <= 64 bits)

Usage example (from documentation)

  u64 value = BitVecToInteger(&flags);

Success

Returns the LSB-first unsigned integer value packed into the bitvector. Bits beyond position 63 are silently dropped. The bitvector is not modified.

Failure

Returns 0 for an empty bitvector. The caller cannot distinguish that from a true zero result.

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:3062:

                // the bottom 64 bits as a regular integer; longer BitVecs
                // lose their upper bits in hex/octal display modes.
                u64          value  = BitVecToInteger(bv);
                StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = true};
                if (!StrFromU64(o, value, &config)) {

In Io.c:3074:

                }
            } else {
                u64          value  = BitVecToInteger(bv);
                StrIntFormat config = {.base = 8, .uppercase = false, .use_prefix = true};
                if (!StrFromU64(o, value, &config)) {

In Int.c:521:

        }
    
        *out = BitVecToInteger(INT_BITS(value));
        return true;
    }

In BitVec.c:1063:

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

In Convert.c:179:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecToInteger\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In Convert.c:190:

    
        // Convert to integer
        u64 value = BitVecToInteger(&bv);
    
        // Check result - pattern 1011 (bits stored as: index 0=true, 1=false, 2=true, 3=true)

In Convert.c:203:

        }
    
        u64 value2 = BitVecToInteger(&bv2);
        result     = result && (value2 > 0); // Should be some positive value

In Convert.c:422:

    
        // Test empty bitvec to integer
        u64 value = BitVecToInteger(&bv);
        result    = result && (value == 0);

In Convert.c:476:

    
                BitVec bv        = BitVecFromInteger(value, bits, ALLOCATOR_OF(&alloc));
                u64    recovered = BitVecToInteger(&bv);
    
                result = result && (recovered == value);

In Convert.c:515:

        result          = result && (BitVecLen(&large_bv) == 64);
    
        u64 large_value = BitVecToInteger(&large_bv);
        result          = result && (large_value == 0xFFFFFFFFFFFFFFFF);
        BitVecDeinit(&large_bv);

In Convert.c:525:

        }
    
        u64 oversized_value = BitVecToInteger(&oversized);
        // Should return some value or 0, but not crash
        result = result && (oversized_value >= 0); // Always true for u64, but documents intent

In Convert.c:537:

        StrDeinit(&empty_str);
    
        u64 empty_value = BitVecToInteger(&empty);
        result          = result && (empty_value == 0);

In Convert.c:585:

            // Integer conversion is deterministic LSB-first (bit[i] -> 1<<i),
            // so the table's expected_value is exact.
            u64 value = BitVecToInteger(&bv);
            result    = result && (value == test_cases[i].expected_value);

In Convert.c:744:

    
        // Test BitVecToInteger with NULL pointer - should abort
        u64 value = BitVecToInteger(NULL);
        (void)value; // Suppress unused variable warning

In Write.c:1417:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4);
    
        BitVecDeinit(&bv);

In Write.c:1435:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);
    
        BitVecDeinit(&bv);

In Write.c:1451:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (*z == '\0');
    
        BitVecDeinit(&bv);

In Write.c:1470:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
    
        BitVecDeinit(&bv);

In Write.c:1489:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 8) && (*z == '\0');
    
        BitVecDeinit(&bv);

In Write.c:1506:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0755) && (BitVecLen(&bv) == 9);
    
        BitVecDeinit(&bv);

In Write.c:2494:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 10) && (BitVecToInteger(&bv) == 0x3ff);
    
        BitVecDeinit(&bv);

In Write.c:2513:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 8) && (BitVecToInteger(&bv) == 0xff);
    
        BitVecDeinit(&bv);

In Write.c:2532:

        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 17) && (BitVecToInteger(&bv) == 0x10000);
    
        BitVecDeinit(&bv);

In Read.c:862:

        z          = "0xDEAD";
        StrReadFmt(z, "{}", bv2);
        u64 value2 = BitVecToInteger(&bv2);
        success    = success && (value2 == 0xDEAD);
        WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");

In Read.c:870:

        z          = "0o755";
        StrReadFmt(z, "{}", bv3);
        u64 value3 = BitVecToInteger(&bv3);
        success    = success && (value3 == 0755);
        WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");

In Read.c:2516:

        Zstr           z   = "0x1";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4); // min-width clamp
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);

In Read.c:2529:

        Zstr             z     = "0xDEAD";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);

In Read.c:2541:

        Zstr           z   = "0o1";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);

In Read.c:2554:

        Zstr           z   = "10110";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecLen(&bv) == 5) && (BitVecToInteger(&bv) == 13);
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);

Last updated on July 1, 2026

BitVecToBytes BitVecToStr