diff --git a/nixide/src/errors/context.rs b/nixide/src/errors/context.rs index 9eae514..13a3c6d 100644 --- a/nixide/src/errors/context.rs +++ b/nixide/src/errors/context.rs @@ -21,12 +21,14 @@ // static std::optional 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(()) diff --git a/nixide/src/errors/error.rs b/nixide/src/errors/error.rs index 95c8379..0894cdd 100644 --- a/nixide/src/errors/error.rs +++ b/nixide/src/errors/error.rs @@ -5,6 +5,16 @@ use crate::sys; pub type NixideResult = Result; +pub(crate) trait ToNixideResult { + fn to_nixide_result(self) -> NixideResult; +} + +impl ToNixideResult for Result { + fn to_nixide_result(self) -> NixideResult { + Err(new_nixide_error!(StringNulByte)) + } +} + #[derive(Debug, Clone)] pub enum NixideError { /// # Warning @@ -134,16 +144,3 @@ impl Display for NixideError { } } } - -// pub trait AsErr { -// fn as_err(self) -> Result<(), T>; -// } - -// impl AsErr for Option { -// fn as_err(self) -> Result<(), NixideError> { -// match self { -// Some(err) => Err(err), -// None => Ok(()), -// } -// } -// } diff --git a/nixide/src/errors/mod.rs b/nixide/src/errors/mod.rs index c194728..9be349f 100644 --- a/nixide/src/errors/mod.rs +++ b/nixide/src/errors/mod.rs @@ -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; diff --git a/nixide/src/expr/eval_state.rs b/nixide/src/expr/eval_state.rs index 7cee8e4..2f7c20a 100644 --- a/nixide/src/expr/eval_state.rs +++ b/nixide/src/expr/eval_state.rs @@ -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>, } -// 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 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 { - 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()))) } } diff --git a/nixide/src/expr/values/attrs.rs b/nixide/src/expr/values/attrs.rs index c6c87b8..c937214 100644 --- a/nixide/src/expr/values/attrs.rs +++ b/nixide/src/expr/values/attrs.rs @@ -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, @@ -170,55 +171,58 @@ impl NixAttrs { Some(name) } - pub fn get(&self, name: T) -> Option + pub fn get(&self, name: T) -> NixideResult> where T: AsRef, { + 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(&self, name: T) -> Option + pub fn get_lazy(&self, name: T) -> NixideResult> where T: AsRef, { + 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(::from(inner, self.state.clone())), + Ok(inner) => Ok(Some(::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), } } } diff --git a/nixide/src/flake/fetchers_settings.rs b/nixide/src/flake/fetchers_settings.rs index dcb611f..bfe56dd 100644 --- a/nixide/src/flake/fetchers_settings.rs +++ b/nixide/src/flake/fetchers_settings.rs @@ -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` 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` 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(); diff --git a/nixide/src/flake/flake_lock_flags.rs b/nixide/src/flake/flake_lock_flags.rs index ab02bad..a1224e6 100644 --- a/nixide/src/flake/flake_lock_flags.rs +++ b/nixide/src/flake/flake_lock_flags.rs @@ -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 { // 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 { // 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 { - 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 { - 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(); diff --git a/nixide/src/flake/flake_settings.rs b/nixide/src/flake/flake_settings.rs index 3af309a..1697ebb 100644 --- a/nixide/src/flake/flake_settings.rs +++ b/nixide/src/flake/flake_settings.rs @@ -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 { - 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(); diff --git a/nixide/src/flake/flakeref_builder.rs b/nixide/src/flake/flakeref_builder.rs index e1d28e5..13eecf2 100644 --- a/nixide/src/flake/flakeref_builder.rs +++ b/nixide/src/flake/flakeref_builder.rs @@ -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 { - 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), diff --git a/nixide/src/flake/flakeref_parse_flags.rs b/nixide/src/flake/flakeref_parse_flags.rs index d1a9d6c..31dfdd6 100644 --- a/nixide/src/flake/flakeref_parse_flags.rs +++ b/nixide/src/flake/flakeref_parse_flags.rs @@ -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(), ); }) diff --git a/nixide/src/flake/locked_flake.rs b/nixide/src/flake/locked_flake.rs index 17b8768..b0be32e 100644 --- a/nixide/src/flake/locked_flake.rs +++ b/nixide/src/flake/locked_flake.rs @@ -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"); } } diff --git a/nixide/src/logging.rs b/nixide/src/logging.rs index 87386e5..495226a 100644 --- a/nixide/src/logging.rs +++ b/nixide/src/logging.rs @@ -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() } diff --git a/nixide/src/nix_settings.rs b/nixide/src/nix_settings.rs index 3c98051..166eb63 100644 --- a/nixide/src/nix_settings.rs +++ b/nixide/src/nix_settings.rs @@ -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 { - 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 { /// 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()); }) } diff --git a/nixide/src/plugins.rs b/nixide/src/plugins.rs index f9f7e8c..00ca391 100644 --- a/nixide/src/plugins.rs +++ b/nixide/src/plugins.rs @@ -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>(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()); }) } diff --git a/nixide/src/stdext/cchar_ptr.rs b/nixide/src/stdext/cchar_ptr.rs index bf1840e..b80d08c 100644 --- a/nixide/src/stdext/cchar_ptr.rs +++ b/nixide/src/stdext/cchar_ptr.rs @@ -5,33 +5,6 @@ use std::str::from_utf8; use crate::NixideResult; use crate::errors::new_nixide_error; -pub trait AsCPtr { - #[allow(unused)] - fn as_c_ptr(&self) -> NixideResult<*const T>; - - #[allow(unused)] - fn into_c_ptr(self) -> NixideResult<*mut T>; -} - -impl AsCPtr for T -where - T: AsRef, -{ - 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; diff --git a/nixide/src/stdext/mod.rs b/nixide/src/stdext/mod.rs index cdf4416..e893a29 100644 --- a/nixide/src/stdext/mod.rs +++ b/nixide/src/stdext/mod.rs @@ -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; diff --git a/nixide/src/store/mod.rs b/nixide/src/store/mod.rs index bb0d398..b193109 100644 --- a/nixide/src/store/mod.rs +++ b/nixide/src/store/mod.rs @@ -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>> { - 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.