BITSTRING(3)

okay bestie, welcome to bitstring(3) from the Library Functions Manual — the bit-string manipulation functions and macros page, and yes it's giving useful 💖

🎀 NAME 🎀

bit_alloc, bit_clear, bit_count, bit_decl, bit_ffc, bit_ffs, bit_ff_at, bit_ffc_at, bit_ffs_at, bit_ffc_area, bit_ffs_area, bit_ff_area_at, bit_ffc_area_at, bit_ffs_area_at, bit_nclear, bit_nset, bit_ntest, bit_set, bit_test, bitstr_size — bit-string manipulation functions and macros 🌸

✨ SYNOPSIS ✨

       #include <bitstring.h>

       bitstr_t *
       bit_alloc(size_t nbits);

       void
       bit_decl(bitstr_t *name, size_t nbits);

       void
       bit_clear(bitstr_t *name, size_t bit);

       void
       bit_count(bitstr_t *name, size_t count, size_t nbits, ssize_t *value);

       void
       bit_ffc(bitstr_t *name, size_t nbits, ssize_t *value);

       void
       bit_ffs(bitstr_t *name, size_t nbits, ssize_t *value);

       void
       bit_ffc_at(bitstr_t *name, size_t start, size_t nbits, ssize_t *value);

       void
       bit_ffs_at(bitstr_t *name, size_t start, size_t nbits, ssize_t *value);

       void
       bit_ff_at(bitstr_t *name, size_t start, size_t nbits, int match,
           ssize_t *value);

       void
       bit_ffc_area(bitstr_t *name, size_t nbits, size_t size, ssize_t *value);

       void
       bit_ffs_area(bitstr_t *name, size_t nbits, size_t size, ssize_t *value);

       void
       bit_ffc_area_at(bitstr_t *name, size_t start, size_t nbits, size_t size,
           ssize_t *value);

       void
       bit_ffs_area_at(bitstr_t *name, size_t start, size_t nbits, size_t size,
           ssize_t *value);

       void
       bit_ff_area_at(bitstr_t *name, size_t start, size_t nbits, size_t size,
           int match, ssize_t *value);

       bit_foreach(bitstr_t *name, size_t nbits, size_t var);

       bit_foreach_at(bitstr_t *name, size_t start, size_t nbits, size_t var);

       bit_foreach_unset(bitstr_t *name, size_t nbits, size_t var);

       bit_foreach_unset_at(bitstr_t *name, size_t start, size_t nbits,
           size_t var);

       void
       bit_nclear(bitstr_t *name, size_t start, size_t stop);

       void
       bit_nset(bitstr_t *name, size_t start, size_t stop);

       int
       bit_ntest(bitstr_t *name, size_t start, size_t stop, int match);

       void
       bit_set(bitstr_t *name, size_t bit);

       int
       bitstr_size(size_t nbits);

       int
       bit_test(bitstr_t *name, size_t bit);

🦋 DESCRIPTION 🦋

These macros operate on strings of bits. That's the whole vibe: little bits, all lined up, getting set, cleared, tested, and counted 💅

• bit_alloc() — returns a pointer of type bitstr_t * to enough space to store nbits bits, or NULL if no space is available. If it succeeds, the returned bit string is initialized with all bits cleared ✨
• bit_decl() — this macro declares a bit string with enough space to store nbits bits. You can use bit_decl() to include statically sized bit strings in structure definitions or to create bit strings on the stack. You are responsible for initializing the bit string, typically via a global initialization of the containing struct or by using the bit_nset() or bin_nclear() functions 🫶
• bitstr_size() — this macro returns the number of bytes necessary to store nbits bits. It's useful for copying bit strings 🎀
• bit_clear() and bit_set() — these functions clear or set the zero-based numbered bit bit, in the bit string name 🧚
• bit_nset() and bit_nclear() — these functions set or clear the zero-based numbered bits from start through stop in the bit string name 🌈
• bit_test() — this function evaluates to non-zero if the zero-based numbered bit bit of bit string name is set, and zero otherwise 💖
• bit_ntest() — this function evaluates to non-zero if the zero-based numbered bits from start through stop in the bit string name all have the value match 👑
• bit_ffc() — stores in the location referenced by value the zero-based number of the first bit not set in the array of nbits bits referenced by name. If all bits are set, the location referenced by value is set to -1 😭
• bit_ffs() — stores in the location referenced by value the zero-based number of the first bit set in the array of nbits bits referenced by name. If no bits are set, the location referenced by value is set to -1 🔥
• bit_ffc_at() — stores in the location referenced by value the zero-based number of the first bit not set in the array of nbits bits referenced by name, at or after the zero-based bit index start. If all bits at or after start are set, the location referenced by value is set to -1 💀
• bit_ffs_at() — stores in the location referenced by value the zero-based number of the first bit set in the array of nbits bits referenced by name, at or after the zero-based bit index start. If no bits are set after start, the location referenced by value is set to -1 ⭐
• bit_ff_at() — stores in the location referenced by value the zero-based number of the first bit in the array of nbits bits referenced by name, at or after the zero-based bit index start, that has value match. If no bits after start match that value, the location referenced by value is set to -1 🌸
• bit_ffc_area() — stores in the location referenced by value the zero-based number of the first bit beginning a sequence of unset bits of at least size unset bits in the array of nbits bits referenced by name. If no sequence of contiguous unset bits of the specified size can be found, the location referenced by value is set to -1 🙈
• bit_ffs_area() — stores in the location referenced by value the zero-based number of the first bit beginning a sequence of set bits of at least size set bits in the array of nbits bits referenced by name. If no sequence of contiguous set bits of the specified size can be found, the location referenced by value is set to -1 🍓
• bit_ffc_area_at() — stores in the location referenced by value the zero-based number of the first bit beginning a sequence of unset bits of at least size unset bits in the array of nbits bits referenced by name, at or after the zero-based bit index start. If no sequence of contiguous unset bits of the specified size can be found at or after start, the location referenced by value is set to -1 💜
• bit_ffs_area_at() — stores in the location referenced by value the zero-based number of the first bit beginning a sequence of set bits of at least size set bits in the array of nbits bits referenced by name, at or after the zero-based bit index start. If no sequence of contiguous set bits of the specified size can be found at or after start, the location referenced by value is set to -1 🌟
• bit_ff_area_at() — stores in the location referenced by value the zero-based number of the first bit beginning a sequence of bits of at least size bits in the array of nbits bits referenced by name, at or after the zero-based bit index start, in which all bits have the value match. If no sequence of contiguous such bits of the specified size can be found at or after start, the location referenced by value is set to -1 🦋
• bit_count() — stores in the location referenced by value the number of bits set in the array of nbits bits referenced by name, at or after the zero-based bit index start. tiny note: the synopsis names that arg count while the prose says start — I'm just reporting the vibes, bestie 💅
• bit_foreach() — this macro traverses all set bits in the array of nbits referenced by name in the forward direction, assigning each location in turn to var ✨
• bit_foreach_at() — this macro traverses all set bits in the array of nbits referenced by name in the forward direction at or after the zero-based bit index start, assigning each location in turn to var 🎀
• bit_foreach_unset() — this macro traverses all unset bits in the array of nbits referenced by name in the forward direction, assigning each location in turn to var 🌈
• bit_foreach_unset_at() — this macro traverses all unset bits in the array of nbits referenced by name in the forward direction at or after the zero-based bit index start, assigning each location in turn to var 🫶

The arguments in bit string macros are evaluated only once and may safely have side effects. so yes, you can be a little chaotic with them, periodt 💖

🧚 EXAMPLES 🧚

             #include <limits.h>
             #include <bitstring.h>

             ...
             #define LPR_BUSY_BIT            0
             #define LPR_FORMAT_BIT          1
             #define LPR_DOWNLOAD_BIT        2
             ...
             #define LPR_AVAILABLE_BIT       9
             #define LPR_MAX_BITS            10

             make_lpr_available()
             {
                     bitstr_t bit_decl(bitlist, LPR_MAX_BITS);
                     ...
                     bit_nclear(bitlist, 0, LPR_MAX_BITS - 1);
                     ...
                     if (!bit_test(bitlist, LPR_BUSY_BIT)) {
                             bit_clear(bitlist, LPR_FORMAT_BIT);
                             bit_clear(bitlist, LPR_DOWNLOAD_BIT);
                             bit_set(bitlist, LPR_AVAILABLE_BIT);
                     }
             }

🌈 SEE ALSO 🌈

malloc(3), stdbit(3), bitset(9) 👑

⭐ HISTORY ⭐

The bitstring functions first appeared in 4.4BSD. iconic behavior, honestly 🎀

---

this page is from Debian, dated November 21, 2023, and the manual is BITSTRING(3) — bye bestie, go set some bits 💖✨