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

replace std::os::raw -> core::ffi

Browse source
This commit is contained in:
do butterflies cry? 2026-04-02 10:40:18 +10:00
parent 20aefb99ed
commit 26c222247a
Signed by: cry
GPG key ID: F68745A836CA0412
9 changed files with 118 additions and 148 deletions
Download patch file Download diff file Expand all files Collapse all files

3
TODO.md
View file

@ -1,3 +0,0 @@
- [ ] rename all `::std::os::raw` instances to ``::core::ffi`
- [ ] I probably don't need my implementations of `NixError` and `NixVerbosity` now, I could just re-export them for sys

49
nixide-sys/tests/eval.rs
View file

@ -1,8 +1,9 @@
#![cfg(feature = "nix-expr-c")] #![cfg(feature = "nix-expr-c")]
#![cfg(test)] #![cfg(test)]
use std::ffi::{CStr, CString}; use ::core::ffi::{CStr, c_char, c_uint, c_void};
use std::ptr; use ::std::ffi::CString;
use ::std::{f64, ptr, slice};
use serial_test::serial; use serial_test::serial;
@ -23,7 +24,7 @@ fn eval_init_and_state_build() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}"); assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -58,7 +59,7 @@ fn eval_simple_expression() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}"); assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -119,12 +120,9 @@ fn value_construction_and_inspection() {
// Float // Float
let float_val = nix_alloc_value(ctx, state); let float_val = nix_alloc_value(ctx, state);
assert!(!float_val.is_null()); assert!(!float_val.is_null());
assert_eq!( assert_eq!(nix_init_float(ctx, float_val, f64::consts::PI), NixErr::Ok);
nix_init_float(ctx, float_val, std::f64::consts::PI),
NixErr::Ok
);
assert_eq!(nix_get_type(ctx, float_val), ValueType::Float); assert_eq!(nix_get_type(ctx, float_val), ValueType::Float);
assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10); assert!((nix_get_float(ctx, float_val) - f64::consts::PI).abs() < 1e-10);
// Bool // Bool
let bool_val = nix_alloc_value(ctx, state); let bool_val = nix_alloc_value(ctx, state);
@ -145,13 +143,9 @@ fn value_construction_and_inspection() {
let s = CString::new("hello world").unwrap(); let s = CString::new("hello world").unwrap();
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok); assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok);
assert_eq!(nix_get_type(ctx, string_val), ValueType::String); assert_eq!(nix_get_type(ctx, string_val), ValueType::String);
extern "C" fn string_cb( extern "C" fn string_cb(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) }; unsafe { *out = Some(s.to_string()) };
} }
@ -399,8 +393,7 @@ fn realised_string_and_gc() {
assert!(!realised.is_null()); assert!(!realised.is_null());
let buf = nix_realised_string_get_buffer_start(realised); let buf = nix_realised_string_get_buffer_start(realised);
let len = nix_realised_string_get_buffer_size(realised); let len = nix_realised_string_get_buffer_size(realised);
let realised_str = let realised_str = str::from_utf8(slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
std::str::from_utf8(std::slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
assert_eq!(realised_str, "hello world"); assert_eq!(realised_str, "hello world");
assert_eq!(nix_realised_string_get_store_path_count(realised), 0); assert_eq!(nix_realised_string_get_store_path_count(realised), 0);
@ -496,7 +489,7 @@ fn multi_argument_function_calls() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -584,7 +577,7 @@ fn curried_function_evaluation() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -713,7 +706,7 @@ fn thunk_creation_with_init_apply() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -792,7 +785,7 @@ fn lookup_path_configuration() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -806,7 +799,7 @@ fn lookup_path_configuration() {
let lookup_path_ptrs: Vec<*const _> = lookup_paths.iter().map(|s| s.as_ptr()).collect(); let lookup_path_ptrs: Vec<*const _> = lookup_paths.iter().map(|s| s.as_ptr()).collect();
let mut lookup_path_ptrs_null_terminated = lookup_path_ptrs; let mut lookup_path_ptrs_null_terminated = lookup_path_ptrs;
lookup_path_ptrs_null_terminated.push(std::ptr::null()); lookup_path_ptrs_null_terminated.push(ptr::null());
let set_lookup_err = nix_eval_state_builder_set_lookup_path( let set_lookup_err = nix_eval_state_builder_set_lookup_path(
ctx, ctx,
@ -869,7 +862,7 @@ fn complex_nested_evaluation() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -992,7 +985,7 @@ fn evaluation_error_handling() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -1043,10 +1036,10 @@ fn evaluation_error_handling() {
assert_ne!(error_code, NixErr::Ok); assert_ne!(error_code, NixErr::Ok);
// Try to get error message // Try to get error message
let mut error_len: std::os::raw::c_uint = 0; let mut error_len: c_uint = 0;
let error_msg_ptr = nix_err_msg(ctx, ctx, &mut error_len as *mut _); let error_msg_ptr = nix_err_msg(ctx, ctx, &mut error_len as *mut _);
if !error_msg_ptr.is_null() && error_len > 0 { if !error_msg_ptr.is_null() && error_len > 0 {
let error_msg = std::str::from_utf8(std::slice::from_raw_parts( let error_msg = str::from_utf8(slice::from_raw_parts(
error_msg_ptr as *const u8, error_msg_ptr as *const u8,
error_len as usize, error_len as usize,
)) ))
@ -1123,7 +1116,7 @@ fn builtin_function_calls() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);

44
nixide-sys/tests/memory.rs
View file

@ -1,7 +1,9 @@
#![cfg(feature = "nix-expr-c")] #![cfg(feature = "nix-expr-c")]
#![cfg(test)] #![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString; use std::ffi::CString;
use std::{ptr, slice, str};
use serial_test::serial; use serial_test::serial;
@ -23,7 +25,7 @@ fn value_reference_counting() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -87,7 +89,7 @@ fn general_gc_reference_counting() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -111,7 +113,7 @@ fn general_gc_reference_counting() {
assert_eq!(init_err, NixErr::Ok); assert_eq!(init_err, NixErr::Ok);
// Test general GC reference counting // Test general GC reference counting
let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void); let gc_incref_err = nix_gc_incref(ctx, value as *const c_void);
assert_eq!(gc_incref_err, NixErr::Ok); assert_eq!(gc_incref_err, NixErr::Ok);
// Value should still be accessible // Value should still be accessible
@ -119,7 +121,7 @@ fn general_gc_reference_counting() {
assert_eq!(value_type, ValueType::String); assert_eq!(value_type, ValueType::String);
// Test GC decrement // Test GC decrement
let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void); let gc_decref_err = nix_gc_decref(ctx, value as *const c_void);
assert_eq!(gc_decref_err, NixErr::Ok); assert_eq!(gc_decref_err, NixErr::Ok);
// Final cleanup // Final cleanup
@ -147,7 +149,7 @@ fn manual_garbage_collection() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -205,7 +207,7 @@ fn value_copying_and_memory_management() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -240,12 +242,12 @@ fn value_copying_and_memory_management() {
// Test string contents using callback // Test string contents using callback
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char, start: *const c_char,
n: ::std::os::raw::c_uint, n: c_uint,
user_data: *mut ::std::os::raw::c_void, user_data: *mut c_void,
) { ) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) }; let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or(""); let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) }; let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string()); *result = Some(s.to_string());
} }
@ -257,14 +259,14 @@ fn value_copying_and_memory_management() {
ctx, ctx,
original, original,
Some(string_callback), Some(string_callback),
&mut original_string as *mut Option<String> as *mut ::std::os::raw::c_void, &mut original_string as *mut Option<String> as *mut c_void,
); );
let _ = nix_get_string( let _ = nix_get_string(
ctx, ctx,
copy, copy,
Some(string_callback), Some(string_callback),
&mut copy_string as *mut Option<String> as *mut ::std::os::raw::c_void, &mut copy_string as *mut Option<String> as *mut c_void,
); );
// Both should have the same string content // Both should have the same string content
@ -315,7 +317,7 @@ fn complex_value_memory_management() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -442,20 +444,20 @@ fn memory_management_error_conditions() {
assert!(!ctx.is_null()); assert!(!ctx.is_null());
// Test reference counting with NULL pointers (should handle gracefully) // Test reference counting with NULL pointers (should handle gracefully)
let null_incref_err = nix_gc_incref(ctx, std::ptr::null() as *const ::std::os::raw::c_void); let null_incref_err = nix_gc_incref(ctx, ptr::null() as *const c_void);
// XXX: May succeed or fail depending on implementation. We can't really // XXX: May succeed or fail depending on implementation. We can't really
// know, so assert both. // know, so assert both.
assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown); assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown);
let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void); let null_decref_err = nix_gc_decref(ctx, ptr::null() as *const c_void);
assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown); assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown);
let null_value_incref_err = nix_value_incref(ctx, std::ptr::null_mut()); let null_value_incref_err = nix_value_incref(ctx, ptr::null_mut());
// Some Nix APIs gracefully handle null pointers and return OK // Some Nix APIs gracefully handle null pointers and return OK
assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown); assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown);
let null_value_decref_err = nix_value_decref(ctx, std::ptr::null_mut()); let null_value_decref_err = nix_value_decref(ctx, ptr::null_mut());
// Some Nix APIs gracefully handle null pointers and return OK // Some Nix APIs gracefully handle null pointers and return OK
assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown); assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown);
@ -469,7 +471,7 @@ fn memory_management_error_conditions() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -485,10 +487,10 @@ fn memory_management_error_conditions() {
assert!(!valid_value.is_null()); assert!(!valid_value.is_null());
// Test copying to/from NULL // Test copying to/from NULL
let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut()); let copy_from_null_err = nix_copy_value(ctx, valid_value, ptr::null_mut());
assert_ne!(copy_from_null_err, NixErr::Ok); assert_ne!(copy_from_null_err, NixErr::Ok);
let copy_to_null_err = nix_copy_value(ctx, std::ptr::null_mut(), valid_value); let copy_to_null_err = nix_copy_value(ctx, ptr::null_mut(), valid_value);
assert_ne!(copy_to_null_err, NixErr::Ok); assert_ne!(copy_to_null_err, NixErr::Ok);
// Clean up // Clean up

78
nixide-sys/tests/primop.rs
View file

@ -1,8 +1,10 @@
#![cfg(feature = "nix-expr-c")] #![cfg(feature = "nix-expr-c")]
#![cfg(test)] #![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString; use std::ffi::CString;
use std::sync::atomic::{AtomicU32, Ordering}; use std::sync::atomic::{AtomicU32, Ordering};
use std::{ptr, slice};
use serial_test::serial; use serial_test::serial;
@ -16,7 +18,7 @@ struct TestPrimOpData {
// Simple PrimOp that adds 1 to an integer argument // Simple PrimOp that adds 1 to an integer argument
unsafe extern "C" fn add_one_primop( unsafe extern "C" fn add_one_primop(
user_data: *mut ::std::os::raw::c_void, user_data: *mut c_void,
context: *mut NixCContext, context: *mut NixCContext,
state: *mut EvalState, state: *mut EvalState,
args: *mut *mut NixValue, args: *mut *mut NixValue,
@ -81,7 +83,7 @@ unsafe extern "C" fn add_one_primop(
// PrimOp that returns a constant string // PrimOp that returns a constant string
unsafe extern "C" fn hello_world_primop( unsafe extern "C" fn hello_world_primop(
_user_data: *mut ::std::os::raw::c_void, _user_data: *mut c_void,
context: *mut NixCContext, context: *mut NixCContext,
_state: *mut EvalState, _state: *mut EvalState,
_args: *mut *mut NixValue, _args: *mut *mut NixValue,
@ -93,7 +95,7 @@ unsafe extern "C" fn hello_world_primop(
// PrimOp that takes multiple arguments and concatenates them // PrimOp that takes multiple arguments and concatenates them
unsafe extern "C" fn concat_strings_primop( unsafe extern "C" fn concat_strings_primop(
_user_data: *mut ::std::os::raw::c_void, _user_data: *mut c_void,
context: *mut NixCContext, context: *mut NixCContext,
state: *mut EvalState, state: *mut EvalState,
args: *mut *mut NixValue, args: *mut *mut NixValue,
@ -135,12 +137,12 @@ unsafe extern "C" fn concat_strings_primop(
// Get string value using callback // Get string value using callback
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char, start: *const c_char,
n: ::std::os::raw::c_uint, n: c_uint,
user_data: *mut ::std::os::raw::c_void, user_data: *mut c_void,
) { ) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) }; let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or(""); let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut String) }; let result = unsafe { &mut *(user_data as *mut String) };
result.push_str(s); result.push_str(s);
} }
@ -150,7 +152,7 @@ unsafe extern "C" fn concat_strings_primop(
context, context,
arg, arg,
Some(string_callback), Some(string_callback),
&mut result as *mut String as *mut ::std::os::raw::c_void, &mut result as *mut String as *mut c_void,
) )
}; };
} }
@ -175,7 +177,7 @@ fn primop_allocation_and_registration() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -198,7 +200,7 @@ fn primop_allocation_and_registration() {
let arg_names = [CString::new("x").unwrap()]; let arg_names = [CString::new("x").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect(); let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs; let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null()); arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("addOne").unwrap(); let name = CString::new("addOne").unwrap();
let doc = CString::new("Add 1 to the argument").unwrap(); let doc = CString::new("Add 1 to the argument").unwrap();
@ -211,7 +213,7 @@ fn primop_allocation_and_registration() {
name.as_ptr(), name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(), arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(), doc.as_ptr(),
test_data_ptr as *mut ::std::os::raw::c_void, test_data_ptr as *mut c_void,
); );
if !primop.is_null() { if !primop.is_null() {
@ -259,7 +261,7 @@ fn primop_function_call() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -281,7 +283,7 @@ fn primop_function_call() {
// Create simple hello world PrimOp (no arguments) // Create simple hello world PrimOp (no arguments)
let name = CString::new("helloWorld").unwrap(); let name = CString::new("helloWorld").unwrap();
let doc = CString::new("Returns hello world string").unwrap(); let doc = CString::new("Returns hello world string").unwrap();
let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()]; let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
let hello_primop = nix_alloc_primop( let hello_primop = nix_alloc_primop(
ctx, ctx,
@ -290,7 +292,7 @@ fn primop_function_call() {
name.as_ptr(), name.as_ptr(),
empty_args.as_mut_ptr(), empty_args.as_mut_ptr(),
doc.as_ptr(), doc.as_ptr(),
std::ptr::null_mut(), ptr::null_mut(),
); );
if !hello_primop.is_null() { if !hello_primop.is_null() {
@ -305,7 +307,7 @@ fn primop_function_call() {
let result = nix_alloc_value(ctx, state); let result = nix_alloc_value(ctx, state);
assert!(!result.is_null()); assert!(!result.is_null());
let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result); let call_err = nix_value_call(ctx, state, primop_value, ptr::null_mut(), result);
if call_err == NixErr::Ok { if call_err == NixErr::Ok {
// Force the result // Force the result
let force_err = nix_value_force(ctx, state, result); let force_err = nix_value_force(ctx, state, result);
@ -316,13 +318,12 @@ fn primop_function_call() {
if result_type == ValueType::String { if result_type == ValueType::String {
// Get string value // Get string value
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char, start: *const c_char,
n: ::std::os::raw::c_uint, n: c_uint,
user_data: *mut ::std::os::raw::c_void, user_data: *mut c_void,
) { ) {
let s = let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) }; let s = str::from_utf8(s).unwrap_or("");
let s = std::str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) }; let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string()); *result = Some(s.to_string());
} }
@ -332,7 +333,7 @@ fn primop_function_call() {
ctx, ctx,
result, result,
Some(string_callback), Some(string_callback),
&mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void, &mut string_result as *mut Option<String> as *mut c_void,
); );
// Verify we got the expected string // Verify we got the expected string
@ -374,7 +375,7 @@ fn primop_with_arguments() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -397,7 +398,7 @@ fn primop_with_arguments() {
let arg_names = [CString::new("x").unwrap()]; let arg_names = [CString::new("x").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect(); let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs; let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null()); arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("addOne").unwrap(); let name = CString::new("addOne").unwrap();
let doc = CString::new("Add 1 to the argument").unwrap(); let doc = CString::new("Add 1 to the argument").unwrap();
@ -409,7 +410,7 @@ fn primop_with_arguments() {
name.as_ptr(), name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(), arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(), doc.as_ptr(),
test_data_ptr as *mut ::std::os::raw::c_void, test_data_ptr as *mut c_void,
); );
if !add_primop.is_null() { if !add_primop.is_null() {
@ -480,7 +481,7 @@ fn primop_multi_argument() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -496,7 +497,7 @@ fn primop_multi_argument() {
let arg_names = [CString::new("s1").unwrap(), CString::new("s2").unwrap()]; let arg_names = [CString::new("s1").unwrap(), CString::new("s2").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect(); let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs; let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null()); arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("concatStrings").unwrap(); let name = CString::new("concatStrings").unwrap();
let doc = CString::new("Concatenate two strings").unwrap(); let doc = CString::new("Concatenate two strings").unwrap();
@ -508,7 +509,7 @@ fn primop_multi_argument() {
name.as_ptr(), name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(), arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(), doc.as_ptr(),
std::ptr::null_mut(), ptr::null_mut(),
); );
if !concat_primop.is_null() { if !concat_primop.is_null() {
@ -548,13 +549,12 @@ fn primop_multi_argument() {
let result_type = nix_get_type(ctx, result); let result_type = nix_get_type(ctx, result);
if result_type == ValueType::String { if result_type == ValueType::String {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char, start: *const c_char,
n: ::std::os::raw::c_uint, n: c_uint,
user_data: *mut ::std::os::raw::c_void, user_data: *mut c_void,
) { ) {
let s = let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) }; let s = str::from_utf8(s).unwrap_or("");
let s = std::str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) }; let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string()); *result = Some(s.to_string());
} }
@ -564,7 +564,7 @@ fn primop_multi_argument() {
ctx, ctx,
result, result,
Some(string_callback), Some(string_callback),
&mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void, &mut string_result as *mut Option<String> as *mut c_void,
); );
// Verify concatenation worked // Verify concatenation worked
@ -601,7 +601,7 @@ fn primop_error_handling() {
let err = nix_libexpr_init(ctx); let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store); let builder = nix_eval_state_builder_new(ctx, store);
@ -616,7 +616,7 @@ fn primop_error_handling() {
// Test invalid PrimOp allocation (NULL callback) // Test invalid PrimOp allocation (NULL callback)
let name = CString::new("invalid").unwrap(); let name = CString::new("invalid").unwrap();
let doc = CString::new("Invalid PrimOp").unwrap(); let doc = CString::new("Invalid PrimOp").unwrap();
let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()]; let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
let _invalid_primop = nix_alloc_primop( let _invalid_primop = nix_alloc_primop(
ctx, ctx,
@ -625,7 +625,7 @@ fn primop_error_handling() {
name.as_ptr(), name.as_ptr(),
empty_args.as_mut_ptr(), empty_args.as_mut_ptr(),
doc.as_ptr(), doc.as_ptr(),
std::ptr::null_mut(), ptr::null_mut(),
); );
// Test initializing value with NULL PrimOp (should fail) // Test initializing value with NULL PrimOp (should fail)

57
nixide-sys/tests/store.rs
View file

@ -1,8 +1,9 @@
#![cfg(feature = "nix-store-c")] #![cfg(feature = "nix-store-c")]
#![cfg(test)] #![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString; use std::ffi::CString;
use std::ptr; use std::{ptr, slice, str};
use serial_test::serial; use serial_test::serial;
@ -61,13 +62,9 @@ fn parse_and_clone_free_store_path() {
#[test] #[test]
#[serial] #[serial]
fn store_get_uri_and_storedir() { fn store_get_uri_and_storedir() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) }; unsafe { *out = Some(s.to_string()) };
} }
@ -116,13 +113,9 @@ fn libstore_init_no_load_config() {
#[test] #[test]
#[serial] #[serial]
fn store_is_valid_path_and_real_path() { fn store_is_valid_path_and_real_path() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) }; unsafe { *out = Some(s.to_string()) };
} }
@ -133,7 +126,7 @@ fn store_is_valid_path_and_real_path() {
let err = nix_libstore_init(ctx); let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
// Use a dummy path (should not be valid, but should not crash) // Use a dummy path (should not be valid, but should not crash)
@ -164,13 +157,9 @@ fn store_is_valid_path_and_real_path() {
#[test] #[test]
#[serial] #[serial]
fn store_path_name() { fn store_path_name() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) }; unsafe { *out = Some(s.to_string()) };
} }
@ -181,7 +170,7 @@ fn store_path_name() {
let err = nix_libstore_init(ctx); let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let path_str = CString::new("/nix/store/foo-bar-baz").unwrap(); let path_str = CString::new("/nix/store/foo-bar-baz").unwrap();
@ -202,13 +191,9 @@ fn store_path_name() {
#[test] #[test]
#[serial] #[serial]
fn store_get_version() { fn store_get_version() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) }; unsafe { *out = Some(s.to_string()) };
} }
@ -219,7 +204,7 @@ fn store_get_version() {
let err = nix_libstore_init(ctx); let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
let mut version: Option<String> = None; let mut version: Option<String> = None;
@ -238,8 +223,8 @@ fn store_get_version() {
#[serial] #[serial]
fn store_realise_and_copy_closure() { fn store_realise_and_copy_closure() {
unsafe extern "C" fn realise_callback( unsafe extern "C" fn realise_callback(
_userdata: *mut ::std::os::raw::c_void, _userdata: *mut c_void,
outname: *const ::std::os::raw::c_char, outname: *const c_char,
out: *const StorePath, out: *const StorePath,
) { ) {
// Just check that callback is called with non-null pointers // Just check that callback is called with non-null pointers
@ -253,7 +238,7 @@ fn store_realise_and_copy_closure() {
let err = nix_libstore_init(ctx); let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok); assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null()); assert!(!store.is_null());
// Use a dummy path (should not crash, may not realise) // Use a dummy path (should not crash, may not realise)
@ -265,7 +250,7 @@ fn store_realise_and_copy_closure() {
ctx, ctx,
store, store,
store_path, store_path,
std::ptr::null_mut(), ptr::null_mut(),
Some(realise_callback), Some(realise_callback),
); );

28
nixide-sys/tests/util.rs
View file

@ -1,7 +1,9 @@
#![cfg(feature = "nix-util-c")] #![cfg(feature = "nix-util-c")]
#![cfg(test)] #![cfg(test)]
use std::ffi::{CStr, CString}; use core::ffi::{CStr, c_char, c_uint, c_void};
use std::ffi::CString;
use std::{slice, str};
use serial_test::serial; use serial_test::serial;
@ -47,13 +49,9 @@ fn version_get() {
#[test] #[test]
#[serial] #[serial]
fn setting_set_and_get() { fn setting_set_and_get() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
*unsafe { &mut *out } = Some(s.to_string()); *unsafe { &mut *out } = Some(s.to_string());
} }
@ -98,13 +96,9 @@ fn setting_set_and_get() {
#[test] #[test]
#[serial] #[serial]
fn error_handling_apis() { fn error_handling_apis() {
unsafe extern "C" fn string_callback( unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
start: *const ::std::os::raw::c_char, let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
n: ::std::os::raw::c_uint, let s = str::from_utf8(s).unwrap();
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>(); let out = user_data.cast::<Option<String>>();
*unsafe { &mut *out } = Some(s.to_string()); *unsafe { &mut *out } = Some(s.to_string());
} }
@ -125,10 +119,10 @@ fn error_handling_apis() {
assert_eq!(code, NixErr::Unknown); assert_eq!(code, NixErr::Unknown);
// Get error message // Get error message
let mut len: std::os::raw::c_uint = 0; let mut len: c_uint = 0;
let err_msg_ptr = nix_err_msg(ctx, ctx, &mut len as *mut _); let err_msg_ptr = nix_err_msg(ctx, ctx, &mut len as *mut _);
if !err_msg_ptr.is_null() && len > 0 { if !err_msg_ptr.is_null() && len > 0 {
let err_msg = std::str::from_utf8(std::slice::from_raw_parts( let err_msg = str::from_utf8(slice::from_raw_parts(
err_msg_ptr as *const u8, err_msg_ptr as *const u8,
len as usize, len as usize,
)) ))

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

@ -94,7 +94,7 @@ pub enum NixError {
/// [NixError::Undocumented] has no equivalent in the `libnix` api. /// [NixError::Undocumented] has no equivalent in the `libnix` api.
/// This is solely a language difference between C++ and Rust, since /// This is solely a language difference between C++ and Rust, since
/// [sys::NixErr] is defined over the *"continuous" (not realy)* /// [sys::NixErr] is defined over the *"continuous" (not realy)*
/// type [std::os::raw::c_int]. /// type [::core::ffi::c_int].
Undocumented(sys::NixErr), Undocumented(sys::NixErr),
} }

3
nixide/src/flake/flake_reference.rs
View file

@ -1,5 +1,4 @@
use std::ffi::c_void; use std::ffi::{c_char, c_void};
use std::os::raw::c_char;
use std::ptr::{NonNull, null_mut}; use std::ptr::{NonNull, null_mut};
use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings}; use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings};

2
nixide/src/flake/flake_reference_parse_flags.rs
View file

@ -1,4 +1,4 @@
use std::os::raw::c_char; use std::ffi::c_char;
use std::ptr::NonNull; use std::ptr::NonNull;
use super::FlakeSettings; use super::FlakeSettings;