rust: Implement Into manually as precaution

ethereum · Mar 19, 2019 · 5802f38 · 5802f38
1 parent 42d6506
commit 5802f38
Showing 1 changed file with 70 additions and 49 deletions.
diff --git a/bindings/rust/evmc-vm/src/lib.rs b/bindings/rust/evmc-vm/src/lib.rs
@@ -10,7 +10,6 @@ pub struct ExecutionResult {
     status: ffi::evmc_status_code,
     gas: i64,
     output: Option<Vec<u8>>,
-    release_fn: Option<unsafe extern "C" fn(*const ffi::evmc_result)>,
     create_addr: Option<ffi::evmc_address>,
 }
 
@@ -22,7 +21,7 @@ impl From<ffi::evmc_result> for ExecutionResult {
             output: if !result.output_data.is_null() {
                 // Pre-allocate a vector.
                 let mut buf: Vec<u8> = Vec::with_capacity(result.output_size);
-                
+
                 // Copy from the C struct's buffer to the vec's buffer.
                 unsafe {
                     std::ptr::copy(result.output_data, buf.as_mut_ptr(), result.output_size);
@@ -32,7 +31,6 @@ impl From<ffi::evmc_result> for ExecutionResult {
             } else {
                 None
             },
-            release_fn: result.release.clone(),
             create_addr: if result.status_code == ffi::evmc_status_code::EVMC_SUCCESS {
                 // NOTE: This field is only Some if the evmc return code is SUCCESS.
                 Some(result.create_address)
@@ -48,7 +46,30 @@ impl From<ffi::evmc_result> for ExecutionResult {
 
         ret
     }
-
+}
+
+impl Into<ffi::evmc_result> for ExecutionResult {
+    fn into(self) -> ffi::evmc_result {
+        let (buffer, len) = if let Some(buf) = self.output {
+            (buf.as_ptr(), buf.len())
+        } else {
+            (std::ptr::null(), 0)
+        };
+
+        ffi::evmc_result {
+            status_code: self.status,
+            gas_left: self.gas,
+            output_data: buffer,
+            output_size: len,
+            release: Some(release_result),
+            create_address: if self.create_addr.is_some() {
+                self.create_addr.unwrap()
+            } else {
+                ffi::evmc_address { bytes: [0u8; 20] }
+            },
+            padding: [0u8; 4],
+        }
+    }
 }
 
 /*
@@ -130,51 +151,51 @@ extern "C" fn release_result(result: *const ffi::evmc_result) {
 mod tests {
     use super::*;
     use evmc_sys as ffi;
-/*
-    #[test]
-    fn constructor() {
-        let result = ExecutionResult::new(
-            ffi::evmc_status_code::EVMC_SUCCESS,
-            420,
-            Some(&[0xde, 0xad, 0xbe, 0xef]),
-        );
-        assert!(result.status() == ffi::evmc_status_code::EVMC_SUCCESS);
-        assert!(result.gasleft() == 420);
-        assert!(result.output().is_some());
-        assert!(result.output().unwrap().len() == 4);
-        assert!(result.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
-    }
+    /*
+        #[test]
+        fn constructor() {
+            let result = ExecutionResult::new(
+                ffi::evmc_status_code::EVMC_SUCCESS,
+                420,
+                Some(&[0xde, 0xad, 0xbe, 0xef]),
+            );
+            assert!(result.status() == ffi::evmc_status_code::EVMC_SUCCESS);
+            assert!(result.gasleft() == 420);
+            assert!(result.output().is_some());
+            assert!(result.output().unwrap().len() == 4);
+            assert!(result.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
+        }
 
-    #[test]
-    fn inner() {
-        let result = ExecutionResult::new(
-            ffi::evmc_status_code::EVMC_SUCCESS,
-            420,
-            Some(&[0xde, 0xad, 0xbe, 0xef]),
-        );
-        let inner = result.into_inner();
-        let back = ExecutionResult::from_boxed(inner);
-        assert!(back.status() == ffi::evmc_status_code::EVMC_SUCCESS);
-        assert!(back.gasleft() == 420);
-        assert!(back.output().is_some());
-        assert!(back.output().unwrap().len() == 4);
-        assert!(back.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
-    }
+        #[test]
+        fn inner() {
+            let result = ExecutionResult::new(
+                ffi::evmc_status_code::EVMC_SUCCESS,
+                420,
+                Some(&[0xde, 0xad, 0xbe, 0xef]),
+            );
+            let inner = result.into_inner();
+            let back = ExecutionResult::from_boxed(inner);
+            assert!(back.status() == ffi::evmc_status_code::EVMC_SUCCESS);
+            assert!(back.gasleft() == 420);
+            assert!(back.output().is_some());
+            assert!(back.output().unwrap().len() == 4);
+            assert!(back.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
+        }
 
-    #[test]
-    fn raw() {
-        let result = ExecutionResult::new(
-            ffi::evmc_status_code::EVMC_SUCCESS,
-            420,
-            Some(&[0xde, 0xad, 0xbe, 0xef]),
-        );
-        let raw = result.into_raw() as *mut ffi::evmc_result;
-        let back = ExecutionResult::from_raw(raw);
-        assert!(back.status() == ffi::evmc_status_code::EVMC_SUCCESS);
-        assert!(back.gasleft() == 420);
-        assert!(back.output().is_some());
-        assert!(back.output().unwrap().len() == 4);
-        assert!(back.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
-    }
-*/
+        #[test]
+        fn raw() {
+            let result = ExecutionResult::new(
+                ffi::evmc_status_code::EVMC_SUCCESS,
+                420,
+                Some(&[0xde, 0xad, 0xbe, 0xef]),
+            );
+            let raw = result.into_raw() as *mut ffi::evmc_result;
+            let back = ExecutionResult::from_raw(raw);
+            assert!(back.status() == ffi::evmc_status_code::EVMC_SUCCESS);
+            assert!(back.gasleft() == 420);
+            assert!(back.output().is_some());
+            assert!(back.output().unwrap().len() == 4);
+            assert!(back.output().unwrap() == &[0xde, 0xad, 0xbe, 0xef]);
+        }
+    */
 }