BitVecToInteger
- Function
- April 17, 2026
Table of Contents
BitVecToInteger
BitVecToIntegerDescription
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);
Usage example (Cross-references)
- In
Io.c:2575:
} else {
// Convert to integer (up to 64 bits) and format as hex
u64 value = BitVecToInteger(bv);
StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = true};
StrFromU64(o, value, &config);
- In
Io.c:2584:
StrPushBackZstr(o, "0o0");
} else {
u64 value = BitVecToInteger(bv);
StrIntFormat config = {.base = 8, .uppercase = false, .use_prefix = true};
StrFromU64(o, value, &config);
- In
Int.c:368:
}
return BitVecToInteger(INT_BITS(value));
}
- In
BitVec.c:822:
}
u64 BitVecToInteger(BitVec *bv) {
ValidateBitVec(bv);
if (bv->length == 0) {
- In
Io.Read.c:844:
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
Io.Read.c:853:
z = "0o755";
StrReadFmt(z, "{}", bv3);
u64 value3 = BitVecToInteger(&bv3);
success = success && (value3 == 0755);
WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
// Test BitVecToInteger function
bool test_bitvec_to_integer(void) {
WriteFmt("Testing BitVecToInteger\n");
BitVec bv = BitVecInit();
// 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);
u64 recovered = BitVecToInteger(&bv);
result = result && (recovered == value);
result = result && (large_bv.length == 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