SarasasChipWorkshop/wfassoc
1
0
Fork 0
Code Activity

refacotr: use omrf to replace all wheels I invented

Browse Source
This commit is contained in:
yyc12345
2026-08-15 09:50:15 +08:00
parent 64ccc083fb
commit a595d7e6e7
10 changed files with 279 additions and 731 deletions
Download Patch File Download Diff File Expand all files Collapse all files
wfassoc-cdylib/src/lib.rs
+207 -354
View File
@@ -1,10 +1,8 @@
mod cstr_ffi;
mod ffi_types;
mod last_error;
mod object_pool;
mod wrapper;
use object_pool::ObjectPool;
use std::sync::{LazyLock, RwLock};
use sarasacw_omrf::object_pool::ObjectPool;
use sarasacw_omrf::{cffi_wrapper, cstr_ffi, in_param_ty, last_error, object_pool, out_param_ty};
use std::sync::LazyLock;
use thiserror::Error as TeError;
use wfassoc::highlevel::{Program, Schema};
@@ -12,7 +10,7 @@ use wfassoc::highlevel::{Program, Schema};
/// Error occurs in this crate.
#[derive(Debug, TeError)]
enum Error {
enum UserError {
/// Error when operating Schema.
#[error("wfassoc error: {0}")]
Schema(#[from] wfassoc::highlevel::SchemaError),
@@ -33,180 +31,65 @@ enum Error {
/// Error occurs when checking enum value
#[error("the enumeration value provided to FFI function is out of its range")]
EnumOutOfRange,
/// Error when manipulating with poison RwLock
#[error("concurrency error: RwLock is poisonous")]
PoisonRwLock,
}
impl From<UserError> for WFError {
fn from(_: UserError) -> Self {
WFERROR_ERR
}
}
/// Result type used in this crate.
type Result<T> = std::result::Result<T, Error>;
type Result<T> = std::result::Result<T, UserError>;
// endregion
// region: Macros
macro_rules! in_param_ty {
($t:ty) => {
$t
};
}
macro_rules! out_param_ty {
($t:ty) => {
*mut $t
};
}
macro_rules! set_out_param {
($lhs:expr, $rhs:expr) => {
unsafe { *$lhs = $rhs };
};
}
macro_rules! resolve_enum {
($t:ty, $v:expr) => {
<$t>::try_from($v).map_err(|_| Error::EnumOutOfRange)
<$t>::try_from($v).map_err(|_| UserError::EnumOutOfRange)
};
}
macro_rules! pull_reader {
($pool:expr) => {
$pool.read().map_err(|_| Error::PoisonRwLock)
};
}
macro_rules! pull_writer {
($pool:expr) => {
$pool.write().map_err(|_| Error::PoisonRwLock)
};
}
/// Macro to wrap inner function execution with standard error handling pattern.
///
/// For functions with no output parameter and no input parameters:
/// ```ignore
/// cffi_wrapper!(|| {
/// // inner function body returning Result<()>
/// });
/// ```
///
/// For functions with no output parameter and with input parameters:
/// ```ignore
/// cffi_wrapper!(|param1: Type1, param2: Type2| {
/// // inner function body using param1, param2 returning Result<()>
/// });
/// ```
///
/// For functions with one output parameter and no input parameters:
/// ```ignore
/// cffi_wrapper!(|| -> (out_param, OutType) {
/// // inner function body returning Result<T>
/// });
/// ```
///
/// For functions with one output parameter and with input parameters:
/// ```ignore
/// cffi_wrapper!(|param1: Type1| -> (out_param, OutType) {
/// // inner function body using param1 returning Result<T>
/// });
/// ```
macro_rules! cffi_wrapper {
// Case with output parameter and input parameters
(|$($param:ident: $param_ty:ty),*| -> ($out_param:ident: $out_param_ty:ty) $inner_body:block) => {{
fn inner($($param: $param_ty),*) -> Result<$out_param_ty> $inner_body
match inner($($param),*) {
Ok(rv) => {
set_out_param!($out_param, rv);
last_error::clear_last_error();
true
}
Err(e) => {
last_error::set_last_error(e.to_string().as_str());
false
}
}
}};
// Case with output parameter and no input parameters
(|| -> ($out_param:ident: $out_param_ty:ty) $inner_body:block) => {{
fn inner() -> Result<$out_param_ty> $inner_body
match inner() {
Ok(rv) => {
set_out_param!($out_param, rv);
last_error::clear_last_error();
true
}
Err(e) => {
last_error::set_last_error(e.to_string().as_str());
false
}
}
}};
// Case without output parameter but with input parameters
(|$($param:ident: $param_ty:ty),*| $inner_body:block) => {{
fn inner($($param: $param_ty),*) -> Result<()> $inner_body
match inner($($param),*) {
Ok(_) => {
last_error::clear_last_error();
true
}
Err(e) => {
last_error::set_last_error(e.to_string().as_str());
false
}
}
}};
// Case without output parameter and no input parameters
(|| $inner_body:block) => {{
fn inner() -> Result<()> $inner_body
match inner() {
Ok(_) => {
last_error::clear_last_error();
true
}
Err(e) => {
last_error::set_last_error(e.to_string().as_str());
false
}
}
}};
}
// endregion
// region: Object Pools
static SCHEMA_POOL: LazyLock<RwLock<ObjectPool<Schema>>> =
LazyLock::new(|| RwLock::new(ObjectPool::new()));
struct State {
schema_pool: ObjectPool<Schema>,
program_pool: ObjectPool<Program>,
ext_status_pool: ObjectPool<wfassoc::highlevel::ProgramExtStatus>,
self_ext_status_pool: ObjectPool<wfassoc::highlevel::ProgramSelfExtStatus>,
icon_rc_pool: ObjectPool<wfassoc::win32::concept::IconRc>,
}
static PROGRAM_POOL: LazyLock<RwLock<ObjectPool<Program>>> =
LazyLock::new(|| RwLock::new(ObjectPool::new()));
impl State {
fn new() -> Self {
Self {
schema_pool: ObjectPool::new(),
program_pool: ObjectPool::new(),
ext_status_pool: ObjectPool::new(),
self_ext_status_pool: ObjectPool::new(),
icon_rc_pool: ObjectPool::new(),
}
}
}
static EXT_STATUS_POOL: LazyLock<RwLock<ObjectPool<wfassoc::highlevel::ProgramExtStatus>>> =
LazyLock::new(|| RwLock::new(ObjectPool::new()));
static SELF_EXT_STATUS_POOL: LazyLock<
RwLock<ObjectPool<wfassoc::highlevel::ProgramSelfExtStatus>>,
> = LazyLock::new(|| RwLock::new(ObjectPool::new()));
static ICON_RC_POOL: LazyLock<RwLock<ObjectPool<wfassoc::win32::concept::IconRc>>> =
LazyLock::new(|| RwLock::new(ObjectPool::new()));
static CONTEXT: LazyLock<State> = LazyLock::new(|| State::new());
// endregion
// region: Exposed Types
pub use ffi_types::{
CStyleString as WFCString, HICON as WFHICON, Scope as WFScope, View as WFView,
};
pub use ffi_types::{INVALID_HICON as WF_INVALID_HICON, INVALID_INDEX as WF_INVALID_INDEX};
pub use object_pool::Token as WFToken;
pub use last_error::CERROR_OK as WFERROR_OK;
pub use last_error::CError as WFError;
pub const WFERROR_ERR: WFError = 1;
pub use cstr_ffi::CStrPtr as WFStrPtr;
pub use object_pool::{INVALID_TOKEN as WF_INVALID_TOKEN, Token as WFToken};
pub use wrapper::{HICON as WFHICON, Scope as WFScope, View as WFView};
pub use wrapper::{INVALID_HICON as WF_INVALID_HICON, INVALID_INDEX as WF_INVALID_INDEX};
// endregion
@@ -215,67 +98,37 @@ pub use object_pool::Token as WFToken;
// region: Facilities
#[unsafe(no_mangle)]
pub extern "C" fn WFStartup() -> bool {
// Initialize all pool by fetching writer from them
cffi_wrapper!(|| {
let _pool = pull_writer!(SCHEMA_POOL)?;
let _pool = pull_writer!(PROGRAM_POOL)?;
let _pool = pull_writer!(EXT_STATUS_POOL)?;
let _pool = pull_writer!(SELF_EXT_STATUS_POOL)?;
let _pool = pull_writer!(ICON_RC_POOL)?;
Ok(())
pub extern "C" fn WFGetLastError() -> WFStrPtr {
last_error::get_error_message()
}
// endregion
// region: Global Functions
#[unsafe(no_mangle)]
pub extern "C" fn WFHasPrivilege(out_has: out_param_ty!(bool)) -> WFError {
cffi_wrapper!(|| -> (out_has: bool) {
Ok(wfassoc::win32::utilities::has_privilege())
})
}
#[unsafe(no_mangle)]
pub extern "C" fn WFShutdown() -> bool {
// Free all pool stored objects
cffi_wrapper!(|| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
pool.clear();
let mut pool = pull_writer!(PROGRAM_POOL)?;
pool.clear();
let mut pool = pull_writer!(EXT_STATUS_POOL)?;
pool.clear();
let mut pool = pull_writer!(SELF_EXT_STATUS_POOL)?;
pool.clear();
let mut pool = pull_writer!(ICON_RC_POOL)?;
pool.clear();
Ok(())
})
}
#[unsafe(no_mangle)]
pub extern "C" fn WFGetLastError() -> WFCString {
last_error::get_last_error()
}
#[unsafe(no_mangle)]
pub extern "C" fn WFHasPrivilege() -> bool {
wfassoc::win32::utilities::has_privilege()
}
#[unsafe(no_mangle)]
pub extern "C" fn WFInvalidToken() -> WFToken {
object_pool::invalid_token()
}
// endregion
// region: Schema
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaCreate(out_schema: out_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFSchemaCreate(out_schema: out_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|| -> (out_schema: WFToken) {
let mut pool = pull_writer!(SCHEMA_POOL)?;
Ok(pool.allocate(Schema::new())?)
let pool = &CONTEXT.schema_pool;
Ok(pool.allocate(Schema::new()))
})
}
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|in_schema: WFToken| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let pool = &CONTEXT.schema_pool;
Ok(pool.free(in_schema)?)
})
}
@@ -283,11 +136,11 @@ pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(WFToken)) -> bool {
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetIdentifier(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_identifier(cstr_ffi::parse_ffi_string(in_value)?);
Ok(())
})
@@ -296,11 +149,11 @@ pub extern "C" fn WFSchemaSetIdentifier(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetPath(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_path(cstr_ffi::parse_ffi_string(in_value)?);
Ok(())
})
@@ -309,11 +162,11 @@ pub extern "C" fn WFSchemaSetPath(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetClsid(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_clsid(cstr_ffi::parse_ffi_string(in_value)?);
Ok(())
})
@@ -322,17 +175,17 @@ pub extern "C" fn WFSchemaSetClsid(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetName(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let name = if in_value.is_null() {
None
} else {
Some(cstr_ffi::parse_ffi_string(in_value)?)
};
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_name(name);
Ok(())
})
@@ -341,17 +194,17 @@ pub extern "C" fn WFSchemaSetName(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetIcon(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let icon = if in_value.is_null() {
None
} else {
Some(cstr_ffi::parse_ffi_string(in_value)?)
};
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_icon(icon);
Ok(())
})
@@ -360,17 +213,17 @@ pub extern "C" fn WFSchemaSetIcon(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetBehavior(
in_schema: in_param_ty!(WFToken),
in_value: in_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_schema: WFToken, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
let behavior = if in_value.is_null() {
None
} else {
Some(cstr_ffi::parse_ffi_string(in_value)?)
};
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.set_behavior(behavior);
Ok(())
})
@@ -379,13 +232,13 @@ pub extern "C" fn WFSchemaSetBehavior(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddStr(
in_schema: in_param_ty!(WFToken),
in_name: in_param_ty!(WFCString),
in_value: in_param_ty!(WFCString),
) -> bool {
in_name: in_param_ty!(WFStrPtr),
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(
|in_schema: WFToken, in_name: WFCString, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
|in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.add_str(
cstr_ffi::parse_ffi_string(in_name)?,
cstr_ffi::parse_ffi_string(in_value)?,
@@ -398,13 +251,13 @@ pub extern "C" fn WFSchemaAddStr(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddIcon(
in_schema: in_param_ty!(WFToken),
in_name: in_param_ty!(WFCString),
in_value: in_param_ty!(WFCString),
) -> bool {
in_name: in_param_ty!(WFStrPtr),
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(
|in_schema: WFToken, in_name: WFCString, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
|in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.add_icon(
cstr_ffi::parse_ffi_string(in_name)?,
cstr_ffi::parse_ffi_string(in_value)?,
@@ -417,13 +270,13 @@ pub extern "C" fn WFSchemaAddIcon(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddBehavior(
in_schema: in_param_ty!(WFToken),
in_name: in_param_ty!(WFCString),
in_value: in_param_ty!(WFCString),
) -> bool {
in_name: in_param_ty!(WFStrPtr),
in_value: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(
|in_schema: WFToken, in_name: WFCString, in_value: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
|in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.add_behavior(
cstr_ffi::parse_ffi_string(in_name)?,
cstr_ffi::parse_ffi_string(in_value)?,
@@ -436,18 +289,18 @@ pub extern "C" fn WFSchemaAddBehavior(
#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddExt(
in_schema: in_param_ty!(WFToken),
in_ext: in_param_ty!(WFCString),
in_ext_name: in_param_ty!(WFCString),
in_ext_icon: in_param_ty!(WFCString),
in_ext_behavior: in_param_ty!(WFCString),
) -> bool {
in_ext: in_param_ty!(WFStrPtr),
in_ext_name: in_param_ty!(WFStrPtr),
in_ext_icon: in_param_ty!(WFStrPtr),
in_ext_behavior: in_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_schema: WFToken,
in_ext: WFCString,
in_ext_name: WFCString,
in_ext_icon: WFCString,
in_ext_behavior: WFCString| {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let schema = pool.get_mut(in_schema)?;
in_ext: WFStrPtr,
in_ext_name: WFStrPtr,
in_ext_icon: WFStrPtr,
in_ext_behavior: WFStrPtr| {
let pool = &CONTEXT.schema_pool;
let mut schema = pool.get_mut(in_schema)?;
schema.add_ext(
cstr_ffi::parse_ffi_string(in_ext)?,
cstr_ffi::parse_ffi_string(in_ext_name)?,
@@ -466,21 +319,21 @@ pub extern "C" fn WFSchemaAddExt(
pub extern "C" fn WFProgramCreate(
in_schema: in_param_ty!(WFToken),
out_program: out_param_ty!(WFToken),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_schema: WFToken| -> (out_program: WFToken) {
let mut pool = pull_writer!(SCHEMA_POOL)?;
let pool = &CONTEXT.schema_pool;
let schema = pool.pop(in_schema)?;
let mut pool = pull_writer!(PROGRAM_POOL)?;
let pool = &CONTEXT.program_pool;
let program = Program::new(schema)?;
Ok(pool.allocate(program)?)
Ok(pool.allocate(program))
})
}
#[unsafe(no_mangle)]
pub extern "C" fn WFProgramDestroy(in_program: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFProgramDestroy(in_program: in_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|in_program: WFToken| {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let pool = &CONTEXT.program_pool;
Ok(pool.free(in_program)?)
})
}
@@ -488,15 +341,14 @@ pub extern "C" fn WFProgramDestroy(in_program: in_param_ty!(WFToken)) -> bool {
#[unsafe(no_mangle)]
pub extern "C" fn WFProgramResolveName(
in_program: in_param_ty!(WFToken),
out_name: out_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_program: WFToken| -> (out_name: WFCString) {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
out_name: out_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_program: WFToken| -> (out_name: WFStrPtr) {
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
let name = program.resolve_name()?;
cstr_ffi::set_ffi_string(&name)?;
Ok(cstr_ffi::get_ffi_string())
Ok(cstr_ffi::push_ffi_string(&name)?)
})
}
@@ -504,14 +356,14 @@ pub extern "C" fn WFProgramResolveName(
pub extern "C" fn WFProgramResolveIcon(
in_program: in_param_ty!(WFToken),
out_icon_rc: out_param_ty!(WFToken),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken| -> (out_icon_rc: WFToken) {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
let icon = program.resolve_icon()?;
let mut pool = pull_writer!(ICON_RC_POOL)?;
Ok(pool.allocate(icon)?)
let pool = &CONTEXT.icon_rc_pool;
Ok(pool.allocate(icon))
})
}
@@ -519,10 +371,10 @@ pub extern "C" fn WFProgramResolveIcon(
pub extern "C" fn WFProgramExtsLen(
in_program: in_param_ty!(WFToken),
out_len: out_param_ty!(usize),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken| -> (out_len: usize) {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
Ok(program.exts_len())
})
}
@@ -530,12 +382,12 @@ pub extern "C" fn WFProgramExtsLen(
#[unsafe(no_mangle)]
pub extern "C" fn WFProgramFindExt(
in_program: in_param_ty!(WFToken),
in_body: in_param_ty!(WFCString),
in_body: in_param_ty!(WFStrPtr),
out_index: out_param_ty!(usize),
) -> bool {
cffi_wrapper!(|in_program: WFToken, in_body: WFCString| -> (out_index: usize) {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_body: WFStrPtr| -> (out_index: usize) {
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
let body = cstr_ffi::parse_ffi_string(in_body)?;
let index = match program.find_ext(body) {
@@ -551,14 +403,14 @@ pub extern "C" fn WFProgramResolveExt(
in_program: in_param_ty!(WFToken),
in_index: in_param_ty!(usize),
out_self_ext_status: out_param_ty!(WFToken),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_index: usize| -> (out_self_ext_status: WFToken) {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
let self_ext_status = program.resolve_ext(in_index)?;
let mut pool = pull_writer!(SELF_EXT_STATUS_POOL)?;
let token = pool.allocate(self_ext_status)?;
let pool = &CONTEXT.self_ext_status_pool;
let token = pool.allocate(self_ext_status);
Ok(token)
})
}
@@ -567,11 +419,12 @@ pub extern "C" fn WFProgramResolveExt(
pub extern "C" fn WFProgramRegister(
in_program: in_param_ty!(WFToken),
in_scope: in_param_ty!(u32),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_scope: u32| {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let scope = resolve_enum!(WFScope, in_scope)?;
let pool = &CONTEXT.program_pool;
let mut program = pool.get_mut(in_program)?;
program.register(scope.into())?;
Ok(())
})
@@ -581,11 +434,12 @@ pub extern "C" fn WFProgramRegister(
pub extern "C" fn WFProgramUnregister(
in_program: in_param_ty!(WFToken),
in_scope: in_param_ty!(u32),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_scope: u32| {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let scope = resolve_enum!(WFScope, in_scope)?;
let pool = &CONTEXT.program_pool;
let mut program = pool.get_mut(in_program)?;
program.unregister(scope.into())?;
Ok(())
})
@@ -596,11 +450,12 @@ pub extern "C" fn WFProgramIsRegistered(
in_program: in_param_ty!(WFToken),
in_scope: in_param_ty!(u32),
out_is_registered: out_param_ty!(bool),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_scope: u32| -> (out_is_registered: bool) {
let pool = pull_reader!(PROGRAM_POOL)?;
let program = pool.get(in_program)?;
let scope = resolve_enum!(WFScope, in_scope)?;
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
Ok(program.is_registered(scope.into())?)
})
}
@@ -610,11 +465,12 @@ pub extern "C" fn WFProgramLinkExt(
in_program: in_param_ty!(WFToken),
in_scope: in_param_ty!(u32),
in_index: in_param_ty!(usize),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_scope: u32, in_index: usize| {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let scope = resolve_enum!(WFScope, in_scope)?;
let pool = &CONTEXT.program_pool;
let mut program = pool.get_mut(in_program)?;
program.link_ext(scope.into(), in_index)?;
Ok(())
})
@@ -625,11 +481,12 @@ pub extern "C" fn WFProgramUnlinkExt(
in_program: in_param_ty!(WFToken),
in_scope: in_param_ty!(u32),
in_index: in_param_ty!(usize),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_scope: u32, in_index: usize| {
let mut pool = pull_writer!(PROGRAM_POOL)?;
let program = pool.get_mut(in_program)?;
let scope = resolve_enum!(WFScope, in_scope)?;
let pool = &CONTEXT.program_pool;
let mut program = pool.get_mut(in_program)?;
program.unlink_ext(scope.into(), in_index)?;
Ok(())
})
@@ -641,19 +498,19 @@ pub extern "C" fn WFProgramQueryExt(
in_view: in_param_ty!(u32),
in_index: in_param_ty!(usize),
out_ext_status: out_param_ty!(WFToken),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_program: WFToken, in_view: u32, in_index: usize| -> (out_ext_status: WFToken) {
let pool = pull_reader!(PROGRAM_POOL)?;
let program = pool.get(in_program)?;
let view = resolve_enum!(WFView, in_view)?;
let pool = &CONTEXT.program_pool;
let program = pool.get(in_program)?;
let ext_status = program.query_ext(view.into(), in_index)?;
let token = match ext_status {
Some(ext_status) => {
let mut pool = pull_writer!(EXT_STATUS_POOL)?;
pool.allocate(ext_status)?
let pool = &CONTEXT.ext_status_pool;
pool.allocate(ext_status)
},
None => object_pool::invalid_token(),
None => WF_INVALID_TOKEN,
};
Ok(token)
})
@@ -664,9 +521,9 @@ pub extern "C" fn WFProgramQueryExt(
// region: Extension Status
#[unsafe(no_mangle)]
pub extern "C" fn WFExtStatusDestroy(in_ext_status: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFExtStatusDestroy(in_ext_status: in_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|in_ext_status: WFToken| {
let mut pool = pull_writer!(EXT_STATUS_POOL)?;
let pool = &CONTEXT.ext_status_pool;
Ok(pool.free(in_ext_status)?)
})
}
@@ -674,14 +531,13 @@ pub extern "C" fn WFExtStatusDestroy(in_ext_status: in_param_ty!(WFToken)) -> bo
#[unsafe(no_mangle)]
pub extern "C" fn WFExtStatusGetName(
in_ext_status: in_param_ty!(WFToken),
out_name: out_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_ext_status: WFToken| -> (out_name: WFCString) {
let pool = pull_reader!(EXT_STATUS_POOL)?;
out_name: out_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_ext_status: WFToken| -> (out_name: WFStrPtr) {
let pool = &CONTEXT.ext_status_pool;
let ext_status = pool.get(in_ext_status)?;
cstr_ffi::set_ffi_string(ext_status.get_name())?;
Ok(cstr_ffi::get_ffi_string())
Ok(cstr_ffi::push_ffi_string(ext_status.get_name())?)
})
}
@@ -689,9 +545,9 @@ pub extern "C" fn WFExtStatusGetName(
pub extern "C" fn WFExtStatusGetIcon(
in_ext_status: in_param_ty!(WFToken),
out_icon: out_param_ty!(WFHICON),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_ext_status: WFToken| -> (out_icon: WFHICON) {
let pool = pull_reader!(EXT_STATUS_POOL)?;
let pool = &CONTEXT.ext_status_pool;
let ext_status = pool.get(in_ext_status)?;
let icon = ext_status.get_icon();
@@ -704,9 +560,9 @@ pub extern "C" fn WFExtStatusGetIcon(
// region: Self Extension Status
#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusDestroy(in_self_ext_status: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFSelfExtStatusDestroy(in_self_ext_status: in_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|in_self_ext_status: WFToken| {
let mut pool = pull_writer!(SELF_EXT_STATUS_POOL)?;
let pool = &CONTEXT.self_ext_status_pool;
Ok(pool.free(in_self_ext_status)?)
})
}
@@ -714,14 +570,13 @@ pub extern "C" fn WFSelfExtStatusDestroy(in_self_ext_status: in_param_ty!(WFToke
#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetName(
in_self_ext_status: in_param_ty!(WFToken),
out_name: out_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_name: WFCString) {
let pool = pull_reader!(SELF_EXT_STATUS_POOL)?;
out_name: out_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_name: WFStrPtr) {
let pool = &CONTEXT.self_ext_status_pool;
let self_ext_status = pool.get(in_self_ext_status)?;
cstr_ffi::set_ffi_string(self_ext_status.get_name())?;
Ok(cstr_ffi::get_ffi_string())
Ok(cstr_ffi::push_ffi_string(self_ext_status.get_name())?)
})
}
@@ -729,9 +584,9 @@ pub extern "C" fn WFSelfExtStatusGetName(
pub extern "C" fn WFSelfExtStatusGetIcon(
in_self_ext_status: in_param_ty!(WFToken),
out_icon: out_param_ty!(WFHICON),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_icon: WFHICON) {
let pool = pull_reader!(SELF_EXT_STATUS_POOL)?;
let pool = &CONTEXT.self_ext_status_pool;
let self_ext_status = pool.get(in_self_ext_status)?;
let icon = self_ext_status.get_icon();
@@ -742,28 +597,26 @@ pub extern "C" fn WFSelfExtStatusGetIcon(
#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetExt(
in_self_ext_status: in_param_ty!(WFToken),
out_inner: out_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFCString) {
let pool = pull_reader!(SELF_EXT_STATUS_POOL)?;
out_inner: out_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFStrPtr) {
let pool = &CONTEXT.self_ext_status_pool;
let self_ext_status = pool.get(in_self_ext_status)?;
cstr_ffi::set_ffi_string(self_ext_status.get_ext())?;
Ok(cstr_ffi::get_ffi_string())
Ok(cstr_ffi::push_ffi_string(self_ext_status.get_ext())?)
})
}
#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetDottedExt(
in_self_ext_status: in_param_ty!(WFToken),
out_inner: out_param_ty!(WFCString),
) -> bool {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFCString) {
let pool = pull_reader!(SELF_EXT_STATUS_POOL)?;
out_inner: out_param_ty!(WFStrPtr),
) -> WFError {
cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFStrPtr) {
let pool = &CONTEXT.self_ext_status_pool;
let self_ext_status = pool.get(in_self_ext_status)?;
cstr_ffi::set_ffi_string(self_ext_status.get_dotted_ext().as_str())?;
Ok(cstr_ffi::get_ffi_string())
Ok(cstr_ffi::push_ffi_string(self_ext_status.get_dotted_ext().as_str())?)
})
}
@@ -772,9 +625,9 @@ pub extern "C" fn WFSelfExtStatusGetDottedExt(
// region: Icon Resource
#[unsafe(no_mangle)]
pub extern "C" fn WFIconRcDestroy(in_icon_rc: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFIconRcDestroy(in_icon_rc: in_param_ty!(WFToken)) -> WFError {
cffi_wrapper!(|in_icon_rc: WFToken| {
let mut pool = pull_writer!(ICON_RC_POOL)?;
let pool = &CONTEXT.icon_rc_pool;
Ok(pool.free(in_icon_rc)?)
})
}
@@ -783,9 +636,9 @@ pub extern "C" fn WFIconRcDestroy(in_icon_rc: in_param_ty!(WFToken)) -> bool {
pub extern "C" fn WFIconRcGetIcon(
in_icon_rc: in_param_ty!(WFToken),
out_icon: out_param_ty!(WFHICON),
) -> bool {
) -> WFError {
cffi_wrapper!(|in_icon_rc: WFToken| -> (out_icon: WFHICON) {
let pool = pull_reader!(ICON_RC_POOL)?;
let pool = &CONTEXT.icon_rc_pool;
let icon_rc = pool.get(in_icon_rc)?;
Ok(icon_rc.get_icon())