raml 0.1.0

Direct OCaml FFI bindings and runtime functions in Rust, without any C
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Contains OCaml types and conversion functions from runtime representations.
//!

#[allow(non_camel_case_types)]
pub type Value = usize;
pub type Uintnat = usize;
#[allow(non_camel_case_types)]
pub type Mlsize_t = Uintnat;
#[allow(non_camel_case_types)]
pub type Tag_t = u8; //typedef unsigned int tag_t; // Actually, an unsigned char
#[allow(non_camel_case_types)]
pub type Color_t = Uintnat;
#[allow(non_camel_case_types)]
pub type Mark_t = Uintnat;

/// An OCaml heap-allocated block header. **NB**: this is currently unimplemented.
///
/// Structure of the header:
///
/// For 16-bit and 32-bit architectures:
///
///```text
///      +--------+-------+-----+
///      | wosize | color | tag |
///      +--------+-------+-----+
/// bits  31    10 9     8 7   0
///```
///
/// For 64-bit architectures:
///
///```text
///      +--------+-------+-----+
///      | wosize | color | tag |
///      +--------+-------+-----+
/// bits  63    10 9     8 7   0
///```
///
pub struct Header {}

#[macro_export]
/// `(((intnat)(x) << 1) + 1)`
macro_rules! val_long {
($x:expr) => ((($x as usize) << 1) + 1);
($x:ident) => ((($x as usize) << 1) + 1);
}

#[macro_export]
/// `Long_val(x)     ((x) >> 1)`
macro_rules! long_val {
($x:ident) => ($x as usize >> 1);
($x:expr) => ($x as usize >> 1);
}

#[macro_export]
/// Converts a machine `usize` into an OCaml `int`
///
/// `Val_int(x) Val_long(x)`
macro_rules! val_int {
($x:expr) => ( val_long!($x) );
($x:ident) => ( val_long!($x) );
}

#[macro_export]
/// Converts an OCaml `int` into a `usize`
///
/// `Int_val(x) ((int) Long_val(x))`
macro_rules! int_val {
($x:ident) => (long_val!($x));
($x:expr) => (long_val!($x));
}

// #define Max_long (((intnat)1 << (8 * sizeof(value) - 2)) - 1)
// #define Min_long (-((intnat)1 << (8 * sizeof(value) - 2)))

#[macro_export]
/// Extracts from the `$block` an OCaml value at the `$ith`-field
macro_rules! field {
    ($block:ident, $i:expr) => (
    unsafe { (block as *mut Value).offset(i)}
    );
}

/// The OCaml `()` (`unit`) value - rien.
pub const UNIT: Value = val_int!(0);

/*
pub const Num_tags: ::std::os::raw::c_ushort = 256;
pub const No_scan_tag: ::std::os::raw::c_uchar = 251;
pub const Forward_tag: ::std::os::raw::c_uchar = 250;
pub const Infix_tag: ::std::os::raw::c_uchar = 249;
pub const Object_tag: ::std::os::raw::c_uchar = 248;
pub const Closure_tag: ::std::os::raw::c_uchar = 247;
pub const Lazy_tag: ::std::os::raw::c_uchar = 246;
pub const Abstract_tag: ::std::os::raw::c_uchar = 251;
pub const String_tag: ::std::os::raw::c_uchar = 252;
pub const Double_tag: ::std::os::raw::c_uchar = 253;
pub const Double_array_tag: ::std::os::raw::c_uchar = 254;
pub const Custom_tag: ::std::os::raw::c_uchar = 255;
pub const Tag_cons: ::std::os::raw::c_uchar = 0;
*/

// Strings
/// The OCaml GC tag for a `string`
pub const STRING_TAG: u8 = 252;

/// Pointer to the first byte
#[macro_export]
macro_rules! bp_val {
  ($v: ident) => {
      $v as *const u8
  }
}

#[macro_export]
/// Extracts a machine `ptr` to the bytes making up an OCaml `string`
macro_rules! string_val {
  ($v:ident) => {
      bp_val!($v)
  }
}

extern "C" {
    /// Returns size of the string in `value` in bytes
    pub fn caml_string_length(value: Value) -> Mlsize_t;
}