|
@@ -0,0 +1,210 @@
|
|
|
+use std::convert::Into;
|
|
|
+use ffi_support::HandleError;
|
|
|
+use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
+use num_enum::{TryFromPrimitive, IntoPrimitive};
|
|
|
+use strum_macros::Display;
|
|
|
+use core::fmt::Debug;
|
|
|
+use crate::define_err_enum;
|
|
|
+use crate::proc::ZRFUProcResultCode;
|
|
|
+
|
|
|
+pub static DEBUG_MODE: AtomicBool = AtomicBool::new(false);
|
|
|
+
|
|
|
+
|
|
|
+#[derive(Debug, IntoPrimitive)]
|
|
|
+#[repr(u32)]
|
|
|
+pub enum ZRFUErrPrefix {
|
|
|
+ Generic = 0x00_00_0000,
|
|
|
+ BytesVec = 0x00_01_0000,
|
|
|
+ ProcCaller = 0x00_02_0000,
|
|
|
+ ProcCallBasic = 0x01_01_0000,
|
|
|
+ ProcCallInput = 0x01_02_0000,
|
|
|
+ ProcCallReturn = 0x01_03_0000,
|
|
|
+ ProcCalling = 0x0201_0000,
|
|
|
+}
|
|
|
+
|
|
|
+impl ZRFUErrPrefix {
|
|
|
+ pub const fn define(self, gtype: ZRFUErrBehavior) -> u32 {
|
|
|
+ unsafe {
|
|
|
+ let prefix = *((&self as *const ZRFUErrPrefix) as *const u32);
|
|
|
+ let behavior = *((>ype as *const ZRFUErrBehavior) as *const u32);
|
|
|
+ prefix | behavior
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[derive(Debug, IntoPrimitive)]
|
|
|
+#[repr(u32)]
|
|
|
+pub enum ZRFUErrBehavior {
|
|
|
+ Ok = 0x0000,
|
|
|
+
|
|
|
+ NullPointerHandle = 0x0001,
|
|
|
+ NullHandle = 0x0002,
|
|
|
+ InvalidHandle = 0x0003,
|
|
|
+ StaleVersion = 0x0004,
|
|
|
+ IndexPastEnd = 0x0005,
|
|
|
+ WrongMap = 0x0006,
|
|
|
+ NullPointerBufferPtr = 0x0007,
|
|
|
+ IOError = 0x0008,
|
|
|
+ CBORDecodeError = 0x0009,
|
|
|
+ ProcNotFound = 0x000A,
|
|
|
+ ProcRegistryNameError = 0x000B,
|
|
|
+ ProcCallerNotInit = 0x000C,
|
|
|
+ ProcCallerRepeatlyInit = 0x000D,
|
|
|
+ ArgsCBORDecodeError = 0x000E,
|
|
|
+ ReturnCBOREncodeError = 0x000F,
|
|
|
+ NoDataToEncodeCBOR = 0x0010,
|
|
|
+ NoArgsNeed = 0x011,
|
|
|
+ NoReturnProvided = 0x0012,
|
|
|
+ CanNotGetArgs = 0x0013,
|
|
|
+}
|
|
|
+
|
|
|
+impl ZRFUErrBehavior {
|
|
|
+ pub fn to_errno(self, prefix: ZRFUErrPrefix) -> ZRFUErrNo {
|
|
|
+ let behavior: u32 = (self as ZRFUErrBehavior).into();
|
|
|
+ let prefu32: u32 = prefix.into();
|
|
|
+ let v = behavior | prefu32;
|
|
|
+ let res = ZRFUErrNo::try_from(v);
|
|
|
+ match res {
|
|
|
+ Ok(t) => t,
|
|
|
+ Err(_) => {
|
|
|
+ let fbv = ZRFUErrNo::try_from(behavior);
|
|
|
+ match fbv {
|
|
|
+ Ok(t) => t,
|
|
|
+ Err(_) => ZRFUErrNo::Unknown,
|
|
|
+ }
|
|
|
+ },
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn with_complex_error(self, err_msg: &str) -> Self {
|
|
|
+ let dbg = DEBUG_MODE.load(Ordering::Relaxed);
|
|
|
+ if dbg {
|
|
|
+ println!("ZRFU_Debug: Error: {}", err_msg);
|
|
|
+ }
|
|
|
+ self
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*#[derive(TryFromPrimitive, IntoPrimitive, Display)]
|
|
|
+#[repr(u32)]
|
|
|
+pub enum ZRFUErrNo {
|
|
|
+ OK = 0x00000000,
|
|
|
+ Unknown = 0x4000FFFF,
|
|
|
+
|
|
|
+}
|
|
|
+*/
|
|
|
+
|
|
|
+define_err_enum!{
|
|
|
+ NullPointerHandle for Generic as Generic_NullPointerHandle,
|
|
|
+ NullHandle for Generic as Generic_NullHandle,
|
|
|
+ InvalidHandle for Generic as Generic_InvalidHandle,
|
|
|
+ StaleVersion for Generic as Generic_StaleVersion,
|
|
|
+ IndexPastEnd for Generic as Generic_IndexPastEnd,
|
|
|
+ WrongMap for Generic as Generic_WrongMap,
|
|
|
+ NullPointerBufferPtr for Generic as Generic_NullPointerBufferPtr,
|
|
|
+ IOError for Generic as Generic_IOError,
|
|
|
+
|
|
|
+ NullPointerHandle for BytesVec as BytesVec_NullPointerHandle,
|
|
|
+ NullHandle for BytesVec as BytesVec_NullHandle,
|
|
|
+ InvalidHandle for BytesVec as BytesVec_InvalidHandle,
|
|
|
+ StaleVersion for BytesVec as BytesVec_StaleVersion,
|
|
|
+ IndexPastEnd for BytesVec as BytesVec_IndexPastEnd,
|
|
|
+ WrongMap for BytesVec as BytesVec_WrongMap,
|
|
|
+ NullPointerBufferPtr for BytesVec as BytesVec_NullPointerBufferPtr,
|
|
|
+ IOError for BytesVec as BytesVec_IOError,
|
|
|
+
|
|
|
+ ProcCallerNotInit for ProcCaller as ProcCaller_ProcCallerNotInit,
|
|
|
+ ProcCallerRepeatlyInit for ProcCaller as ProcCaller_ProcCallerRepeatlyInit,
|
|
|
+
|
|
|
+ NullPointerHandle for ProcCallBasic as ProcCallBasic_NullPointerHandle,
|
|
|
+ NullHandle for ProcCallBasic as ProcCallBasic_NullHandle,
|
|
|
+ InvalidHandle for ProcCallBasic as ProcCallBasic_InvalidHandle,
|
|
|
+ StaleVersion for ProcCallBasic as ProcCallBasic_StaleVersion,
|
|
|
+ IndexPastEnd for ProcCallBasic as ProcCallBasic_IndexPastEnd,
|
|
|
+ WrongMap for ProcCallBasic as ProcCallBasic_WrongMap,
|
|
|
+ NullPointerBufferPtr for ProcCallBasic as ProcCallBasic_NullPointerBufferPtr,
|
|
|
+ IOError for ProcCallBasic as ProcCallBasic_IOError,
|
|
|
+ CBORDecodeError for ProcCallBasic as ProcCallBasic_CBORDecodeError,
|
|
|
+ ProcNotFound for ProcCallBasic as ProcCallBasic_ProcNotFound,
|
|
|
+ ProcRegistryNameError for ProcCallBasic as ProcCallBasic_ProcRegistryNameError,
|
|
|
+
|
|
|
+ NullHandle for ProcCallInput as ProcCallInput_NullHandle,
|
|
|
+ InvalidHandle for ProcCallInput as ProcCallInput_InvalidHandle,
|
|
|
+ StaleVersion for ProcCallInput as ProcCallInput_StaleVersion,
|
|
|
+ IndexPastEnd for ProcCallInput as ProcCallInput_IndexPastEnd,
|
|
|
+ WrongMap for ProcCallInput as ProcCallInput_WrongMap,
|
|
|
+ NullPointerBufferPtr for ProcCallInput as ProcCallInput_NullPointerBufferPtr,
|
|
|
+ IOError for ProcCallInput as ProcCallInput_IOError,
|
|
|
+ ArgsCBORDecodeError for ProcCallInput as ProcCallInput_ArgsCBORDecodeError,
|
|
|
+
|
|
|
+ NullHandle for ProcCallReturn as ProcCallReturn_NullHandle,
|
|
|
+ InvalidHandle for ProcCallReturn as ProcCallReturn_InvalidHandle,
|
|
|
+ StaleVersion for ProcCallReturn as ProcCallReturn_StaleVersion,
|
|
|
+ IndexPastEnd for ProcCallReturn as ProcCallReturn_IndexPastEnd,
|
|
|
+ WrongMap for ProcCallReturn as ProcCallReturn_WrongMap,
|
|
|
+ NullPointerBufferPtr for ProcCallReturn as ProcCallReturn_NullPointerBufferPtr,
|
|
|
+ IOError for ProcCallReturn as ProcCallReturn_IOError,
|
|
|
+ ReturnCBOREncodeError for ProcCallReturn as ProcCallReturn_ReturnCBOREncodeError,
|
|
|
+ NoDataToEncodeCBOR for ProcCallReturn as ProcCallReturn_NoDataToEncodeCBOR,
|
|
|
+
|
|
|
+ NoArgsNeed for ProcCalling as ProcCalling_NoArgsNeed,
|
|
|
+ NoReturnProvided for ProcCalling as ProcCalling_NoReturnProvided,
|
|
|
+ CanNotGetArgs for ProcCalling as ProcCalling_CanNotGetArgs
|
|
|
+}
|
|
|
+
|
|
|
+impl ZRFUErrNo {
|
|
|
+ pub fn get_errno(self) -> u32 {
|
|
|
+ (self as ZRFUErrNo).into()
|
|
|
+ }
|
|
|
+ pub fn get_return_code(self) -> i32 {
|
|
|
+ let ec : u32 = (self as ZRFUErrNo).into();
|
|
|
+ -(ec as i32)
|
|
|
+ }
|
|
|
+ pub fn from_return_code(v : i32) -> ZRFUErrNo {
|
|
|
+ if v < 0 {
|
|
|
+ let res = ZRFUErrNo::try_from((-v) as u32);
|
|
|
+ match res {
|
|
|
+ Ok(n) => n,
|
|
|
+ Err(_) => ZRFUErrNo::Unknown,
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ ZRFUErrNo::OK
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn with_complex_error(self, err_msg: &str) -> Self {
|
|
|
+ let dbg = DEBUG_MODE.load(Ordering::Relaxed);
|
|
|
+ if dbg {
|
|
|
+ println!("ZRFU_Debug: Error: {}", err_msg);
|
|
|
+ }
|
|
|
+ self
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+impl From<HandleError> for ZRFUErrBehavior {
|
|
|
+ fn from(he: HandleError) -> Self {
|
|
|
+ match he {
|
|
|
+ HandleError::NullHandle => Self::NullHandle,
|
|
|
+ HandleError::InvalidHandle => Self::InvalidHandle,
|
|
|
+ HandleError::StaleVersion => Self::StaleVersion,
|
|
|
+ HandleError::IndexPastEnd => Self::IndexPastEnd,
|
|
|
+ HandleError::WrongMap => Self::WrongMap,
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+impl From<ZRFUProcResultCode> for ZRFUErrBehavior {
|
|
|
+ fn from(value: ZRFUProcResultCode) -> Self {
|
|
|
+ match value {
|
|
|
+ ZRFUProcResultCode::Ok => ZRFUErrBehavior::Ok,
|
|
|
+ ZRFUProcResultCode::NoArgsNeed => ZRFUErrBehavior::NoArgsNeed,
|
|
|
+ ZRFUProcResultCode::NoReturnProvided => ZRFUErrBehavior::NoReturnProvided,
|
|
|
+ ZRFUProcResultCode::ArgsCBORDecodeError(s) => ZRFUErrBehavior::ArgsCBORDecodeError
|
|
|
+ .with_complex_error(s.as_str()),
|
|
|
+ ZRFUProcResultCode::CanNotGetArgs => ZRFUErrBehavior::CanNotGetArgs,
|
|
|
+ ZRFUProcResultCode::ReturnCBOREncodeError(s) => ZRFUErrBehavior::ReturnCBOREncodeError
|
|
|
+ .with_complex_error(s.as_str()),
|
|
|
+ ZRFUProcResultCode::NoDataToEncodeCBOR => ZRFUErrBehavior::NoDataToEncodeCBOR,
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|