rust: iterator bindings to C code

In this changeset, still made of Rust code only,
we expose the Rust iterator for instantiation and
consumption from C code.

The idea is that both the index and index_get_parents()
will be passed from the C extension, hence avoiding a hard
link dependency to parsers.so, so that the crate can
still be built and tested independently.

On the other hand, parsers.so will use the symbols
defined in this changeset.

rust/hg-direct-ffi/Cargo.toml

@@ -0,0 +1,12
+[package]
+name = "hgdirectffi"
+version = "0.1.0"
+authors = ["Georges Racinet <[e-mail]>"]
+description = "Low level Python bindings for hg-core, going through existing C extensions"
+
+[dependencies]
+libc = "*"
+hg-core = { path = "../hg-core" }
+
+[lib]
+crate-type = ["staticlib"]

rust/hg-direct-ffi/src/ancestors.rs

@@ -0,0 +1,229
+// Copyright 2018 Georges Racinet <[e-mail]>
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+
+//! Bindings for CPython extension code
+//!
+//! This exposes methods to build and use a `rustlazyancestors` iterator
+//! from C code, using an index and its parents function that are passed
+//! from the caller at instantiation.
+
+use hg::AncestorsIterator;
+use hg::{Graph, GraphError, Revision, NULL_REVISION};
+use libc::{c_int, c_long, c_void, ssize_t};
+use std::ptr::null_mut;
+use std::slice;
+
+type IndexPtr = *mut c_void;
+type IndexParentsFn =
+    unsafe extern "C" fn(index: IndexPtr, rev: ssize_t, ps: *mut [c_int; 2], max_rev: c_int)
+        -> c_int;
+
+/// A Graph backed up by objects and functions from revlog.c
+///
+/// This implementation of the Graph trait, relies on (pointers to)
+/// - the C index object (`index` member)
+/// - the `index_get_parents()` function (`parents` member)
+pub struct Index {
+    index: IndexPtr,
+    parents: IndexParentsFn,
+}
+
+impl Index {
+    pub fn new(index: IndexPtr, parents: IndexParentsFn) -> Self {
+        Index {
+            index: index,
+            parents: parents,
+        }
+    }
+}
+
+impl Graph for Index {
+    /// wrap a call to the C extern parents function
+    fn parents(&self, rev: Revision) -> Result<(Revision, Revision), GraphError> {
+        let mut res: [c_int; 2] = [0; 2];
+        let code =
+            unsafe { (self.parents)(self.index, rev as ssize_t, &mut res as *mut [c_int; 2], rev) };
+        match code {
+            0 => Ok((res[0], res[1])),
+            _ => Err(GraphError::ParentOutOfRange(rev)),
+        }
+    }
+}
+
+/// Wrapping of AncestorsIterator<Index> constructor, for C callers.
+///
+/// Besides `initrevs`, `stoprev` and `inclusive`, that are converted
+/// we receive the index and the parents function as pointers
+#[no_mangle]
+pub extern "C" fn rustlazyancestors_init(
+    index: IndexPtr,
+    parents: IndexParentsFn,
+    initrevslen: usize,
+    initrevs: *mut c_long,
+    stoprev: c_long,
+    inclusive: c_int,
+) -> *mut AncestorsIterator<Index> {
+    unsafe {
+        raw_init(
+            Index::new(index, parents),
+            initrevslen,
+            initrevs,
+            stoprev,
+            inclusive,
+        )
+    }
+}
+
+/// Testable (for any Graph) version of rustlazyancestors_init
+#[inline]
+unsafe fn raw_init<G: Graph>(
+    graph: G,
+    initrevslen: usize,
+    initrevs: *mut c_long,
+    stoprev: c_long,
+    inclusive: c_int,
+) -> *mut AncestorsIterator<G> {
+    let inclb = match inclusive {
+        0 => false,
+        1 => true,
+        _ => {
+            return null_mut();
+        }
+    };
+
+    let slice = slice::from_raw_parts(initrevs, initrevslen);
+
+    Box::into_raw(Box::new(match AncestorsIterator::new(
+        graph,
+        slice.into_iter().map(|&r| r as Revision),
+        stoprev as Revision,
+        inclb,
+    ) {
+        Ok(it) => it,
+        Err(_) => {
+            return null_mut();
+        }
+    }))
+}
+
+/// Deallocator to be called from C code
+#[no_mangle]
+pub extern "C" fn rustlazyancestors_drop(raw_iter: *mut AncestorsIterator<Index>) {
+    raw_drop(raw_iter);
+}
+
+/// Testable (for any Graph) version of rustlazayancestors_drop
+#[inline]
+fn raw_drop<G: Graph>(raw_iter: *mut AncestorsIterator<G>) {
+    unsafe {
+        Box::from_raw(raw_iter);
+    }
+}
+
+/// Iteration main method to be called from C code
+///
+/// We convert the end of iteration into NULL_REVISION,
+/// it will be up to the C wrapper to convert that back into a Python end of
+/// iteration
+#[no_mangle]
+pub extern "C" fn rustlazyancestors_next(raw: *mut AncestorsIterator<Index>) -> c_long {
+    raw_next(raw)
+}
+
+/// Testable (for any Graph) version of rustlazayancestors_next
+#[inline]
+fn raw_next<G: Graph>(raw: *mut AncestorsIterator<G>) -> c_long {
+    let as_ref = unsafe { &mut *raw };
+    as_ref.next().unwrap_or(NULL_REVISION) as c_long
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::thread;
+
+    #[derive(Clone, Debug)]
+    struct Stub;
+
+    impl Graph for Stub {
+        fn parents(&self, r: Revision) -> Result<(Revision, Revision), GraphError> {
+            match r {
+                25 => Err(GraphError::ParentOutOfRange(25)),
+                _ => Ok((1, 2)),
+            }
+        }
+    }
+
+    /// Helper for test_init_next()
+    fn stub_raw_init(
+        initrevslen: usize,
+        initrevs: usize,
+        stoprev: c_long,
+        inclusive: c_int,
+    ) -> usize {
+        unsafe {
+            raw_init(
+                Stub,
+                initrevslen,
+                initrevs as *mut c_long,
+                stoprev,
+                inclusive,
+            ) as usize
+        }
+    }
+
+    fn stub_raw_init_from_vec(
+        mut initrevs: Vec<c_long>,
+        stoprev: c_long,
+        inclusive: c_int,
+    ) -> *mut AncestorsIterator<Stub> {
+        unsafe {
+            raw_init(
+                Stub,
+                initrevs.len(),
+                initrevs.as_mut_ptr(),
+                stoprev,
+                inclusive,
+            )
+        }
+    }
+
+    #[test]
+    // Test what happens when we init an Iterator as with the exposed C ABI
+    // and try to use it afterwards
+    // We spawn new threads, in order to make memory consistency harder
+    // but this forces us to convert the pointers into shareable usizes.
+    fn test_init_next() {
+        let mut initrevs: Vec<c_long> = vec![11, 13];
+        let initrevs_len = initrevs.len();
+        let initrevs_ptr = initrevs.as_mut_ptr() as usize;
+        let handler = thread::spawn(move || stub_raw_init(initrevs_len, initrevs_ptr, 0, 1));
+        let raw = handler.join().unwrap() as *mut AncestorsIterator<Stub>;
+
+        assert_eq!(raw_next(raw), 13);
+        assert_eq!(raw_next(raw), 11);
+        assert_eq!(raw_next(raw), 2);
+        assert_eq!(raw_next(raw), 1);
+        assert_eq!(raw_next(raw), NULL_REVISION as c_long);
+        raw_drop(raw);
+    }
+
+    #[test]
+    fn test_init_wrong_bool() {
+        assert_eq!(stub_raw_init_from_vec(vec![11, 13], 0, 2), null_mut());
+    }
+
+    #[test]
+    fn test_empty() {
+        let raw = stub_raw_init_from_vec(vec![], 0, 1);
+        assert_eq!(raw_next(raw), NULL_REVISION as c_long);
+        raw_drop(raw);
+    }
+
+    #[test]
+    fn test_init_err_out_of_range() {
+        assert!(stub_raw_init_from_vec(vec![25], 0, 0).is_null());
+    }
+}

rust/hg-direct-ffi/src/lib.rs

@@ -0,0 +1,16
+// Copyright 2018 Georges Racinet <[e-mail]>
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+
+//! Bindings for CPython extension code
+//!
+//! This exposes methods to build and use a `rustlazyancestors` iterator
+//! from C code, using an index and its parents function that are passed
+//! from the caller at instantiation.
+
+extern crate hg;
+extern crate libc;
+
+mod ancestors;
+pub use ancestors::{rustlazyancestors_drop, rustlazyancestors_init, rustlazyancestors_next};

rust/Cargo.lock

@@ -1,131 +1,139
 [[package]]
 name = "aho-corasick"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cpython"
 version = "0.1.0"
 source = "git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52#c90d65cf84abfffce7ef54476bbfed56017a2f52"
 dependencies = [
  "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
  "python27-sys 0.1.2 (git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52)",
 ]
 
 [[package]]
 name = "hg-core"
 version = "0.1.0"
 
 [[package]]
 name = "hgcli"
 version = "0.1.0"
 dependencies = [
  "cpython 0.1.0 (git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52)",
  "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
  "python27-sys 0.1.2 (git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52)",
 ]
 
 [[package]]
+name = "hgdirectffi"
+version = "0.1.0"
+dependencies = [
+ "hg-core 0.1.0",
+ "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "kernel32-sys"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "libc"
 version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "memchr"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "num-traits"
 version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "python27-sys"
 version = "0.1.2"
 source = "git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52#c90d65cf84abfffce7ef54476bbfed56017a2f52"
 dependencies = [
  "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 0.1.80 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "regex"
 version = "0.1.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "aho-corasick 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "thread_local 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "regex-syntax"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "thread-id"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "thread_local"
 version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "utf8-ranges"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "winapi"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "winapi-build"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [metadata]
 "checksum aho-corasick 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ca972c2ea5f742bfce5687b9aef75506a764f61d37f8f649047846a9686ddb66"
 "checksum cpython 0.1.0 (git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52)" = "<none>"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
 "checksum libc 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)" = "96264e9b293e95d25bfcbbf8a88ffd1aedc85b754eba8b7d78012f638ba220eb"
 "checksum memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d8b629fb514376c675b98c1421e80b151d3817ac42d7c667717d282761418d20"
 "checksum num-traits 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "cacfcab5eb48250ee7d0c7896b51a2c5eec99c1feea5f32025635f5ae4b00070"
 "checksum python27-sys 0.1.2 (git+https://github.com/indygreg/rust-cpython.git?rev=c90d65cf84abfffce7ef54476bbfed56017a2f52)" = "<none>"
 "checksum regex 0.1.80 (registry+https://github.com/rust-lang/crates.io-index)" = "4fd4ace6a8cf7860714a2c2280d6c1f7e6a413486c13298bbc86fd3da019402f"
 "checksum regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957"
 "checksum thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a9539db560102d1cef46b8b78ce737ff0bb64e7e18d35b2a5688f7d097d0ff03"
 "checksum thread_local 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "8576dbbfcaef9641452d5cf0df9b0e7eeab7694956dd33bb61515fb8f18cfdd5"
 "checksum utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a1ca13c08c41c9c3e04224ed9ff80461d97e121589ff27c753a16cb10830ae0f"
 "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
 "checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"

rust/Cargo.toml

@@ -1,3 +1,3
 [workspace]
-members = ["hgcli", "hg-core"]
+members = ["hgcli", "hg-core", "hg-direct-ffi"]
 exclude = ["chg"]