Lots of updates

Author: zshipko

Cargo.toml

@@ -7,6 +7,6 @@ keywords = ["ocaml", "rust", "ffi"]
 repository = "https://github.com/zshipko/ocaml-rs"
 license = "ISC"
 description = "OCaml bindings for Rust"
-documentation = "https://docs.rs/raml"
+documentation = "https://docs.rs/ocaml"
 
 [dependencies]

LICENSE.md

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2018, Zach Shipko
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

README.md

@@ -1,10 +1,6 @@
 # ocaml-rs - OCaml FFI for Rust
 
-NOTE: `ocmal-rs` is based on [raml v0.1](https://crates.io/crates/raml) with the goal of creating an even higher-level interface.
-
-Direct OCaml bindings without ever leaving Rust - no C stubs!
-
-Please see the example in `examples` for the Rust code in `rust` for the Rust code that OCaml code will call and the `ocaml` directory for the OCaml code that calls the Rust code.
+NOTE: `ocaml-rs` is based on [raml v0.1](https://crates.io/crates/raml) with the goal of creating a higher-level interface.
 
 ```rust
 caml!(ml_beef, |parameter|, <local>, {
@@ -15,7 +11,9 @@ caml!(ml_beef, |parameter|, <local>, {
 } -> local);
 ```
 
-The macro takes care of _automatically_ declaring `CAMLparam` et. al, as well as `CAMLlocal` and `CAMLreturn`.
+The macro takes care of _automatically_ declaring `CAMLparam` et. al, as well as `CAMLlocal` and `CAMLreturn`
+
+For a working example see `./examples/rust` and `./examples/ocaml`
 
 ### Documentation
 

examples/ocaml/Makefile

@@ -18,8 +18,7 @@ pretty: test
 	cd ../rust && cargo rustc $(ARGS)
 
 clean:
-	rm test *.o *.cm*
-	rm -rf _build
+	rm -rf _build test
 	cd ../rust && cargo clean
 
 .PHONY: build clean pretty

examples/ocaml/test.ml

@@ -4,9 +4,15 @@ external send_tuple : (int * int) -> int = "ml_send_tuple"
 external new_tuple : unit -> (int * int * int) = "ml_new_tuple"
 external new_array : unit -> int array = "ml_new_array"
 external new_list : unit -> int list = "ml_new_list"
+external testing_callback : int -> int -> unit = "ml_testing_callback"
 
 let f x = x land 0x0000ffff
 
+let print_testing a b =
+    Printf.printf "testing: %d %d\n" a b
+
+let _ =
+    Callback.register "print_testing" print_testing
 
 let _ =
   let string = "string thing" in
@@ -23,4 +29,5 @@ let _ =
   let arr = new_array () in
   Array.iter (Printf.printf "%d\n") arr;
   let lst = new_list () in
-  List.iter (Printf.printf "%d\n") lst
+  List.iter (Printf.printf "%d\n") lst;
+  testing_callback 5 10

examples/rust/src/lib.rs

@@ -12,8 +12,10 @@ caml!(ml_send_int, |v|, <l>, {
 caml!(ml_send_two, |v, v2|, {
     println!("local root addr: {:p} caml_local_roots: {:#?}, v: {:?}", &memory::caml_local_roots, memory::caml_local_roots, v.value());
     let x = v.int_val();
+    println!("string tag: {}", v2.tag() as u8);
     let string = ocaml::Str::from(v2);
     println!("got  0x{:x}, {}", x, string.as_str());
+
 });
 
 caml!(ml_send_tuple, |t|, <dest>, {
@@ -24,26 +26,23 @@ caml!(ml_send_tuple, |t|, <dest>, {
 } -> dest);
 
 caml!(ml_new_tuple, |_unit|, <dest>, {
-    let tuple = ocaml::Tuple::from((Value::int(0), Value::int(1), Value::int(2)));
+    let tuple = ocaml::Tuple::from(vec![Value::int(0), Value::int(1), Value::int(2)]);
     dest = Value::from(tuple);
 } -> dest);
 
 caml!(ml_new_array, |_unit|, <dest>, {
-    let mut arr = ocaml::Array::new(5);
-
-    for i in 0..5 {
-        arr.set(i, Value::int(i as i32)).unwrap();
-    }
-
-    dest = Value::from(arr)
+    let x: Vec<Value> = (0..5).map(|x| Value::int(x)).collect();
+    dest = ocaml::Array::from(x).into();
 } -> dest);
 
 caml!(ml_new_list, |_unit|, <dest>, {
-    let mut list = ocaml::List::new();
+    let x: Vec<Value> = (0..5).map(|x| Value::int(x)).collect();
+    dest = ocaml::List::from(x).into();
+} -> dest);
 
-    for i in 0..5 {
-        list.append(Value::int(i));
-    }
+caml!(ml_testing_callback, |a, b|, {
+    let f = ocaml::named_value("print_testing")
+        .expect("print_testing not registered");
 
-    dest = ocaml::Value::from(list)
-} -> dest);
+    f.call_n(vec![a, b]);
+});

src/core/lib.rs

@@ -36,6 +36,27 @@ pub type Mark = Uintnat;
 ///
 pub struct Header {}
 
+pub const VALUE_SIZE: isize = ::std::mem::size_of::<Value>() as isize;
+
+/// #ifdef ARCH_BIG_ENDIAN
+/// #define Tag_val(val) (((unsigned char *) (val)) [-1])
+/// #else
+/// #define Tag_val(val) (((unsigned char *) (val)) [-sizeof(value)])
+/// #endif
+#[cfg(target_endian = "big")]
+#[macro_export]
+macro_rules! tag_val {
+($x:expr) => (*(($x as *const u8).offset(-1)));
+($x:ident) => (*(($x as *const u8).offset(-1)));
+}
+
+#[cfg(target_endian = "little")]
+#[macro_export]
+macro_rules! tag_val {
+($x:expr) => (*(($x as *const u8).offset(-$crate::core::mlvalues::VALUE_SIZE)));
+($x:ident) => (*(($x as *const u8).offset(-$crate::core::mlvalues::VALUE_SIZE)));
+}
+
 #[macro_export]
 /// `(((intnat)(x) << 1) + 1)`
 macro_rules! val_long {

src/core/mlvalues.rs

@@ -27,8 +27,8 @@ pub enum Tag {
 }
 
 impl Tag {
-    pub fn new(i: u32) -> Tag {
-        match i {
+    pub fn new(i: u8) -> Tag {
+        match i as u32 {
             Forward_tag => Tag::Forward,
             Infix_tag => Tag::Infix,
             Object_tag => Tag::Object,

src/tag.rs

@@ -17,23 +17,14 @@ impl From<Tuple> for Value {
     }
 }
 
-impl From<(Value, Value)> for Tuple {
-    fn from(t: (Value, Value)) -> Tuple {
-        let mut dst = Tuple::new(2);
-        let (a, b) = t;
-        let _ = dst.set(0, a);
-        let _ = dst.set(1, b);
-        dst
-    }
-}
+impl <R: AsRef<[Value]>> From<R> for Tuple {
+    fn from(t: R) -> Tuple {
+        let mut dst = Tuple::new(t.as_ref().len());
+
+        for (n, item) in t.as_ref().iter().enumerate() {
+            let _ = dst.set(n, item.clone());
+        }
 
-impl From<(Value, Value, Value)> for Tuple {
-    fn from(t: (Value, Value, Value)) -> Tuple {
-        let mut dst = Tuple::new(3);
-        let (a, b, c) = t;
-        let _ = dst.set(0, a);
-        let _ = dst.set(1, b);
-        let _ = dst.set(2, c);
         dst
     }
 }
@@ -76,6 +67,18 @@ impl From<Array> for Value {
     }
 }
 
+impl <R: AsRef<[Value]>> From<R> for Array {
+    fn from(t: R) -> Array {
+        let mut dst = Array::new(t.as_ref().len());
+
+        for (n, item) in t.as_ref().iter().enumerate() {
+            let _ = dst.set(n, item.clone());
+        }
+
+        dst
+    }
+}
+
 impl From<Value> for Array {
     fn from(v: Value) -> Array {
         if !v.is_block() {
@@ -127,6 +130,18 @@ impl From<List> for Value {
     }
 }
 
+impl <R: AsRef<[Value]>> From<R> for List {
+    fn from(t: R) -> List {
+        let mut dst = List::new();
+
+        for item in t.as_ref().iter().rev() {
+            let _ = dst.push_hd(item.clone());
+        }
+
+        dst
+    }
+}
+
 impl List {
     pub fn new() -> List {
         List(Value::new(empty_list()), 0)
@@ -136,7 +151,7 @@ impl List {
         self.1
     }
 
-    pub fn append(&mut self, v: Value) {
+    pub fn push_hd(&mut self, v: Value) {
         unsafe {
             let tmp = alloc::caml_alloc(2, 0);
             memory::store_field(tmp, 0, v.0);