rosy 0.0.9

Ruby bindings for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use super::prelude::*;

pub mod integer_flags {
    use super::*;

    pub const PACK_MSWORD_FIRST:                 c_int = 0x01;
    pub const PACK_LSWORD_FIRST:                 c_int = 0x02;
    pub const PACK_MSBYTE_FIRST:                 c_int = 0x10;
    pub const PACK_LSBYTE_FIRST:                 c_int = 0x20;
    pub const PACK_NATIVE_BYTE_ORDER:            c_int = 0x40;
    pub const PACK_2COMP:                        c_int = 0x80; // 2's compliment
    pub const PACK_FORCE_GENERIC_IMPLEMENTATION: c_int = 0x400;

    // For rb_integer_unpack:
    pub const PACK_FORCE_BIGNUM: c_int = 0x100;
    pub const PACK_NEGATIVE:     c_int = 0x200;

    // Combinations
    pub const PACK_LITTLE_ENDIAN: c_int = PACK_LSWORD_FIRST | PACK_LSBYTE_FIRST;
    pub const PACK_BIG_ENDIAN:    c_int = PACK_MSWORD_FIRST | PACK_MSBYTE_FIRST;
}

extern "C" {
    // VALUE rb_uint2inum(uintptr_t n)
    pub fn rb_uint2inum(n: usize) -> VALUE;
    // VALUE rb_int2inum(intptr_t n)
    pub fn rb_int2inum(n: isize) -> VALUE;

    // double rb_big2dbl(VALUE x)
    pub fn rb_big2dbl(x: VALUE) -> f64;
    // VALUE rb_big2str(VALUE x, int base)
    pub fn rb_big2str(x: VALUE, base: c_int) -> VALUE;

    // int rb_bigzero_p(VALUE x)
    pub fn rb_bigzero_p(x: VALUE) -> c_int;

    // int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
    pub fn rb_integer_pack(
        val: VALUE,
        words: *mut c_void,
        numwords: usize,
        wordsize: usize,
        nails: usize,
        flags: c_int,
    ) -> c_int;

    // VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
    pub fn rb_integer_unpack(
        words: *const c_void,
        numwords: usize,
        wordsize: usize,
        nails: usize,
        flags: c_int,
    ) -> VALUE;

    // VALUE rb_big_eq(VALUE x, VALUE y)
    pub fn rb_big_eq(x: VALUE, y: VALUE) -> VALUE;
    // int rb_big_sign(VALUE x)
    pub fn rb_big_sign(x: VALUE) -> c_int;

    // int rb_absint_singlebit_p(VALUE val)
    pub fn rb_absint_singlebit_p(val: VALUE) -> c_int;

    // size_t rb_absint_size(VALUE val, int *nlz_bits_ret)
    pub fn rb_absint_size(val: VALUE, nlz_bits_ret: *mut c_int) -> usize;

    // size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
    pub fn rb_absint_numwords(
        val: VALUE,
        word_numbits: usize,
        nlz_bits_ret: *mut usize,
    ) -> usize;

    // VALUE rb_big_cmp(VALUE x, VALUE y);
    pub fn rb_big_cmp(x: VALUE, y: VALUE) -> VALUE;
    // VALUE rb_big_and(VALUE x, VALUE y);
    pub fn rb_big_and(x: VALUE, y: VALUE) -> VALUE;
    // VALUE rb_big_or(VALUE x, VALUE y);
    pub fn rb_big_or(x: VALUE, y: VALUE) -> VALUE;
    // VALUE rb_big_xor(VALUE x, VALUE y);
    pub fn rb_big_xor(x: VALUE, y: VALUE) -> VALUE;
}