refactor: Make rust bindings more rusty

bindings/rust/src/unicorn_const.rs

@@ -14,49 +14,88 @@ pub const MILISECOND_SCALE: u64 = 1_000;
 #[derive(PartialEq, Debug, Clone, Copy)]
 #[allow(clippy::upper_case_acronyms)]
 pub enum uc_error {
-    OK = 0,
-    NOMEM = 1,
-    ARCH = 2,
-    HANDLE = 3,
-    MODE = 4,
-    VERSION = 5,
-    READ_UNMAPPED = 6,
-    WRITE_UNMAPPED = 7,
-    FETCH_UNMAPPED = 8,
-    HOOK = 9,
-    INSN_INVALID = 10,
-    MAP = 11,
-    WRITE_PROT = 12,
-    READ_PROT = 13,
-    FETCH_PROT = 14,
-    ARG = 15,
-    READ_UNALIGNED = 16,
+    OK              = 0,
+    NOMEM           = 1,
+    ARCH            = 2,
+    HANDLE          = 3,
+    MODE            = 4,
+    VERSION         = 5,
+    READ_UNMAPPED   = 6,
+    WRITE_UNMAPPED  = 7,
+    FETCH_UNMAPPED  = 8,
+    HOOK            = 9,
+    INSN_INVALID    = 10,
+    MAP             = 11,
+    WRITE_PROT      = 12,
+    READ_PROT       = 13,
+    FETCH_PROT      = 14,
+    ARG             = 15,
+    READ_UNALIGNED  = 16,
     WRITE_UNALIGNED = 17,
     FETCH_UNALIGNED = 18,
-    HOOK_EXIST = 19,
-    RESOURCE = 20,
-    EXCEPTION = 21,
+    HOOK_EXIST      = 19,
+    RESOURCE        = 20,
+    EXCEPTION       = 21,
+}
+
+impl uc_error {
+    /// Calls op if the result is Ok, otherwise returns the Err value of self.
+    /// This function can be used for control flow based on Result values.
+    pub fn and_then<U, F: FnOnce() -> Result<U, uc_error>>(
+        self,
+        op: F,
+    ) -> Result<U, uc_error> {
+        if let Self::OK = self {
+            op()
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Returns res if the result is Ok, otherwise returns the Err value of self.
+    /// Arguments passed to and are eagerly evaluated; if you are passing the result
+    /// of a function call, it is recommended to use and_then, which is lazily evaluated.
+    pub fn and<U>(
+        self,
+        res: Result<U, uc_error>,
+    ) -> Result<U, uc_error> {
+        if let Self::OK = self {
+            res
+        } else {
+            Err(self)
+        }
+    }
+}
+
+impl From<uc_error> for Result<(), uc_error> {
+    fn from(value: uc_error) -> Self {
+        if let uc_error::OK = value {
+            Ok(())
+        } else {
+            Err(value)
+        }
+    }
 }
 
 #[repr(C)]
 #[derive(PartialEq, Debug, Clone, Copy)]
 pub enum MemType {
-    READ = 16,
-    WRITE = 17,
-    FETCH = 18,
-    READ_UNMAPPED = 19,
+    READ           = 16,
+    WRITE          = 17,
+    FETCH          = 18,
+    READ_UNMAPPED  = 19,
     WRITE_UNMAPPED = 20,
     FETCH_UNMAPPED = 21,
-    WRITE_PROT = 22,
-    READ_PROT = 23,
-    FETCH_PROT = 24,
-    READ_AFTER = 25,
+    WRITE_PROT     = 22,
+    READ_PROT      = 23,
+    FETCH_PROT     = 24,
+    READ_AFTER     = 25,
 }
 
 #[repr(C)]
 #[derive(PartialEq, Debug, Clone, Copy)]
 pub enum TlbType {
-    CPU = 0,
+    CPU     = 0,
     VIRTUAL = 1,
 }
 
@@ -103,10 +142,10 @@ bitflags! {
 #[derive(PartialEq, Debug, Clone, Copy)]
 #[allow(clippy::upper_case_acronyms)]
 pub enum Query {
-    MODE = 1,
+    MODE      = 1,
     PAGE_SIZE = 2,
-    ARCH = 3,
-    TIMEOUT = 4,
+    ARCH      = 3,
+    TIMEOUT   = 4,
 }
 
 bitflags! {
@@ -132,17 +171,17 @@ pub struct MemRegion {
 #[repr(C)]
 #[derive(PartialEq, Debug, Clone, Copy)]
 pub enum Arch {
-    ARM = 1,
-    ARM64 = 2,
-    MIPS = 3,
-    X86 = 4,
-    PPC = 5,
-    SPARC = 6,
-    M68K = 7,
-    RISCV = 8,
-    S390X = 9,
+    ARM     = 1,
+    ARM64   = 2,
+    MIPS    = 3,
+    X86     = 4,
+    PPC     = 5,
+    SPARC   = 6,
+    M68K    = 7,
+    RISCV   = 8,
+    S390X   = 9,
     TRICORE = 10,
-    MAX = 11,
+    MAX     = 11,
 }
 
 impl TryFrom<usize> for Arch {
@@ -205,7 +244,7 @@ bitflags! {
 pub struct TranslationBlock {
     pub pc: u64,
     pub icount: u16,
-    pub size: u16
+    pub size: u16,
 }
 
 macro_rules! UC_CTL_READ {
@@ -229,21 +268,21 @@ macro_rules! UC_CTL_READ_WRITE {
 #[allow(clippy::upper_case_acronyms)]
 #[repr(u64)]
 pub enum ControlType {
-    UC_CTL_UC_MODE = 0,
+    UC_CTL_UC_MODE      = 0,
     UC_CTL_UC_PAGE_SIZE = 1,
-    UC_CTL_UC_ARCH = 2,
-    UC_CTL_UC_TIMEOUT = 3,
+    UC_CTL_UC_ARCH      = 2,
+    UC_CTL_UC_TIMEOUT   = 3,
     UC_CTL_UC_USE_EXITS = 4,
     UC_CTL_UC_EXITS_CNT = 5,
-    UC_CTL_UC_EXITS = 6,
-    UC_CTL_CPU_MODEL = 7,
+    UC_CTL_UC_EXITS     = 6,
+    UC_CTL_CPU_MODEL    = 7,
     UC_CTL_TB_REQUEST_CACHE = 8,
     UC_CTL_TB_REMOVE_CACHE = 9,
-    UC_CTL_TB_FLUSH = 10,
-    UC_CTL_TLB_FLUSH = 11,
-    UC_CTL_TLB_TYPE = 12,
-    UC_CTL_IO_READ = 1<<31,
-    UC_CTL_IO_WRITE = 1<<30,
+    UC_CTL_TB_FLUSH     = 10,
+    UC_CTL_TLB_FLUSH    = 11,
+    UC_CTL_TLB_TYPE     = 12,
+    UC_CTL_IO_READ      = 1 << 31,
+    UC_CTL_IO_WRITE     = 1 << 30,
 }
 
 #[repr(C)]