Skip to content
Documentation
API Reference
BitVecToInteger

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) 
                // 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)) {
                }
            } else {
                u64          value  = BitVecToInteger(bv);
                StrIntFormat config = {.base = 8, .uppercase = false, .use_prefix = true};
                if (!StrFromU64(o, value, &config)) {
    }
    
    u64 BitVecToInteger(const BitVec *bv) {
        ValidateBitVec(bv);
        if (bv->length == 0) {
        }
    
        *out = BitVecToInteger(INT_BITS(value));
        return true;
    }
        z          = "0xDEAD";
        StrReadFmt(z, "{}", bv2);
        u64 value2 = BitVecToInteger(&bv2);
        success    = success && (value2 == 0xDEAD);
        WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");
        z          = "0o755";
        StrReadFmt(z, "{}", bv3);
        u64 value3 = BitVecToInteger(&bv3);
        success    = success && (value3 == 0755);
        WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecToInteger\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Convert to integer
        u64 value = BitVecToInteger(&bv);
    
        // Check result - pattern 1011 (bits stored as: index 0=true, 1=false, 2=true, 3=true)

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

    
        // Test empty bitvec to integer
        u64 value = BitVecToInteger(&bv);
        result    = result && (value == 0);
    
                BitVec bv        = BitVecFromInteger(value, bits, ALLOCATOR_OF(&alloc));
                u64    recovered = BitVecToInteger(&bv);
    
                result = result && (recovered == value);
        result          = result && (BitVecLen(&large_bv) == 64);
    
        u64 large_value = BitVecToInteger(&large_bv);
        result          = result && (large_value == 0xFFFFFFFFFFFFFFFF);
        BitVecDeinit(&large_bv);
        }
    
        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

        StrDeinit(&empty_str);
    
        u64 empty_value = BitVecToInteger(&empty);
        result          = result && (empty_value == 0);
    
            // Test integer conversion (may depend on bit order)
            u64 value = BitVecToInteger(&bv);
            // We test that we get a consistent value (not necessarily the exact expected one)
            result = result && (value > 0 || ZstrCompare(test_cases[i].pattern, "00000000") == 0);
    
        // Test BitVecToInteger with NULL pointer - should abort
        u64 value = BitVecToInteger(NULL);
        (void)value; // Suppress unused variable warning
Last updated on
BitVecToBytesBitVecToStr