Move libfsm/start.c to Rust

.gitignore

@@ -1 +1,3 @@
-build/
+/build
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "libfsm-rs"
+version = "0.1.0"
+authors = ["Kate F <kate@elide.org>"]
+edition = "2018"
+
+[lib]
+crate-type = ["staticlib"]
+path = "src/libfsm/lib.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libc = "0.2"

Makefile

@@ -92,7 +92,6 @@ INCDIR += include
 .include <obj.mk>
 .include <dep.mk>
 .include <ar.mk>
-.include <so.mk>
 .include <part.mk>
 .include <prog.mk>
 .include <mkdir.mk>
@@ -110,3 +109,24 @@ STAGE_BUILD := ${STAGE_BUILD:Nbin/cvtpcre}
 	grep FAIL ${BUILD}/tests/*/res*; [ $$? -ne 0 ]
 .endif
 
+.if !${CC:T:Memcc*}
+
+./target/debug/liblibfsm_rs.a:
+	cargo build
+
+test::
+	cargo test
+
+./target/debug/liblibfsm_rs.d: ./target/debug/liblibfsm_rs.a
+.if exists(./target/debug/liblibfsm_rs.d)
+.include "./target/debug/liblibfsm_rs.d"
+.endif
+
+.for part in ${PART}
+${BUILD}/lib/${part}.o: ./target/debug/liblibfsm_rs.a
+# hijacking LDRFLAGS here because the target only expects .o sources
+LDRFLAGS.${part} += ./target/debug/liblibfsm_rs.a
+.endfor
+
+.endif
+

src/fsm/Makefile

@@ -61,6 +61,8 @@ LDD_VER!=                        \
 LFLAGS.fsm += -lrt
 .endif
 
+LFLAGS.fsm += -lpthread -ldl
+
 .endif
 
 .endif

src/libfsm/Makefile

@@ -8,13 +8,11 @@ SRC += src/libfsm/clone.c
 SRC += src/libfsm/closure.c
 SRC += src/libfsm/edge.c
 SRC += src/libfsm/empty.c
-SRC += src/libfsm/end.c
 SRC += src/libfsm/endids.c
 SRC += src/libfsm/equal.c
 SRC += src/libfsm/exec.c
 SRC += src/libfsm/fsm.c
 SRC += src/libfsm/mode.c
-SRC += src/libfsm/start.c
 SRC += src/libfsm/state.c
 SRC += src/libfsm/trim.c
 SRC += src/libfsm/example.c

src/libfsm/capture.c

@@ -21,7 +21,7 @@ fsm_capture_init(struct fsm *fsm)
 	}
 	fsm->capture_info = ci;
 
-	for (i = 0; i < fsm->statealloc; i++) {
+	for (i = 0; i < fsm->statecount; i++) {
 		fsm->states[i].has_capture_actions = 0;
 	}
 

src/libfsm/fsm.c

@@ -22,6 +22,7 @@
 #include "internal.h"
 #include "capture.h"
 #include "endids.h"
+#include "libfsm_rs.h"
 
 void
 free_contents(struct fsm *fsm)
@@ -47,6 +48,9 @@ fsm_new(const struct fsm_options *opt)
 	static const struct fsm_options defaults;
 	struct fsm *new, f;
 
+	/* just to prove linking works */
+	fsm_noop();
+
 	if (opt == NULL) {
 		opt = &defaults;
 	}

src/libfsm/fsm.rs

@@ -0,0 +1,243 @@
+//! Representation of a Finite State Machine.
+
+use libc::c_void;
+use std::slice;
+
+// Keep in sync with include/fsm.h:fsm_state_t
+type StateId = u32;
+
+// Opaque pointer to struct edget_set
+type EdgeSet = *mut c_void;
+
+// Opaque pointer to struct state_set
+type StateSet = *mut c_void;
+
+// Opaque pointer to struct fsm_capture_info
+type CaptureInfo = *mut c_void;
+
+// Opaque pointer to struct endid_info
+type EndIdInfo = *mut c_void;
+
+// Opaque pointer to struct fsm_options
+type Options = *const c_void;
+
+const ENDCOUNT_MAX: usize = usize::MAX;
+
+/// One state in a `Fsm`'s array of states.
+// Keep in sync with interanl.h:struct fsm_state
+#[repr(C)]
+struct State {
+    end: bool,
+
+    /// If false, then this state has no need for checking the fsm->capture_info struct.
+    has_capture_actions: bool,
+
+    /// Meaningful within one particular transformation only.
+    visited: bool,
+
+    edges: EdgeSet,
+    epsilons: StateSet,
+}
+
+/// Finite State Machine.
+// Keep in sync with interanl.h:struct fsm
+#[repr(C)]
+pub struct Fsm {
+    /// Array.
+    states: *mut State,
+
+    /// Number of elements allocated.
+    statealloc: usize,
+
+    /// Number of elements populated.
+    statecount: usize,
+
+    endcount: usize,
+
+    start: StateId,
+    hasstart: bool,
+
+    capture_info: CaptureInfo,
+    endid_info: EndIdInfo,
+    opt: Options,
+}
+
+impl Fsm {
+    pub fn clear_start(&mut self) {
+        self.hasstart = false;
+    }
+
+    pub fn set_start(&mut self, state: StateId) {
+        assert!((state as usize) < self.statecount);
+
+        self.start = state;
+        self.hasstart = true;
+    }
+
+    pub fn get_start(&self) -> Option<StateId> {
+        if self.hasstart {
+            assert!((self.start as usize) < self.statecount);
+            Some(self.start)
+        } else {
+            None
+        }
+    }
+
+    fn states_as_mut_slice(&self) -> &mut [State] {
+        unsafe { slice::from_raw_parts_mut(self.states, self.statecount) }
+    }
+
+    pub fn set_end(&mut self, state: StateId, end: bool) {
+        assert!((state as usize) < self.statecount);
+
+        {
+            // Temporary scope so the `s` mutable borrow terminates before
+            // we frob `self.endcount` below.
+
+            let states = self.states_as_mut_slice();
+            let s = &mut states[state as usize];
+
+            if s.end == end {
+                return;
+            } else {
+                s.end = end;
+            }
+        }
+
+        if end {
+            assert!(self.endcount < ENDCOUNT_MAX);
+            self.endcount += 1;
+        } else {
+            assert!(self.endcount > 0);
+            self.endcount -= 1;
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe fn fsm_clearstart(fsm: *mut Fsm) {
+    assert!(!fsm.is_null());
+    let fsm = &mut *fsm;
+
+    fsm.clear_start();
+}
+
+#[no_mangle]
+pub unsafe fn fsm_setstart(fsm: *mut Fsm, state: StateId) {
+    assert!(!fsm.is_null());
+    let fsm = &mut *fsm;
+
+    fsm.set_start(state);
+}
+
+#[no_mangle]
+pub unsafe fn fsm_getstart(fsm: *const Fsm, out_start: *mut StateId) -> i32 {
+    assert!(!fsm.is_null());
+    assert!(!out_start.is_null());
+
+    let fsm = &*fsm;
+    match fsm.get_start() {
+        Some(id) => {
+            *out_start = id;
+            1
+        }
+
+        None => 0,
+    }
+}
+
+#[no_mangle]
+pub unsafe fn fsm_setend(fsm: *mut Fsm, state: StateId, end: i32) {
+    assert!(!fsm.is_null());
+    let fsm = &mut *fsm;
+
+    let end = if end != 0 { true } else { false };
+
+    fsm.set_end(state, end)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ptr;
+
+    // Just here until we can construct Fsm in Rust
+    fn dummy_fsm_new() -> Fsm {
+        Fsm {
+            states: ptr::null_mut(),
+            statealloc: 0,
+            statecount: 0,
+            endcount: 0,
+            start: 0,
+            hasstart: false,
+            capture_info: ptr::null_mut(),
+            endid_info: ptr::null_mut(),
+            opt: ptr::null(),
+        }
+    }
+
+    #[test]
+    fn sets_and_clears_start() {
+        let mut fsm = dummy_fsm_new();
+
+        // FIXME: this sets up an inconsistent state, but we need it to
+        // test the assertion inside fsm.set_start().
+        fsm.statecount = 1;
+
+        fsm.set_start(0);
+        assert_eq!(fsm.get_start(), Some(0));
+
+        fsm.clear_start();
+        assert!(fsm.get_start().is_none())
+    }
+
+    #[test]
+    fn sets_and_clears_start_from_c() {
+        let mut fsm = dummy_fsm_new();
+        let fsm_ptr = &mut fsm as *mut _;
+
+        // FIXME: this sets up an inconsistent state, but we need it to
+        // test the assertion inside fsm_setstart().
+        fsm.statecount = 1;
+
+        unsafe {
+            let mut n = 0;
+
+            fsm_setstart(fsm_ptr, 0);
+            assert_eq!(fsm_getstart(fsm_ptr, &mut n), 1);
+            assert_eq!(n, 0);
+
+            fsm_clearstart(fsm_ptr);
+            assert_eq!(fsm_getstart(fsm_ptr, &mut n), 0);
+        }
+    }
+
+    #[test]
+    fn set_end_works() {
+        let mut fsm = dummy_fsm_new();
+
+        fn make_state() -> State {
+            State {
+                end: false,
+                has_capture_actions: false,
+                visited: false,
+                edges: ptr::null_mut(),
+                epsilons: ptr::null_mut(),
+            }
+        }
+
+        let mut states = vec![make_state(), make_state(), make_state()];
+
+        fsm.states = states.as_mut_ptr();
+        fsm.statecount = 3;
+        fsm.statealloc = 3;
+
+        fsm.set_end(1, true); // yay aliased mutability
+        assert_eq!(fsm.endcount, 1);
+        assert!(states[1].end);
+
+        fsm.set_end(1, false);
+        assert_eq!(fsm.endcount, 0);
+        assert!(!states[1].end);
+    }
+}