Period (#12)

* change periodicity to period
* fix memory leaks

Author: thiennamdinh

CHANGELOG

@@ -7,6 +7,7 @@ The purpose of this changelog is to document new features and breaking changes t
 - Add JSON <-> Scheme interface
 - Separate crypto primitives into separate namespace
 - Add unix time primitive
+- Use explicit period instead of periodicity
 
 --- v1.0.4 (2025.09.14) ---
 

src/config.rs

@@ -30,10 +30,10 @@ pub struct Config {
     #[arg(
         short = 'c',
         long,
-        default_value_t = 0,
-        help = "Power of two determining the period of the step query"
+        default_value_t = 1.0,
+        help = "Number of seconds between each step inquiry"
     )]
-    pub periodicity: i32,
+    pub period: f64,
 }
 
 impl Config {

src/evaluator.rs

@@ -76,16 +76,13 @@ impl Type {
 
 pub fn obj2str(sc: *mut s7_scheme, obj: *mut s7_cell) -> String {
     unsafe {
-        unsafe {
-            let expr = s7_object_to_c_string(sc, obj);
-            let cstr = CStr::from_ptr(expr);
-            let result = match cstr.to_str() {
-                Ok(expr) => expr.to_owned(),
-                Err(_) => format!("(error 'encoding-error \"Failed to encode string\")"),
-            };
-            free(expr as *mut libc::c_void);
-            result
-        }
+        let expr = s7_string(s7_object_to_string(sc, obj, false));
+        let cstr = CStr::from_ptr(expr);
+        let result = match cstr.to_str() {
+            Ok(expr) => expr.to_owned(),
+            Err(_) => format!("(error 'encoding-error \"Failed to encode string\")"),
+        };
+        result
     }
 }
 
@@ -108,24 +105,21 @@ pub fn scheme2json(expression: &str) -> Result<Value, String> {
     // - @hash-table: {"*type/hash-table*": [["a", 6], [53, 199]]}
 
     unsafe {
-        unsafe {
-            let sc: *mut s7_scheme = s7_init();
+        let sc: *mut s7_scheme = s7_init();
 
-            // Parse the expression without evaluating it
-            let c_expr = CString::new(expression).unwrap_or_else(|_| CString::new("()").unwrap());
-            let input_port = s7_open_input_string(sc, c_expr.as_ptr());
-            let s7_obj = s7_read(sc, input_port);
-            s7_close_input_port(sc, input_port);
+        // Parse the expression without evaluating it
+        let c_expr = CString::new(expression).unwrap_or_else(|_| CString::new("()").unwrap());
+        let input_port = s7_open_input_string(sc, c_expr.as_ptr());
+        let s7_obj = s7_read(sc, input_port);
+        s7_close_input_port(sc, input_port);
 
-            let result = s7_obj_to_json(sc, s7_obj);
-            s7_free(sc);
-            result
-        }
+        let result = s7_obj_to_json(sc, s7_obj);
+        s7_free(sc);
+        result
     }
 }
 
 pub fn json2scheme(expression: Value) -> Result<String, String> {
-    unsafe {
         unsafe {
             let sc: *mut s7_scheme = s7_init();
             match json_to_s7_obj(sc, &expression) {
@@ -139,7 +133,6 @@ pub fn json2scheme(expression: Value) -> Result<String, String> {
                     Err(err)
                 }
             }
-        }
     }
 }
 
@@ -162,7 +155,6 @@ impl Evaluator {
 
         primitives_.extend(primitives);
 
-        unsafe {
             unsafe {
                 let sc: *mut s7_scheme = s7_init();
 
@@ -209,7 +201,6 @@ impl Evaluator {
                     sc,
                     primitives: primitives_,
                 }
-            }
         }
     }
 
@@ -232,19 +223,17 @@ impl Evaluator {
 
 impl Drop for Evaluator {
     fn drop(&mut self) {
-        unsafe {
             unsafe {
                 s7_free(self.sc);
             }
-        }
     }
 }
 
 fn primitive_expression_to_byte_vector() -> Primitive {
     unsafe extern "C" fn code(sc: *mut s7_scheme, args: s7_pointer) -> s7_pointer {
         let arg = s7_car(args);
 
-        let s7_c_str = s7_object_to_c_string(sc, arg);
+        let s7_c_str = s7_string(s7_object_to_string(sc, arg, false));
         let c_string = CStr::from_ptr(s7_c_str);
 
         let bv = s7_make_byte_vector(
@@ -256,7 +245,6 @@ fn primitive_expression_to_byte_vector() -> Primitive {
         for (i, b) in c_string.to_bytes().iter().enumerate() {
             s7_byte_vector_set(bv, i as i64, *b);
         }
-        free(s7_c_str as *mut libc::c_void);
         bv
     }
 
@@ -328,7 +316,7 @@ fn primitive_hex_string_to_byte_vector() -> Primitive {
             );
         }
 
-        let s7_c_str = s7_object_to_c_string(sc, arg);
+        let s7_c_str = s7_string(s7_object_to_string(sc, arg, false));
         let hex_string = CStr::from_ptr(s7_c_str)
             .to_str()
             .expect("Failed to convert C string to hex string");
@@ -338,8 +326,6 @@ fn primitive_hex_string_to_byte_vector() -> Primitive {
             .map(|i| u8::from_str_radix(&hex_string[i..i + 2], 16))
             .collect();
 
-        free(s7_c_str as *mut libc::c_void);
-
         match result {
             Ok(result) => {
                 let bv =

src/main.rs

@@ -117,21 +117,19 @@ async fn main() {
     rocket_config.address = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
     rocket_config.limits = Limits::new().limit("string", 1_i32.mebibytes());
 
-    let period = 2_f64.powi(config.periodicity);
-
     if config.step != "" {
         tokio::spawn(async move {
             let mut step = 0;
             let start = ((SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .expect("Failed to get system time")
                 .as_micros() as f64
-                / (period * MICRO))
+                / (config.period * MICRO))
                 .ceil()
-                * (period * MICRO)) as u128;
+                * (config.period * MICRO)) as u128;
 
             loop {
-                let until = start + step * (period * MICRO) as u128;
+                let until = start + step * (config.period * MICRO) as u128;
                 let now = SystemTime::now()
                     .duration_since(UNIX_EPOCH)
                     .expect("Failed to get system time")