cry/nixide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix and replace all AsCPtr usage

Browse source
This commit is contained in:
do butterflies cry? 2026-04-13 22:22:28 +10:00
parent ede5d7c308
commit 9f8effeeda
Signed by: cry
GPG key ID: F68745A836CA0412
17 changed files with 114 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

10
nixide/src/errors/context.rs
View file

@ -21,12 +21,14 @@
// static std::optional<std::string> programName;
// };
use std::ffi::CString;
use std::ffi::c_uint;
use std::ffi::c_void;
use std::ptr::NonNull;
use super::{NixError, NixideResult};
use crate::stdext::{AsCPtr as _, CCharPtrExt as _};
use crate::errors::ToNixideResult as _;
use crate::stdext::CCharPtrExt as _;
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -188,11 +190,11 @@ impl ErrorContext {
///
#[allow(unused)]
pub fn set_err(&self, err: NixError, msg: &str) -> NixideResult<()> {
let ptr = unsafe { self.as_ptr() };
assert!(!ptr.is_null(), "");
let ctx = unsafe { self.as_ptr() };
let c_msg = CString::new(msg).to_nixide_result()?;
unsafe {
sys::nix_set_err_msg(ptr, err.err_code(), msg.as_c_ptr()?);
sys::nix_set_err_msg(ctx, err.err_code(), c_msg.as_ptr());
}
Ok(())

23
nixide/src/errors/error.rs
View file

@ -5,6 +5,16 @@ use crate::sys;
pub type NixideResult<T> = Result<T, NixideError>;
pub(crate) trait ToNixideResult<T> {
fn to_nixide_result(self) -> NixideResult<T>;
}
impl<T> ToNixideResult<T> for Result<T, std::ffi::NulError> {
fn to_nixide_result(self) -> NixideResult<T> {
Err(new_nixide_error!(StringNulByte))
}
}
#[derive(Debug, Clone)]
pub enum NixideError {
/// # Warning
@ -134,16 +144,3 @@ impl Display for NixideError {
}
}
}
// pub trait AsErr<T> {
// fn as_err(self) -> Result<(), T>;
// }
// impl AsErr<NixideError> for Option<NixideError> {
// fn as_err(self) -> Result<(), NixideError> {
// match self {
// Some(err) => Err(err),
// None => Ok(()),
// }
// }
// }

2
nixide/src/errors/mod.rs
View file

@ -4,6 +4,6 @@ mod context;
mod nix_error;
pub(crate) use context::ErrorContext;
pub(crate) use error::new_nixide_error;
pub use error::{NixideError, NixideResult};
pub(crate) use error::{ToNixideResult, new_nixide_error};
pub use nix_error::NixError;

36
nixide/src/expr/eval_state.rs
View file

@ -1,11 +1,10 @@
use std::cell::RefCell;
use std::ffi::CString;
use std::ptr::NonNull;
use std::rc::Rc;
use crate::stdext::AsCPtr as _;
use super::Value;
use crate::errors::ErrorContext;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrappers::AsInnerPtr;
use crate::util::{panic_issue_call_failed, wrap};
@ -22,22 +21,6 @@ pub struct EvalState {
store: Rc<RefCell<Store>>,
}
// impl Clone for EvalState {
// fn clone(&self) -> Self {
// let inner = self.inner.clone();
//
// wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
// sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void);
// })
// .unwrap();
//
// Self {
// inner,
// store: self.store.clone(),
// }
// }
// }
impl AsInnerPtr<sys::EvalState> for EvalState {
#[inline]
unsafe fn as_ptr(&self) -> *mut sys::EvalState {
@ -87,8 +70,8 @@ impl EvalState {
/// Returns an error if evaluation fails.
///
pub fn interpret(&self, expr: &str, path: &str) -> NixideResult<Value> {
let expr = expr.as_c_ptr()?;
let path = path.as_c_ptr()?;
let c_expr = CString::new(expr).to_nixide_result()?;
let c_path = CString::new(path).to_nixide_result()?;
// Allocate value for result
// XXX: TODO: create a method for this (``)
@ -99,10 +82,15 @@ impl EvalState {
// Evaluate expression
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_expr_eval_from_string(ctx.as_ptr(), self.as_ptr(), expr, path, value.as_ptr());
value
sys::nix_expr_eval_from_string(
ctx.as_ptr(),
self.as_ptr(),
c_expr.as_ptr(),
c_path.as_ptr(),
value.as_ptr(),
);
Value::from((value, self.inner_ref().clone()))
})
.map(|ptr| Value::from((ptr, self.inner_ref().clone())))
}
}

38
nixide/src/expr/values/attrs.rs
View file

@ -1,15 +1,16 @@
use std::cell::RefCell;
use std::ffi::CString;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::{self, NonNull};
use std::rc::Rc;
use super::{NixThunk, NixValue, Value};
use crate::NixError;
use crate::errors::{ErrorContext, NixideError};
use crate::stdext::{AsCPtr, CCharPtrExt};
use crate::errors::{ErrorContext, NixideError, ToNixideResult as _};
use crate::stdext::CCharPtrExt;
use crate::sys;
use crate::util::wrappers::AsInnerPtr;
use crate::util::{panic_issue_call_failed, wrap};
use crate::{NixError, NixideResult};
pub struct NixAttrs {
inner: NonNull<sys::NixValue>,
@ -170,55 +171,58 @@ impl NixAttrs {
Some(name)
}
pub fn get<T>(&self, name: T) -> Option<Value>
pub fn get<T>(&self, name: T) -> NixideResult<Option<Value>>
where
T: AsRef<str>,
{
let c_name = CString::new(name.as_ref()).to_nixide_result()?;
let result = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_get_attr_byname(
ctx.as_ptr(),
self.as_ptr(),
self.state.borrow().as_ptr(),
name.as_ref()
.into_c_ptr()
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),
c_name.as_ptr(),
)
});
match result {
Ok(inner) => Some(Value::from((inner, self.state.clone()))),
Ok(inner) => Ok(Some(Value::from((inner, self.state.clone())))),
Err(NixideError::NixError {
err: NixError::KeyNotFound(_),
..
}) => None,
Err(err) => panic_issue_call_failed!("{}", err),
}) => Ok(None),
Err(err) => Err(err),
}
}
pub fn get_lazy<T>(&self, name: T) -> Option<NixThunk>
pub fn get_lazy<T>(&self, name: T) -> NixideResult<Option<NixThunk>>
where
T: AsRef<str>,
{
let c_name = CString::new(name.as_ref()).to_nixide_result()?;
let result = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_get_attr_byname_lazy(
ctx.as_ptr(),
self.as_ptr(),
self.state.borrow().as_ptr(),
name.as_ref()
.into_c_ptr()
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),
c_name.as_ptr(),
)
});
match result {
Ok(inner) => Some(<NixThunk as NixValue>::from(inner, self.state.clone())),
Ok(inner) => Ok(Some(<NixThunk as NixValue>::from(
inner,
self.state.clone(),
))),
Err(NixideError::NixError {
err: NixError::KeyNotFound(_),
..
}) => None,
Err(err) => panic_issue_call_failed!("{}", err),
}) => Ok(None),
Err(err) => Err(err),
}
}
}

24
nixide/src/flake/fetchers_settings.rs
View file

@ -1,8 +1,8 @@
use std::ffi::{CString, c_char};
use std::ptr::NonNull;
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -57,15 +57,15 @@ impl FetchersSettings {
#[allow(unused)]
pub fn add_access_token(&self, token_name: &str, token_value: &str) -> NixideResult<()> {
// XXX: TODO: have a dedicated `self.access_tokens: HashMap<String, String>` instead
let name_ptr = token_name.into_c_ptr()?;
let value_ptr = token_value.into_c_ptr()?;
let c_name = CString::new(token_name).to_nixide_result()?;
let c_value = CString::new(token_value).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_fetchers_settings_add_access_token(
ctx.as_ptr(),
self.as_ptr(),
name_ptr,
value_ptr,
c_name.as_ptr() as *mut c_char,
c_value.as_ptr() as *mut c_char,
);
})
.unwrap();
@ -84,10 +84,14 @@ impl FetchersSettings {
#[allow(unused)]
pub fn remove_access_token(&self, token_name: &str) -> NixideResult<()> {
// XXX: TODO: have a dedicated `self.access_tokens: HashMap<String, String>` instead
let name_ptr = token_name.into_c_ptr()?;
let c_name = CString::new(token_name).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_fetchers_settings_remove_access_token(ctx.as_ptr(), self.as_ptr(), name_ptr);
sys::nix_fetchers_settings_remove_access_token(
ctx.as_ptr(),
self.as_ptr(),
c_name.as_ptr() as *mut c_char,
);
})
.unwrap();
@ -168,13 +172,13 @@ impl FetchersSettings {
/// It is instead **exposed by the Nixide C API extensions.**
///
pub fn global_flake_registry(&self, registry: &str) -> NixideResult<()> {
let registry_ptr = registry.into_c_ptr()?;
let c_registry = CString::new(registry).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_fetchers_settings_set_global_flake_registry(
ctx.as_ptr(),
self.as_ptr(),
registry_ptr,
c_registry.as_ptr() as *mut c_char,
);
})
.unwrap();

25
nixide/src/flake/flake_lock_flags.rs
View file

@ -1,10 +1,9 @@
use std::ffi::c_char;
use std::ffi::{CString, c_char};
use std::ptr::{self, NonNull};
use super::FlakeRef;
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -120,13 +119,13 @@ impl FlakeLockFlags {
#[allow(unused)]
pub fn override_input(self, input: &str, flakeref: &FlakeRef) -> NixideResult<Self> {
// XXX: TODO: should `input` be wrapped as `format!("inputs.{input}")`?
let input_path = input.as_c_ptr()?;
let c_input = CString::new(input).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_add_input_override(
ctx.as_ptr(),
self.as_ptr(),
input_path,
c_input.as_ptr(),
flakeref.as_ptr(),
);
})?;
@ -148,10 +147,14 @@ impl FlakeLockFlags {
#[allow(unused)]
pub fn update_input(self, input: &str) -> NixideResult<Self> {
// XXX: TODO: should `input` be wrapped as `format!("inputs.{input}")`?
let input_path = input.as_c_ptr()?;
let c_input = CString::new(input).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_add_input_update(ctx.as_ptr(), self.as_ptr(), input_path);
sys::nix_flake_lock_flags_add_input_update(
ctx.as_ptr(),
self.as_ptr(),
c_input.as_ptr(),
);
})?;
Ok(self)
@ -287,13 +290,13 @@ impl FlakeLockFlags {
///
#[allow(unused)]
pub fn input_lock_file_path(self, path: &str) -> NixideResult<Self> {
let path_ptr = path.as_c_ptr()? as *mut c_char;
let c_path = CString::new(path).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_set_reference_lock_file_path(
ctx.as_ptr(),
self.as_ptr(),
path_ptr,
c_path.as_ptr() as *mut c_char,
)
})
.unwrap();
@ -311,13 +314,13 @@ impl FlakeLockFlags {
///
#[allow(unused)]
pub fn output_lock_file_path(self, path: &str) -> NixideResult<Self> {
let path_ptr = path.as_c_ptr()? as *mut c_char;
let c_path = CString::new(path).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_set_output_lock_file_path(
ctx.as_ptr(),
self.as_ptr(),
path_ptr,
c_path.as_ptr() as *mut c_char,
)
})
.unwrap();

8
nixide/src/flake/flake_settings.rs
View file

@ -1,8 +1,8 @@
use std::ffi::CString;
use std::ptr::NonNull;
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -86,12 +86,12 @@ impl FlakeSettings {
///
#[allow(unused)]
pub fn commit_lock_file_summary(self, summary: &str) -> NixideResult<Self> {
let summary_ptr = summary.into_c_ptr()?;
let c_summary = CString::new(summary).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_settings_set_commit_lock_file_summary(
ctx.as_ptr(),
self.as_ptr(),
summary_ptr,
c_summary.as_ptr().cast_mut(),
)
})
.unwrap();

9
nixide/src/flake/flakeref_builder.rs
View file

@ -1,10 +1,9 @@
use std::ffi::c_void;
use std::ffi::{CString, c_void};
use std::path::Path;
use std::ptr::{self, NonNull, null_mut};
use super::{FetchersSettings, FlakeRef, FlakeRefParseFlags};
use crate::errors::{ErrorContext, NixideResult, new_nixide_error};
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, NixideResult, ToNixideResult as _, new_nixide_error};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -32,7 +31,7 @@ impl FlakeRefBuilder {
}
pub fn build(&self) -> NixideResult<FlakeRef> {
let reference_ptr = self.reference.as_c_ptr()?;
let c_reference = CString::new(self.reference.as_str()).to_nixide_result()?;
let mut ptr: *mut sys::NixFlakeReference = null_mut();
let fragment = wrap::nix_string_callback!(
@ -45,7 +44,7 @@ impl FlakeRefBuilder {
self.fetch_settings.as_ptr(),
ptr::null_mut(),
self.parse_flags.as_ptr(),
reference_ptr,
c_reference.as_ptr(),
self.reference.len(),
&mut ptr,
Some(callback),

8
nixide/src/flake/flakeref_parse_flags.rs
View file

@ -1,7 +1,7 @@
use std::ffi::CString;
use std::ptr::{self, NonNull};
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
use crate::{NixideResult, sys};
@ -68,13 +68,13 @@ impl FlakeRefParseFlags {
/// to the current working directory (see `libutil/filesystem.cc:absPath`).
///
pub fn base_directory(&mut self, base_directory: &str) -> NixideResult<()> {
let base_directory_ptr = base_directory.as_c_ptr()?;
let c_base_directory = CString::new(base_directory).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_reference_parse_flags_set_base_directory(
ctx.as_ptr(),
self.as_ptr(),
base_directory_ptr,
c_base_directory.as_ptr(),
base_directory.len(),
);
})

4
nixide/src/flake/locked_flake.rs
View file

@ -175,8 +175,8 @@ mod tests {
if let Value::Attrs(outputs) = outputs {
let value = outputs.get("hello").unwrap();
assert!(matches!(value, Value::String(_)));
if let Value::String(value) = value {
assert!(matches!(value, Some(Value::String(_))));
if let Some(Value::String(value)) = value {
assert_eq!(value.as_string(), "world");
}
}

9
nixide/src/logging.rs
View file

@ -1,5 +1,6 @@
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use std::ffi::CString;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr as _;
@ -69,8 +70,10 @@ impl ToString for LogFormat {
/// modified without nixide updating to account for this.
///
pub fn set_log_format(format: LogFormat) {
let c_format = CString::new(format.to_string()).to_nixide_result().unwrap();
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_set_log_format(ctx.as_ptr(), format.to_string().as_c_ptr().unwrap());
sys::nix_set_log_format(ctx.as_ptr(), c_format.as_ptr());
})
.unwrap()
}

13
nixide/src/nix_settings.rs
View file

@ -1,7 +1,7 @@
use std::ffi::{CString, c_void};
use crate::NixideResult;
use crate::errors::{AsNixideResult as _, ErrorContext};
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr as _;
@ -11,13 +11,13 @@ use crate::util::wrappers::AsInnerPtr as _;
/// Please prefer [nixide::FlakeSettings] and [nixide::FetchersSettings].
///
pub unsafe fn get_global_setting(key: &str) -> NixideResult<String> {
let key = CString::new(key).to_nixide_result()?;
let c_key = CString::new(key).to_nixide_result()?;
wrap::nix_string_callback!(
|callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
sys::nix_setting_get(
ctx.as_ptr(),
key.as_ptr(),
c_key.as_ptr(),
Some(callback),
userdata as *mut c_void,
);
@ -30,11 +30,10 @@ pub unsafe fn get_global_setting(key: &str) -> NixideResult<String> {
/// Please prefer [nixide::FlakeSettings] and [nixide::FetchersSettings].
///
pub unsafe fn set_global_setting(key: &str, value: &str) -> NixideResult<()> {
// DEBUG: TODO: write a convenient way to convert this to NixideResult
let key = CString::new(key).unwrap();
let value = CString::new(value).unwrap();
let c_key = CString::new(key).to_nixide_result()?;
let c_value = CString::new(value).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_setting_set(ctx.as_ptr(), key.as_ptr(), value.as_ptr());
sys::nix_setting_set(ctx.as_ptr(), c_key.as_ptr(), c_value.as_ptr());
})
}

9
nixide/src/plugins.rs
View file

@ -1,6 +1,7 @@
use std::ffi::CString;
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr as _;
@ -11,8 +12,8 @@ pub fn load_plugins() -> NixideResult<()> {
}
pub fn register_plugin<S: AsRef<str>>(path: S) -> NixideResult<()> {
let path_ptr = path.as_ref().into_c_ptr()?;
let c_path = CString::new(path.as_ref()).to_nixide_result()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_register_plugin(ctx.as_ptr(), path_ptr);
sys::nix_register_plugin(ctx.as_ptr(), c_path.as_ptr().cast_mut());
})
}

27
nixide/src/stdext/cchar_ptr.rs
View file

@ -5,33 +5,6 @@ use std::str::from_utf8;
use crate::NixideResult;
use crate::errors::new_nixide_error;
pub trait AsCPtr<T> {
#[allow(unused)]
fn as_c_ptr(&self) -> NixideResult<*const T>;
#[allow(unused)]
fn into_c_ptr(self) -> NixideResult<*mut T>;
}
impl<T> AsCPtr<c_char> for T
where
T: AsRef<str>,
{
fn as_c_ptr(&self) -> NixideResult<*const c_char> {
match CStr::from_bytes_until_nul(self.as_ref().as_bytes()) {
Ok(s) => Ok(s.as_ptr()),
Err(_) => Err(new_nixide_error!(StringNulByte)),
}
}
fn into_c_ptr(self) -> NixideResult<*mut c_char> {
match CStr::from_bytes_until_nul(self.as_ref().as_bytes()) {
Ok(s) => Ok(s.as_ptr().cast_mut()),
Err(_) => Err(new_nixide_error!(StringNulByte)),
}
}
}
pub trait CCharPtrExt {
#[allow(unused)]
fn to_utf8_string(self) -> NixideResult<String>;

2
nixide/src/stdext/mod.rs
View file

@ -1,5 +1,5 @@
mod cchar_ptr;
mod slice;
pub(crate) use cchar_ptr::{AsCPtr, CCharPtrExt};
pub(crate) use cchar_ptr::CCharPtrExt;
pub(crate) use slice::SliceExt;

8
nixide/src/store/mod.rs
View file

@ -8,14 +8,13 @@ mod path;
pub use path::*;
use std::cell::RefCell;
use std::ffi::{c_char, c_void};
use std::ffi::{CString, c_char, c_void};
use std::path::PathBuf;
use std::ptr::{NonNull, null, null_mut};
use std::rc::Rc;
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
use crate::errors::{ErrorContext, ToNixideResult as _};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
@ -58,7 +57,8 @@ impl Store {
/// Returns an error if the store cannot be opened.
///
pub fn open(uri: &str) -> NixideResult<Rc<RefCell<Self>>> {
unsafe { Self::open_ptr(uri.as_c_ptr()?) }
let c_uri = CString::new(uri).to_nixide_result()?;
unsafe { Self::open_ptr(c_uri.as_ptr()) }
}
/// Opens a connection to the default Nix store.