Class: String

Inherits:

Object

• Object
• String

Defined in:

(unknown)

Instance Method Summary

• #bit_at(*args) ⇒ Object

  Return true/false/nil for the bit at flat position n.

• #bit_clear(*args) ⇒ Object
• #bit_count(*args) ⇒ Object
• #bit_fields(*args) ⇒ Object

  Non-iterator form of each_bit_field; collect bit-field records into an Array.

• #bit_flip(*args) ⇒ Object
• #bit_offsets(*args) ⇒ Object
• #bit_run_count(*args) ⇒ Object

  Return the length of the consecutive run of ‘bit` starting at pos, or nil.

• #bit_runs(*args) ⇒ Object

  Non-iterator form of each_bit_run; collect run triples into an Array.

• #bit_set(*args) ⇒ Object
• #bit_slice(*args) ⇒ Object

  Extract a sub-sequence of bits into a new String.

• #bit_splice(*args) ⇒ Object

  Write bits from str into self at bit-level granularity (inverse of bit_slice).

• #bits(*args) ⇒ Object
• #bitwise_and ⇒ Object
• #bitwise_and! ⇒ Object
• #bitwise_not ⇒ Object
• #bitwise_not! ⇒ Object
• #bitwise_or ⇒ Object
• #bitwise_or! ⇒ Object
• #bitwise_xor ⇒ Object
• #bitwise_xor! ⇒ Object
• #each_bit(*args) ⇒ Object
• #each_bit_field(*args) ⇒ Object

  Yield each packed bit-field record as one Integer per field.

• #each_bit_offset(*args) ⇒ Object
• #each_bit_run(*args) ⇒ Object

Instance Method Details

#bit_at(*args) ⇒ Object

Return true/false/nil for the bit at flat position n.

# File 'ext/string_bits/string_bits.c', line 378

static VALUE
rb_str_bit_at(int argc, VALUE *argv, VALUE self)
{
    VALUE bit_offset_v, opts;
    rb_scan_args(argc, argv, "1:", &bit_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);

    if (!rb_integer_type_p(bit_offset_v)) {
        rb_raise(rb_eTypeError, "bit index must be an integer");
    }
    ssize_t bit_offset = integer_to_bit_idx(bit_offset_v);
    if (bit_offset < 0) {
        rb_raise(rb_eIndexError, "bit index out of range");
    }
    ssize_t size = RSTRING_LEN(self) * 8;
    if (size <= bit_offset) {
        return Qnil;
    }

    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t idx = logical_to_physical(bit_offset, lsb_first);

    if (test_bit(RSTRING_PTR(self), idx)) {
        return Qtrue;
    } else {
        return Qfalse;
    }
}

#bit_clear(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 1090

static VALUE
rb_str_bit_clear(int argc, VALUE *argv, VALUE self)
{
    return rb_str_mutate_bits(argc, argv, self, SB_MUT_CLEAR);
}

#bit_count(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 531

static VALUE
rb_str_bit_count(int argc, VALUE *argv, VALUE self)
{
    const unsigned char *str = (const unsigned char *)RSTRING_PTR(self);
    ssize_t src_len = RSTRING_LEN(self);

    VALUE v0 = Qnil, v1 = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "02:", &v0, &v1, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);

    /* No positional args: count the whole string; lsb_first: is ignored (order-independent) */
    if (NIL_P(v0))
        return SSIZET2NUM(count_set_bits(str, src_len));

    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t total_bits = src_len * 8;
    ssize_t bit_offset, bit_length;

    if (rb_obj_is_kind_of(v0, rb_cRange)) {
        if (!NIL_P(v1))
            rb_raise(rb_eArgError, "wrong number of arguments");
        sb_range_validate_endpoints(v0);
        ssize_t beg, len;
        if (!RTEST(sb_range_beg_len(v0, &beg, &len, total_bits, 0)))
            return INT2FIX(0);
        bit_offset = beg;
        bit_length = len;
    }
    else if (!NIL_P(v1)) {
        if (!rb_integer_type_p(v0))
            rb_raise(rb_eTypeError, "bit_offset must be an integer");
        if (!rb_integer_type_p(v1))
            rb_raise(rb_eTypeError, "bit_length must be an integer");
        bit_offset = integer_to_bit_idx(v0);
        if (bit_offset < 0)
            rb_raise(rb_eIndexError, "bit_offset must be non-negative");
        bit_length = integer_to_bit_idx(v1);
        if (bit_length < 0)
            rb_raise(rb_eArgError, "bit_length must be non-negative");
    }
    else {
        rb_raise(rb_eArgError,
                 "wrong number of arguments (given 1, expected 0, 1 Range, or 2)");
    }

    if (lsb_first)
        return SSIZET2NUM(count_set_bits_range(str, src_len, bit_offset, bit_length));
    else
        return SSIZET2NUM(count_set_bits_range_msb(str, src_len, bit_offset, bit_length));
}

#bit_fields(*args) ⇒ Object

Non-iterator form of each_bit_field; collect bit-field records into an Array.

# File 'ext/string_bits/string_bits.c', line 1369

static VALUE
rb_str_bit_fields(int argc, VALUE *argv, VALUE self)
{
    VALUE rest, opts;
    rb_scan_args(argc, argv, "*:", &rest, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);

    ssize_t num_fields = RARRAY_LEN(rest);
    if (num_fields == 0) {
        rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
    }

    ssize_t *bitlens = ALLOCA_N(ssize_t, num_fields);
    ssize_t step = 0;
    for (ssize_t f = 0; f < num_fields; f++) {
        VALUE v = RARRAY_AREF(rest, f);
        if (!rb_integer_type_p(v)) {
            rb_raise(rb_eTypeError, "bitlen must be an integer");
        }
        ssize_t bl = NUM2SSIZET(v);
        if (bl <= 0) {
            rb_raise(rb_eArgError, "bitlen must be positive");
        }
        if (bl > 64) {
            rb_raise(rb_eArgError, "bitlen must be <= 64 (got %ld)", bl);
        }
        bitlens[f] = bl;
        step += bl;
    }

    int lsb_first = parse_lsb_first_opt(opts);

    ssize_t src_len = RSTRING_LEN(self);
    ssize_t total_bits = src_len * 8;
    ssize_t iterations = total_bits / step;

    int have_block = rb_block_given_p();
    VALUE result = have_block ? Qnil : rb_ary_new_capa(iterations);

    VALUE *field_vals = ALLOCA_N(VALUE, num_fields);

    for (ssize_t iter = 0; iter < iterations; iter++) {
        ssize_t base_bit = iter * step;
        const unsigned char *src = (const unsigned char *)RSTRING_PTR(self);
        ssize_t field_bit = base_bit;
        for (ssize_t f = 0; f < num_fields; f++) {
            uint64_t val = extract_uint64(src, src_len, field_bit, bitlens[f], lsb_first);
            field_vals[f] = ULL2NUM(val);
            field_bit += bitlens[f];
        }
        if (have_block) {
            rb_yield_values2((int)num_fields, field_vals);
        } else if (num_fields == 1) {
            rb_ary_push(result, field_vals[0]);
        } else {
            rb_ary_push(result, rb_ary_new_from_values(num_fields, field_vals));
        }
    }

    return have_block ? self : result;
}

#bit_flip(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 1096

static VALUE
rb_str_bit_flip(int argc, VALUE *argv, VALUE self)
{
    return rb_str_mutate_bits(argc, argv, self, SB_MUT_FLIP);
}

#bit_offsets(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 785

static VALUE
rb_str_bit_offsets(int argc, VALUE *argv, VALUE self)
{
    VALUE bit_val, start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "11:", &bit_val, &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    int target    = parse_bit_target(bit_val);
    ssize_t start_offset = parse_start_offset(start_offset_v);

    ssize_t len = RSTRING_LEN(self);
    const unsigned char *str = (const unsigned char *)RSTRING_PTR(self);

    if (rb_block_given_p()) {
        emit_bit_offsets(str, len, target, lsb_first, start_offset, Qnil);
        return self;
    }

    /* Pre-size the Array using popcount to avoid repeated reallocation.
     * For target=0 the expected count is (len * 8 - popcount). */
    ssize_t set_count = count_set_bits(str, len);
    ssize_t count     = (target == 1) ? set_count : (len * 8 - set_count);
    VALUE ary = rb_ary_new_capa(count);
    emit_bit_offsets(str, len, target, lsb_first, start_offset, ary);
    return ary;
}

#bit_run_count(*args) ⇒ Object

Return the length of the consecutive run of ‘bit` starting at pos, or nil.

# File 'ext/string_bits/string_bits.c', line 1501

static VALUE
rb_str_bit_run_count(int argc, VALUE *argv, VALUE self)
{
    VALUE bit_offset_v, bit_val, opts;
    rb_scan_args(argc, argv, "20:", &bit_val, &bit_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);

    if (!rb_integer_type_p(bit_offset_v)) {
        rb_raise(rb_eTypeError, "position must be an integer");
    }
    int target = parse_bit_target(bit_val);
    ssize_t bit_offset = integer_to_bit_idx(bit_offset_v);
    ssize_t src_len = RSTRING_LEN(self);
    if (bit_offset < 0 || bit_offset >= src_len * 8) return Qnil;

    const unsigned char *src = (const unsigned char *)RSTRING_PTR(self);
    if (lsb_first) {
        if (((src[bit_offset >> 3] >> (bit_offset & 7)) & 1) != target) return Qnil;
        return SSIZET2NUM(count_run_lsb(src, src_len, bit_offset, target));
    }

    if (logical_get_bit(src, bit_offset, 0) != target) return Qnil;

    ssize_t run = 1;
    ssize_t total_bits = src_len * 8;
    while (bit_offset + run < total_bits && logical_get_bit(src, bit_offset + run, 0) == target) {
        run++;
    }
    return SSIZET2NUM(run);
}

#bit_runs(*args) ⇒ Object

Non-iterator form of each_bit_run; collect run triples into an Array.

# File 'ext/string_bits/string_bits.c', line 1597

static VALUE
rb_str_bit_runs(int argc, VALUE *argv, VALUE self)
{
    VALUE start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "01:", &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t start_offset = parse_start_offset(start_offset_v);

    if (rb_block_given_p()) {
        emit_bit_runs(self, lsb_first, start_offset, Qnil);
        return self;
    }

    VALUE ary = rb_ary_new();
    emit_bit_runs(self, lsb_first, start_offset, ary);
    return ary;
}

#bit_set(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 1084

static VALUE
rb_str_bit_set(int argc, VALUE *argv, VALUE self)
{
    return rb_str_mutate_bits(argc, argv, self, SB_MUT_SET);
}

#bit_slice(*args) ⇒ Object

Extract a sub-sequence of bits into a new String.

# File 'ext/string_bits/string_bits.c', line 907

static VALUE
rb_str_bit_slice(int argc, VALUE *argv, VALUE self)
{
    ssize_t src_len = RSTRING_LEN(self);
    ssize_t total_bits = src_len * 8;
    ssize_t bit_offset, bit_length;
    VALUE v0, v1, opts;
    int n_pos = rb_scan_args(argc, argv, "11:", &v0, &v1, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);

    if (n_pos == 1 && rb_obj_is_kind_of(v0, rb_cRange)) {
        sb_range_validate_endpoints(v0);
        ssize_t beg, len;
        if (!RTEST(sb_range_beg_len(v0, &beg, &len, total_bits, 0))) {
            return Qnil;
        }
        bit_offset = beg;
        bit_length = len;
    }
    else if (n_pos == 2) {
        if (!rb_integer_type_p(v0) || !rb_integer_type_p(v1)) {
            return Qnil;
        }

        bit_offset = integer_to_bit_idx(v0);
        bit_length = integer_to_bit_idx(v1);

        if (bit_offset < 0 || bit_length < 0) return Qnil;
    }
    else if (n_pos == 1) {
        return Qnil;
    }
    else {
        rb_raise(rb_eArgError,
                 "wrong number of arguments (given %d, expected 1 or 2)", n_pos);
    }

    if (bit_offset > total_bits) return Qnil;
    ssize_t available = total_bits - bit_offset;
    if (bit_length > available) bit_length = available;

    if (bit_length == 0) return rb_str_new("", 0);

    ssize_t out_bytes = (bit_length + 7) / 8;
    VALUE result = rb_str_buf_new(out_bytes);
    rb_str_resize(result, out_bytes);
    rb_enc_associate(result, rb_enc_get(self));
    unsigned char *dst = (unsigned char *)RSTRING_PTR(result);
    const unsigned char *src = (const unsigned char *)RSTRING_PTR(self);

    memset(dst, 0, out_bytes);

    if (lsb_first) {
        bit_copy_core(dst, 0, src, src_len, bit_offset, bit_length);
    } else {
        ssize_t dst_bit = 0;
        ssize_t start_byte = bit_offset >> 3;
        ssize_t end_byte = (bit_offset + bit_length - 1) >> 3;

        for (ssize_t b = start_byte; b <= end_byte; b++) {
            ssize_t b_start_l = b << 3;
            ssize_t b_end_l = b_start_l + 7;
            ssize_t l_min = (bit_offset > b_start_l) ? bit_offset : b_start_l;
            ssize_t l_max = ((bit_offset + bit_length - 1) < b_end_l) ? (bit_offset + bit_length - 1) : b_end_l;

            ssize_t p_min = b_start_l + (7 - (l_max & 7L));
            ssize_t p_max = b_start_l + (7 - (l_min & 7L));
            ssize_t chunk_len = p_max - p_min + 1;

            bit_copy_core(dst, dst_bit, src, src_len, p_min, chunk_len);
            dst_bit += chunk_len;
        }
    }
    return result;
}

#bit_splice(*args) ⇒ Object

Write bits from str into self at bit-level granularity (inverse of bit_slice).

# File 'ext/string_bits/string_bits.c', line 1617

static VALUE
rb_str_bit_splice(int argc, VALUE *argv, VALUE self)
{
    ssize_t dst_bit_off, dst_bit_len;
    ssize_t src_bit_off, src_bit_len;
    VALUE str;
    ssize_t dst_total = RSTRING_LEN(self) * 8;
    VALUE v0, v1, v2, v3, opts;

    int n_pos = rb_scan_args(argc, argv, "22:", &v0, &v1, &v2, &v3, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);

    if (n_pos == 2 && rb_obj_is_kind_of(v0, rb_cRange)) {
        /* bit_splice(range, str) */
        sb_range_validate_endpoints(v0);
        ssize_t beg, len;
        sb_range_beg_len(v0, &beg, &len, dst_total, 1);
        dst_bit_off = beg;
        dst_bit_len = len;
        str = v1;
        Check_Type(str, T_STRING);
        src_bit_off = 0;
        src_bit_len = dst_bit_len;
    }
    else if (n_pos == 3 && rb_obj_is_kind_of(v0, rb_cRange)) {
        /* bit_splice(range, str, str_bit_index) */
        sb_range_validate_endpoints(v0);
        ssize_t beg, len;
        sb_range_beg_len(v0, &beg, &len, dst_total, 1);
        dst_bit_off = beg;
        dst_bit_len = len;
        str = v1;
        Check_Type(str, T_STRING);
        if (!rb_integer_type_p(v2)) {
            rb_raise(rb_eTypeError, "third argument must be an Integer");
        }
        ssize_t src_total = RSTRING_LEN(str) * 8;
        src_bit_off = integer_to_bit_idx(v2);
        if (src_bit_off < 0) src_bit_off += src_total;
        src_bit_len = dst_bit_len;
    }
    else if (n_pos == 3) {
        /* bit_splice(bit_index, bit_length, str) */
        if (!rb_integer_type_p(v0) || !rb_integer_type_p(v1)) {
            rb_raise(rb_eTypeError, "bit index and length must be integers");
        }
        dst_bit_off = integer_to_bit_idx(v0);
        dst_bit_len = integer_to_bit_idx(v1);
        if (dst_bit_off < 0) dst_bit_off += dst_total;

        /*
         * Integer source support was prototyped here, but it is intentionally
         * disabled in the current proposal to keep the public API limited to
         * String-to-String splicing.
         */
        if (rb_integer_type_p(v2)) {
            rb_raise(rb_eArgError,
                     "bit_splice source must be a String in the current proposal");
        }

        str = v2;
        Check_Type(str, T_STRING);
        src_bit_off = 0;
        src_bit_len = dst_bit_len;
    }
    else if (n_pos == 4) {
        /* bit_splice(bit_index, bit_length, str, str_bit_index) */
        if (!rb_integer_type_p(v0) || !rb_integer_type_p(v1) || !rb_integer_type_p(v3)) {
            rb_raise(rb_eTypeError, "bit indices and lengths must be integers");
        }
        dst_bit_off = integer_to_bit_idx(v0);
        dst_bit_len = integer_to_bit_idx(v1);
        if (dst_bit_off < 0) dst_bit_off += dst_total;
        str = v2;
        Check_Type(str, T_STRING);
        ssize_t src_total = RSTRING_LEN(str) * 8;
        src_bit_off = integer_to_bit_idx(v3);
        if (src_bit_off < 0) src_bit_off += src_total;
        src_bit_len = dst_bit_len;
    }
    else {
        rb_raise(rb_eArgError,
                 "wrong number of arguments (given %d, expected 2, 3, or 4)", n_pos);
    }

    if (dst_bit_off < 0 || dst_bit_len < 0 || dst_bit_off + dst_bit_len > dst_total) {
        rb_raise(rb_eIndexError,
                 "bit_splice: destination range [%ld, %ld] out of bounds (total %ld bits)",
                 dst_bit_off, dst_bit_len, dst_total);
    }

    ssize_t src_total_bits = RSTRING_LEN(str) * 8;
    if (src_bit_off < 0 || src_bit_len < 0 || src_bit_off + src_bit_len > src_total_bits) {
        rb_raise(rb_eIndexError,
                 "bit_splice: source range [%ld, %ld] out of bounds (total %ld bits)",
                 src_bit_off, src_bit_len, src_total_bits);
    }

    if (dst_bit_len == 0) return self;

    /* Guard against self-aliasing: duplicate src before modifying self */
    VALUE src_str = (str == self) ? rb_str_dup(str) : str;

    rb_str_modify(self);

    unsigned char       *dst          = (unsigned char *)RSTRING_PTR(self);
    const unsigned char *src          = (const unsigned char *)RSTRING_PTR(src_str);
    ssize_t                 src_len_bytes = RSTRING_LEN(src_str);

    if (lsb_first) {
        bit_copy_core(dst, dst_bit_off, src, src_len_bytes, src_bit_off, dst_bit_len);
    } else {
        ssize_t current_src_bit = src_bit_off;
        ssize_t start_byte = dst_bit_off >> 3;
        ssize_t end_byte = (dst_bit_off + dst_bit_len - 1) >> 3;

        for (ssize_t b = start_byte; b <= end_byte; b++) {
            ssize_t b_start_l = b << 3;
            ssize_t b_end_l = b_start_l + 7;
            ssize_t l_min = (dst_bit_off > b_start_l) ? dst_bit_off : b_start_l;
            ssize_t l_max = ((dst_bit_off + dst_bit_len - 1) < b_end_l) ? (dst_bit_off + dst_bit_len - 1) : b_end_l;

            ssize_t p_min = b_start_l + (7 - (l_max & 7L));
            ssize_t p_max = b_start_l + (7 - (l_min & 7L));
            ssize_t chunk_len = p_max - p_min + 1;

            bit_copy_core(dst, p_min, src, src_len_bytes, current_src_bit, chunk_len);
            current_src_bit += chunk_len;
        }
    }

    RB_GC_GUARD(src_str);
    return self;
}

#bits(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 639

static VALUE
rb_str_bits(int argc, VALUE *argv, VALUE self)
{
    VALUE start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "01:", &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t start_offset = parse_start_offset(start_offset_v);
    ssize_t len = RSTRING_LEN(self);
    const unsigned char *str = (const unsigned char *)RSTRING_PTR(self);

    if (rb_block_given_p()) {
        emit_bits(str, len, lsb_first, start_offset, Qnil);
        return self;
    }

    ssize_t nbits = (start_offset >= len * 8) ? 0 : (len * 8 - start_offset);
    VALUE ary = rb_ary_new_capa(nbits);
    emit_bits(str, len, lsb_first, start_offset, ary);
    return ary;
}

#bitwise_and ⇒ Object

#bitwise_and! ⇒ Object

#bitwise_not ⇒ Object

#bitwise_not! ⇒ Object

#bitwise_or ⇒ Object

#bitwise_or! ⇒ Object

#bitwise_xor ⇒ Object

#bitwise_xor! ⇒ Object

#each_bit(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 623

static VALUE
rb_str_each_bit(int argc, VALUE *argv, VALUE self)
{
    RETURN_ENUMERATOR(self, argc, argv);

    VALUE start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "01:", &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t start_offset = parse_start_offset(start_offset_v);

    emit_bits((const unsigned char *)RSTRING_PTR(self), RSTRING_LEN(self),
              lsb_first, start_offset, Qnil);
    return self;
}

#each_bit_field(*args) ⇒ Object

Yield each packed bit-field record as one Integer per field.

# File 'ext/string_bits/string_bits.c', line 1313

static VALUE
rb_str_each_bit_field(int argc, VALUE *argv, VALUE self)
{
    RETURN_ENUMERATOR(self, argc, argv);

    VALUE rest, opts;
    rb_scan_args(argc, argv, "*:", &rest, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);

    ssize_t num_fields = RARRAY_LEN(rest);
    if (num_fields == 0) {
        rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
    }

    ssize_t *bitlens = ALLOCA_N(ssize_t, num_fields);
    ssize_t step = 0;
    for (ssize_t f = 0; f < num_fields; f++) {
        VALUE v = RARRAY_AREF(rest, f);
        if (!rb_integer_type_p(v)) {
            rb_raise(rb_eTypeError, "bitlen must be an integer");
        }
        ssize_t bl = NUM2SSIZET(v);
        if (bl <= 0) {
            rb_raise(rb_eArgError, "bitlen must be positive");
        }
        if (bl > 64) {
            rb_raise(rb_eArgError, "bitlen must be <= 64 (got %ld)", bl);
        }
        bitlens[f] = bl;
        step += bl;
    }

    int lsb_first = parse_lsb_first_opt(opts);

    ssize_t src_len = RSTRING_LEN(self);
    ssize_t total_bits = src_len * 8;
    ssize_t iterations = total_bits / step;

    VALUE *field_vals = ALLOCA_N(VALUE, num_fields);

    for (ssize_t iter = 0; iter < iterations; iter++) {
        ssize_t base_bit = iter * step;
        const unsigned char *src = (const unsigned char *)RSTRING_PTR(self);
        ssize_t field_bit = base_bit;
        for (ssize_t f = 0; f < num_fields; f++) {
            uint64_t val = extract_uint64(src, src_len, field_bit, bitlens[f], lsb_first);
            field_vals[f] = ULL2NUM(val);
            field_bit += bitlens[f];
        }
        rb_yield_values2((int)num_fields, field_vals);
    }

    return self;
}

#each_bit_offset(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 768

static VALUE
rb_str_each_bit_offset(int argc, VALUE *argv, VALUE self)
{
    RETURN_ENUMERATOR(self, argc, argv);

    VALUE bit_val, start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "11:", &bit_val, &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    int target    = parse_bit_target(bit_val);
    ssize_t start_offset = parse_start_offset(start_offset_v);

    emit_bit_offsets((const unsigned char *)RSTRING_PTR(self), RSTRING_LEN(self),
                     target, lsb_first, start_offset, Qnil);
    return self;
}

#each_bit_run(*args) ⇒ Object

# File 'ext/string_bits/string_bits.c', line 1581

static VALUE
rb_str_each_bit_run(int argc, VALUE *argv, VALUE self)
{
    RETURN_ENUMERATOR(self, argc, argv);

    VALUE start_offset_v = Qnil, opts = Qnil;
    rb_scan_args(argc, argv, "01:", &start_offset_v, &opts);
    validate_option_hash(opts, SB_KW_LSB_FIRST);
    int lsb_first = parse_lsb_first_opt(opts);
    ssize_t start_offset = parse_start_offset(start_offset_v);

    emit_bit_runs(self, lsb_first, start_offset, Qnil);
    return self;
}