Class: String

Inherits:
Object
  • Object
show all
Defined in:
(unknown)

Instance Method Summary collapse

Instance Method Details

#bit_at(*args) ⇒ Object

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



408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
 
# File 'ext/string_bits/string_bits.c', line 408

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");
    }
    int64_t size = SB_BIT_LEN(RSTRING_LEN(self));
    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 



1121
1122
1123
1124
1125
 
# File 'ext/string_bits/string_bits.c', line 1121

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 



561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
 
# File 'ext/string_bits/string_bits.c', line 561

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);
    int64_t total_bits = SB_BIT_LEN(src_len);
    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.



1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
 
# File 'ext/string_bits/string_bits.c', line 1400

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 %" PRIdPTR ")", (intptr_t)bl);
        }
        bitlens[f] = bl;
        step += bl;
    }

    int lsb_first = parse_lsb_first_opt(opts);

    ssize_t src_len = RSTRING_LEN(self);
    int64_t total_bits = SB_BIT_LEN(src_len);
    ssize_t iterations = (ssize_t)(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 



1127
1128
1129
1130
1131
 
# File 'ext/string_bits/string_bits.c', line 1127

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 



816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
 
# File 'ext/string_bits/string_bits.c', line 816

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 : (ssize_t)(SB_BIT_LEN(len) - 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.



1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
 
# File 'ext/string_bits/string_bits.c', line 1532

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 >= SB_BIT_LEN(src_len)) 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;
    int64_t total_bits = SB_BIT_LEN(src_len);
    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.



1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
 
# File 'ext/string_bits/string_bits.c', line 1628

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 



1115
1116
1117
1118
1119
 
# File 'ext/string_bits/string_bits.c', line 1115

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.



938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
 
# File 'ext/string_bits/string_bits.c', line 938

static VALUE
rb_str_bit_slice(int argc, VALUE *argv, VALUE self)
{
    ssize_t src_len = RSTRING_LEN(self);
    int64_t total_bits = SB_BIT_LEN(src_len);
    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;
    int64_t available = total_bits - bit_offset;
    if (bit_length > available) bit_length = (ssize_t)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).



1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
 
# File 'ext/string_bits/string_bits.c', line 1648

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;
    int64_t dst_total = SB_BIT_LEN(RSTRING_LEN(self));
    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");
        }
        int64_t src_total = SB_BIT_LEN(RSTRING_LEN(str));
        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);
        int64_t src_total = SB_BIT_LEN(RSTRING_LEN(str));
        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 [%" PRIdPTR ", %" PRIdPTR
                 "] out of bounds (total %" PRId64 " bits)",
                 (intptr_t)dst_bit_off, (intptr_t)dst_bit_len, (int64_t)dst_total);
    }

    int64_t src_total_bits = SB_BIT_LEN(RSTRING_LEN(str));
    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 [%" PRIdPTR ", %" PRIdPTR
                 "] out of bounds (total %" PRId64 " bits)",
                 (intptr_t)src_bit_off, (intptr_t)src_bit_len, (int64_t)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 



669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
 
# File 'ext/string_bits/string_bits.c', line 669

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;
    }

    int64_t total_bits = SB_BIT_LEN(len);
    ssize_t nbits = (start_offset >= total_bits) ? 0 : (ssize_t)(total_bits - 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 



653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
 
# File 'ext/string_bits/string_bits.c', line 653

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.



1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
 
# File 'ext/string_bits/string_bits.c', line 1344

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 %" PRIdPTR ")", (intptr_t)bl);
        }
        bitlens[f] = bl;
        step += bl;
    }

    int lsb_first = parse_lsb_first_opt(opts);

    ssize_t src_len = RSTRING_LEN(self);
    int64_t total_bits = SB_BIT_LEN(src_len);
    ssize_t iterations = (ssize_t)(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 



799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
 
# File 'ext/string_bits/string_bits.c', line 799

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 



1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
 
# File 'ext/string_bits/string_bits.c', line 1612

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;
}