servicepoint/servicepoint-binding-c
0
2
Fork 0
Code Issues 1 Pull requests 1 Projects Releases 2 Packages Wiki Activity Actions

add /*notnull*/ comments in header, use NotNull for parameters

Browse source
This commit is contained in:
Vinzenz Schroeter 2025-04-12 12:19:10 +02:00
parent bb90af3a57
commit 40fed5ba04
13 changed files with 299 additions and 385 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/bitmap.rs
View file

@ -13,7 +13,7 @@
//! sp_bitmap_free(grid);
//! ```
use servicepoint::{DataRef, Grid};
use servicepoint::{Bitmap, DataRef, Grid};
use std::ptr::NonNull;
use crate::byte_slice::SPByteSlice;
@ -43,8 +43,8 @@ use crate::byte_slice::SPByteSlice;
pub unsafe extern "C" fn sp_bitmap_new(
width: usize,
height: usize,
) -> *mut servicepoint::Bitmap {
if let Some(bitmap) = servicepoint::Bitmap::new(width, height) {
) -> *mut Bitmap {
if let Some(bitmap) = Bitmap::new(width, height) {
Box::leak(Box::new(bitmap))
} else {
std::ptr::null_mut()
@ -62,9 +62,8 @@ pub unsafe extern "C" fn sp_bitmap_new(
/// - the returned instance is freed in some way, either by using a consuming function or
/// by explicitly calling [sp_bitmap_free].
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_new_screen_sized(
) -> NonNull<servicepoint::Bitmap> {
let result = Box::new(servicepoint::Bitmap::max_sized());
pub unsafe extern "C" fn sp_bitmap_new_screen_sized() -> NonNull<Bitmap> {
let result = Box::new(Bitmap::max_sized());
NonNull::from(Box::leak(result))
}
@ -99,12 +98,10 @@ pub unsafe extern "C" fn sp_bitmap_new_screen_sized(
pub unsafe extern "C" fn sp_bitmap_load(
width: usize,
height: usize,
data: *const u8,
data_length: usize,
) -> *mut servicepoint::Bitmap {
assert!(!data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, data_length) };
if let Ok(bitmap) = servicepoint::Bitmap::load(width, height, data) {
data: SPByteSlice,
) -> *mut Bitmap {
let data = unsafe { data.as_slice() };
if let Ok(bitmap) = Bitmap::load(width, height, data) {
Box::leak(Box::new(bitmap))
} else {
std::ptr::null_mut()
@ -129,10 +126,9 @@ pub unsafe extern "C" fn sp_bitmap_load(
/// by explicitly calling `sp_bitmap_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_clone(
bitmap: *const servicepoint::Bitmap,
) -> NonNull<servicepoint::Bitmap> {
assert!(!bitmap.is_null());
let result = Box::new(unsafe { (*bitmap).clone() });
bitmap: NonNull<Bitmap>,
) -> NonNull<Bitmap> {
let result = Box::new(unsafe { bitmap.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -147,14 +143,11 @@ pub unsafe extern "C" fn sp_bitmap_clone(
/// The caller has to make sure that:
///
/// - `bitmap` points to a valid [SPBitmap]
/// - `bitmap` is not used concurrently or after bitmap call
/// - `bitmap` was not passed to another consuming function, e.g. to create a [SPCommand]
///
/// [SPCommand]: [crate::SPCommand]
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_free(bitmap: *mut servicepoint::Bitmap) {
assert!(!bitmap.is_null());
_ = unsafe { Box::from_raw(bitmap) };
pub unsafe extern "C" fn sp_bitmap_free(bitmap: NonNull<Bitmap>) {
_ = unsafe { Box::from_raw(bitmap.as_ptr()) };
}
/// Gets the current value at the specified position in the [SPBitmap].
@ -177,12 +170,11 @@ pub unsafe extern "C" fn sp_bitmap_free(bitmap: *mut servicepoint::Bitmap) {
/// - `bitmap` is not written to concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_get(
bitmap: *const servicepoint::Bitmap,
bitmap: NonNull<Bitmap>,
x: usize,
y: usize,
) -> bool {
assert!(!bitmap.is_null());
unsafe { (*bitmap).get(x, y) }
unsafe { bitmap.as_ref().get(x, y) }
}
/// Sets the value of the specified position in the [SPBitmap].
@ -208,13 +200,12 @@ pub unsafe extern "C" fn sp_bitmap_get(
/// - `bitmap` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_set(
bitmap: *mut servicepoint::Bitmap,
bitmap: NonNull<Bitmap>,
x: usize,
y: usize,
value: bool,
) {
assert!(!bitmap.is_null());
unsafe { (*bitmap).set(x, y, value) };
unsafe { (*bitmap.as_ptr()).set(x, y, value) };
}
/// Sets the state of all pixels in the [SPBitmap].
@ -235,12 +226,8 @@ pub unsafe extern "C" fn sp_bitmap_set(
/// - `bitmap` points to a valid [SPBitmap]
/// - `bitmap` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_fill(
bitmap: *mut servicepoint::Bitmap,
value: bool,
) {
assert!(!bitmap.is_null());
unsafe { (*bitmap).fill(value) };
pub unsafe extern "C" fn sp_bitmap_fill(bitmap: NonNull<Bitmap>, value: bool) {
unsafe { (*bitmap.as_ptr()).fill(value) };
}
/// Gets the width in pixels of the [SPBitmap] instance.
@ -259,11 +246,8 @@ pub unsafe extern "C" fn sp_bitmap_fill(
///
/// - `bitmap` points to a valid [SPBitmap]
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_width(
bitmap: *const servicepoint::Bitmap,
) -> usize {
assert!(!bitmap.is_null());
unsafe { (*bitmap).width() }
pub unsafe extern "C" fn sp_bitmap_width(bitmap: NonNull<Bitmap>) -> usize {
unsafe { bitmap.as_ref().width() }
}
/// Gets the height in pixels of the [SPBitmap] instance.
@ -282,11 +266,8 @@ pub unsafe extern "C" fn sp_bitmap_width(
///
/// - `bitmap` points to a valid [SPBitmap]
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_height(
bitmap: *const servicepoint::Bitmap,
) -> usize {
assert!(!bitmap.is_null());
unsafe { (*bitmap).height() }
pub unsafe extern "C" fn sp_bitmap_height(bitmap: NonNull<Bitmap>) -> usize {
unsafe { bitmap.as_ref().height() }
}
/// Gets an unsafe reference to the data of the [SPBitmap] instance.
@ -304,8 +285,7 @@ pub unsafe extern "C" fn sp_bitmap_height(
/// - the returned memory range is never accessed concurrently, either via the [SPBitmap] or directly
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_unsafe_data_ref(
bitmap: *mut servicepoint::Bitmap,
mut bitmap: NonNull<Bitmap>,
) -> SPByteSlice {
assert!(!bitmap.is_null());
unsafe { SPByteSlice::from_slice((*bitmap).data_ref_mut()) }
unsafe { SPByteSlice::from_slice(bitmap.as_mut().data_ref_mut()) }
}

71
src/bitvec.rs
View file

@ -13,19 +13,7 @@ use std::ptr::NonNull;
/// sp_bitvec_set(vec, 5, true);
/// sp_bitvec_free(vec);
/// ```
pub struct SPBitVec(servicepoint::BitVecU8Msb0);
impl From<servicepoint::BitVecU8Msb0> for SPBitVec {
fn from(actual: servicepoint::BitVecU8Msb0) -> Self {
Self(actual)
}
}
impl From<SPBitVec> for servicepoint::BitVecU8Msb0 {
fn from(value: SPBitVec) -> Self {
value.0
}
}
pub struct SPBitVec(pub(crate) servicepoint::BitVecU8Msb0);
impl Clone for SPBitVec {
fn clone(&self) -> Self {
@ -53,7 +41,8 @@ impl Clone for SPBitVec {
/// by explicitly calling `sp_bitvec_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_new(size: usize) -> NonNull<SPBitVec> {
let result = Box::new(SPBitVec(servicepoint::BitVecU8Msb0::repeat(false, size)));
let result =
Box::new(SPBitVec(servicepoint::BitVecU8Msb0::repeat(false, size)));
NonNull::from(Box::leak(result))
}
@ -75,12 +64,11 @@ pub unsafe extern "C" fn sp_bitvec_new(size: usize) -> NonNull<SPBitVec> {
/// by explicitly calling `sp_bitvec_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_load(
data: *const u8,
data_length: usize,
data: SPByteSlice,
) -> NonNull<SPBitVec> {
assert!(!data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, data_length) };
let result = Box::new(SPBitVec(servicepoint::BitVecU8Msb0::from_slice(data)));
let data = unsafe { data.as_slice() };
let result =
Box::new(SPBitVec(servicepoint::BitVecU8Msb0::from_slice(data)));
NonNull::from(Box::leak(result))
}
@ -102,10 +90,9 @@ pub unsafe extern "C" fn sp_bitvec_load(
/// by explicitly calling `sp_bitvec_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_clone(
bit_vec: *const SPBitVec,
bit_vec: NonNull<SPBitVec>,
) -> NonNull<SPBitVec> {
assert!(!bit_vec.is_null());
let result = Box::new(unsafe { (*bit_vec).clone() });
let result = Box::new(unsafe { bit_vec.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -125,9 +112,8 @@ pub unsafe extern "C" fn sp_bitvec_clone(
///
/// [SPCommand]: [crate::SPCommand]
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_free(bit_vec: *mut SPBitVec) {
assert!(!bit_vec.is_null());
_ = unsafe { Box::from_raw(bit_vec) };
pub unsafe extern "C" fn sp_bitvec_free(bit_vec: NonNull<SPBitVec>) {
_ = unsafe { Box::from_raw(bit_vec.as_ptr()) };
}
/// Gets the value of a bit from the [SPBitVec].
@ -152,11 +138,10 @@ pub unsafe extern "C" fn sp_bitvec_free(bit_vec: *mut SPBitVec) {
/// - `bit_vec` is not written to concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_get(
bit_vec: *const SPBitVec,
bit_vec: NonNull<SPBitVec>,
index: usize,
) -> bool {
assert!(!bit_vec.is_null());
unsafe { *(*bit_vec).0.get(index).unwrap() }
unsafe { *bit_vec.as_ref().0.get(index).unwrap() }
}
/// Sets the value of a bit in the [SPBitVec].
@ -180,12 +165,11 @@ pub unsafe extern "C" fn sp_bitvec_get(
/// - `bit_vec` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_set(
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
index: usize,
value: bool,
) {
assert!(!bit_vec.is_null());
unsafe { (*bit_vec).0.set(index, value) }
unsafe { (*bit_vec.as_ptr()).0.set(index, value) }
}
/// Sets the value of all bits in the [SPBitVec].
@ -206,9 +190,11 @@ pub unsafe extern "C" fn sp_bitvec_set(
/// - `bit_vec` points to a valid [SPBitVec]
/// - `bit_vec` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_fill(bit_vec: *mut SPBitVec, value: bool) {
assert!(!bit_vec.is_null());
unsafe { (*bit_vec).0.fill(value) }
pub unsafe extern "C" fn sp_bitvec_fill(
bit_vec: NonNull<SPBitVec>,
value: bool,
) {
unsafe { (*bit_vec.as_ptr()).0.fill(value) }
}
/// Gets the length of the [SPBitVec] in bits.
@ -227,9 +213,8 @@ pub unsafe extern "C" fn sp_bitvec_fill(bit_vec: *mut SPBitVec, value: bool) {
///
/// - `bit_vec` points to a valid [SPBitVec]
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_len(bit_vec: *const SPBitVec) -> usize {
assert!(!bit_vec.is_null());
unsafe { (*bit_vec).0.len() }
pub unsafe extern "C" fn sp_bitvec_len(bit_vec: NonNull<SPBitVec>) -> usize {
unsafe { bit_vec.as_ref().0.len() }
}
/// Returns true if length is 0.
@ -248,9 +233,10 @@ pub unsafe extern "C" fn sp_bitvec_len(bit_vec: *const SPBitVec) -> usize {
///
/// - `bit_vec` points to a valid [SPBitVec]
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_is_empty(bit_vec: *const SPBitVec) -> bool {
assert!(!bit_vec.is_null());
unsafe { (*bit_vec).0.is_empty() }
pub unsafe extern "C" fn sp_bitvec_is_empty(
bit_vec: NonNull<SPBitVec>,
) -> bool {
unsafe { bit_vec.as_ref().0.is_empty() }
}
/// Gets an unsafe reference to the data of the [SPBitVec] instance.
@ -272,8 +258,7 @@ pub unsafe extern "C" fn sp_bitvec_is_empty(bit_vec: *const SPBitVec) -> bool {
/// - the returned memory range is never accessed concurrently, either via the [SPBitVec] or directly
#[no_mangle]
pub unsafe extern "C" fn sp_bitvec_unsafe_data_ref(
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
) -> SPByteSlice {
assert!(!bit_vec.is_null());
unsafe { SPByteSlice::from_slice((*bit_vec).0.as_raw_mut_slice() ) }
unsafe { SPByteSlice::from_slice((*bit_vec.as_ptr()).0.as_raw_mut_slice()) }
}

56
src/brightness_grid.rs
View file

@ -32,7 +32,6 @@ pub const SP_BRIGHTNESS_MAX: u8 = 11;
/// Count of possible brightness values
pub const SP_BRIGHTNESS_LEVELS: u8 = 12;
/// Creates a new [SPBrightnessGrid] with the specified dimensions.
///
/// returns: [SPBrightnessGrid] initialized to 0. Will never return NULL.
@ -48,9 +47,7 @@ pub unsafe extern "C" fn sp_brightness_grid_new(
width: usize,
height: usize,
) -> NonNull<BrightnessGrid> {
let result = Box::new(servicepoint::BrightnessGrid::new(
width, height,
));
let result = Box::new(BrightnessGrid::new(width, height));
NonNull::from(Box::leak(result))
}
@ -75,16 +72,14 @@ pub unsafe extern "C" fn sp_brightness_grid_new(
pub unsafe extern "C" fn sp_brightness_grid_load(
width: usize,
height: usize,
data: *const u8,
data_length: usize,
data: SPByteSlice,
) -> *mut BrightnessGrid {
assert!(!data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, data_length) };
let data = unsafe { data.as_slice() };
let grid = match servicepoint::ByteGrid::load(width, height, data) {
None => return std::ptr::null_mut(),
Some(grid) => grid,
};
if let Ok(grid) = servicepoint::BrightnessGrid::try_from(grid) {
if let Ok(grid) = BrightnessGrid::try_from(grid) {
Box::leak(Box::new(grid))
} else {
std::ptr::null_mut()
@ -113,10 +108,9 @@ pub unsafe extern "C" fn sp_brightness_grid_load(
/// by explicitly calling `sp_brightness_grid_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_clone(
brightness_grid: *const BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
) -> NonNull<BrightnessGrid> {
assert!(!brightness_grid.is_null());
let result = Box::new(unsafe { (*brightness_grid).clone() });
let result = Box::new(unsafe { brightness_grid.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -141,10 +135,9 @@ pub unsafe extern "C" fn sp_brightness_grid_clone(
/// [SPCommand]: [crate::SPCommand]
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_free(
brightness_grid: *mut BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
) {
assert!(!brightness_grid.is_null());
_ = unsafe { Box::from_raw(brightness_grid) };
_ = unsafe { Box::from_raw(brightness_grid.as_ptr()) };
}
/// Gets the current value at the specified position.
@ -169,12 +162,11 @@ pub unsafe extern "C" fn sp_brightness_grid_free(
/// - `brightness_grid` is not written to concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_get(
brightness_grid: *const BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
x: usize,
y: usize,
) -> u8 {
assert!(!brightness_grid.is_null());
unsafe { (*brightness_grid).get(x, y) }.into()
unsafe { brightness_grid.as_ref().get(x, y) }.into()
}
/// Sets the value of the specified position in the [SPBrightnessGrid].
@ -201,15 +193,14 @@ pub unsafe extern "C" fn sp_brightness_grid_get(
/// - `brightness_grid` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_set(
brightness_grid: *mut BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
x: usize,
y: usize,
value: u8,
) {
assert!(!brightness_grid.is_null());
let brightness = servicepoint::Brightness::try_from(value)
.expect("invalid brightness value");
unsafe { (*brightness_grid).set(x, y, brightness) };
unsafe { (*brightness_grid.as_ptr()).set(x, y, brightness) };
}
/// Sets the value of all cells in the [SPBrightnessGrid].
@ -232,13 +223,12 @@ pub unsafe extern "C" fn sp_brightness_grid_set(
/// - `brightness_grid` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_fill(
brightness_grid: *mut BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
value: u8,
) {
assert!(!brightness_grid.is_null());
let brightness = servicepoint::Brightness::try_from(value)
.expect("invalid brightness value");
unsafe { (*brightness_grid).fill(brightness) };
unsafe { (*brightness_grid.as_ptr()).fill(brightness) };
}
/// Gets the width of the [SPBrightnessGrid] instance.
@ -260,10 +250,9 @@ pub unsafe extern "C" fn sp_brightness_grid_fill(
/// - `brightness_grid` points to a valid [SPBrightnessGrid]
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_width(
brightness_grid: *const BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
) -> usize {
assert!(!brightness_grid.is_null());
unsafe { (*brightness_grid).width() }
unsafe { brightness_grid.as_ref().width() }
}
/// Gets the height of the [SPBrightnessGrid] instance.
@ -285,10 +274,9 @@ pub unsafe extern "C" fn sp_brightness_grid_width(
/// - `brightness_grid` points to a valid [SPBrightnessGrid]
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_height(
brightness_grid: *const BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
) -> usize {
assert!(!brightness_grid.is_null());
unsafe { (*brightness_grid).height() }
unsafe { brightness_grid.as_ref().height() }
}
/// Gets an unsafe reference to the data of the [SPBrightnessGrid] instance.
@ -312,12 +300,10 @@ pub unsafe extern "C" fn sp_brightness_grid_height(
/// - the returned memory range is never accessed concurrently, either via the [SPBrightnessGrid] or directly
#[no_mangle]
pub unsafe extern "C" fn sp_brightness_grid_unsafe_data_ref(
brightness_grid: *mut BrightnessGrid,
brightness_grid: NonNull<BrightnessGrid>,
) -> SPByteSlice {
assert!(!brightness_grid.is_null());
assert_eq!(core::mem::size_of::<servicepoint::Brightness>(), 1);
let data = unsafe { (*brightness_grid).data_ref_mut() };
assert_eq!(size_of::<servicepoint::Brightness>(), 1);
let data = unsafe { (*brightness_grid.as_ptr()).data_ref_mut() };
// this assumes more about the memory layout than rust guarantees. yikes!
unsafe { SPByteSlice::from_slice(transmute(data)) }
}

2
src/byte_slice.rs
View file

@ -28,7 +28,7 @@ impl SPByteSlice {
unsafe { std::slice::from_raw_parts(self.start.as_ptr(), self.length) }
}
pub(crate) unsafe fn as_slice_mut(&mut self) -> &mut [u8] {
pub(crate) unsafe fn as_slice_mut(&self) -> &mut [u8] {
unsafe {
std::slice::from_raw_parts_mut(self.start.as_ptr(), self.length)
}

50
src/char_grid.rs
View file

@ -18,6 +18,7 @@
//! sp_char_grid_free(grid);
//! ```
use crate::SPByteSlice;
use servicepoint::{CharGrid, Grid};
use std::ptr::NonNull;
@ -36,7 +37,7 @@ pub unsafe extern "C" fn sp_char_grid_new(
width: usize,
height: usize,
) -> NonNull<CharGrid> {
let result = Box::new(CharGrid::new(width, height));
let result = Box::new(CharGrid::new(width, height));
NonNull::from(Box::leak(result))
}
@ -62,16 +63,12 @@ pub unsafe extern "C" fn sp_char_grid_new(
pub unsafe extern "C" fn sp_char_grid_load(
width: usize,
height: usize,
data: *const u8,
data_length: usize,
data: SPByteSlice,
) -> NonNull<CharGrid> {
assert!(data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, data_length) };
let data = unsafe { data.as_slice() };
// TODO remove unwrap
let result = Box::new(
CharGrid::load_utf8(width, height, data.to_vec())
.unwrap(),
);
let result =
Box::new(CharGrid::load_utf8(width, height, data.to_vec()).unwrap());
NonNull::from(Box::leak(result))
}
@ -93,10 +90,9 @@ pub unsafe extern "C" fn sp_char_grid_load(
/// by explicitly calling `sp_char_grid_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_clone(
char_grid: *const CharGrid,
char_grid: NonNull<CharGrid>,
) -> NonNull<CharGrid> {
assert!(!char_grid.is_null());
let result = Box::new(unsafe { (*char_grid).clone() });
let result = Box::new(unsafe { char_grid.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -116,9 +112,8 @@ pub unsafe extern "C" fn sp_char_grid_clone(
///
/// [SPCommand]: [crate::SPCommand]
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_free(char_grid: *mut CharGrid) {
assert!(!char_grid.is_null());
_ = unsafe { Box::from_raw(char_grid) };
pub unsafe extern "C" fn sp_char_grid_free(char_grid: NonNull<CharGrid>) {
_ = unsafe { Box::from_raw(char_grid.as_ptr()) };
}
/// Gets the current value at the specified position.
@ -141,12 +136,11 @@ pub unsafe extern "C" fn sp_char_grid_free(char_grid: *mut CharGrid) {
/// - `char_grid` is not written to concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_get(
char_grid: *const CharGrid,
char_grid: NonNull<CharGrid>,
x: usize,
y: usize,
) -> u32 {
assert!(!char_grid.is_null());
unsafe { (*char_grid).get(x, y) as u32 }
unsafe { char_grid.as_ref().get(x, y) as u32 }
}
/// Sets the value of the specified position in the [SPCharGrid].
@ -174,13 +168,12 @@ pub unsafe extern "C" fn sp_char_grid_get(
/// [SPBitVec]: [crate::SPBitVec]
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_set(
char_grid: *mut CharGrid,
char_grid: NonNull<CharGrid>,
x: usize,
y: usize,
value: u32,
) {
assert!(!char_grid.is_null());
unsafe { (*char_grid).set(x, y, char::from_u32(value).unwrap()) };
unsafe { (*char_grid.as_ptr()).set(x, y, char::from_u32(value).unwrap()) };
}
/// Sets the value of all cells in the [SPCharGrid].
@ -202,11 +195,10 @@ pub unsafe extern "C" fn sp_char_grid_set(
/// - `char_grid` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_fill(
char_grid: *mut CharGrid,
char_grid: NonNull<CharGrid>,
value: u32,
) {
assert!(!char_grid.is_null());
unsafe { (*char_grid).fill(char::from_u32(value).unwrap()) };
unsafe { (*char_grid.as_ptr()).fill(char::from_u32(value).unwrap()) };
}
/// Gets the width of the [SPCharGrid] instance.
@ -226,10 +218,9 @@ pub unsafe extern "C" fn sp_char_grid_fill(
/// - `char_grid` points to a valid [SPCharGrid]
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_width(
char_grid: *const CharGrid,
char_grid: NonNull<CharGrid>,
) -> usize {
assert!(!char_grid.is_null());
unsafe { (*char_grid).width() }
unsafe { char_grid.as_ref().width() }
}
/// Gets the height of the [SPCharGrid] instance.
@ -249,8 +240,7 @@ pub unsafe extern "C" fn sp_char_grid_width(
/// - `char_grid` points to a valid [SPCharGrid]
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_height(
char_grid: *const CharGrid,
char_grid: NonNull<CharGrid>,
) -> usize {
assert!(!char_grid.is_null());
unsafe { (*char_grid).height() }
unsafe { char_grid.as_ref().height() }
}

84
src/command.rs
View file

@ -2,8 +2,11 @@
//!
//! prefix `sp_command_`
use crate::{SPBitVec};
use servicepoint::{BinaryOperation, BrightnessGrid, CharGrid, CompressionCode, Cp437Grid, GlobalBrightnessCommand, Packet, TypedCommand};
use crate::SPBitVec;
use servicepoint::{
BinaryOperation, Bitmap, BrightnessGrid, CharGrid, CompressionCode,
Cp437Grid, GlobalBrightnessCommand, Packet, TypedCommand,
};
use std::ptr::NonNull;
/// A low-level display command.
@ -21,7 +24,6 @@ use std::ptr::NonNull;
///
/// [SPConnection]: [crate::SPConnection]
/// Tries to turn a [SPPacket] into a [SPCommand].
///
/// The packet is deallocated in the process.
@ -43,9 +45,9 @@ use std::ptr::NonNull;
/// by explicitly calling `sp_command_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_command_try_from_packet(
packet: *mut Packet,
packet: NonNull<Packet>,
) -> *mut TypedCommand {
let packet = *unsafe { Box::from_raw(packet) };
let packet = *unsafe { Box::from_raw(packet.as_ptr()) };
match servicepoint::TypedCommand::try_from(packet) {
Err(_) => std::ptr::null_mut(),
Ok(command) => Box::into_raw(Box::new(command)),
@ -70,10 +72,9 @@ pub unsafe extern "C" fn sp_command_try_from_packet(
/// by explicitly calling `sp_command_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_command_clone(
command: *const TypedCommand,
command: NonNull<TypedCommand>,
) -> NonNull<TypedCommand> {
assert!(!command.is_null());
let result = Box::new(unsafe { (*command).clone() });
let result = Box::new(unsafe { command.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -155,8 +156,7 @@ pub unsafe extern "C" fn sp_command_brightness(
) -> NonNull<TypedCommand> {
let brightness = servicepoint::Brightness::try_from(brightness)
.expect("invalid brightness");
let result =
Box::new(GlobalBrightnessCommand::from(brightness).into());
let result = Box::new(GlobalBrightnessCommand::from(brightness).into());
NonNull::from(Box::leak(result))
}
@ -182,10 +182,9 @@ pub unsafe extern "C" fn sp_command_brightness(
pub unsafe extern "C" fn sp_command_char_brightness(
x: usize,
y: usize,
grid: *mut BrightnessGrid,
grid: NonNull<BrightnessGrid>,
) -> NonNull<TypedCommand> {
assert!(!grid.is_null());
let grid = unsafe { *Box::from_raw(grid) };
let grid = unsafe { *Box::from_raw(grid.as_ptr()) };
let result = Box::new(
servicepoint::BrightnessGridCommand {
origin: servicepoint::Origin::new(x, y),
@ -224,7 +223,7 @@ pub unsafe extern "C" fn sp_command_char_brightness(
#[no_mangle]
pub unsafe extern "C" fn sp_command_bitmap_linear(
offset: usize,
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
compression: CompressionCode,
) -> *mut TypedCommand {
unsafe {
@ -265,7 +264,7 @@ pub unsafe extern "C" fn sp_command_bitmap_linear(
#[no_mangle]
pub unsafe extern "C" fn sp_command_bitmap_linear_and(
offset: usize,
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
compression: CompressionCode,
) -> *mut TypedCommand {
unsafe {
@ -306,7 +305,7 @@ pub unsafe extern "C" fn sp_command_bitmap_linear_and(
#[no_mangle]
pub unsafe extern "C" fn sp_command_bitmap_linear_or(
offset: usize,
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
compression: CompressionCode,
) -> *mut TypedCommand {
unsafe {
@ -347,7 +346,7 @@ pub unsafe extern "C" fn sp_command_bitmap_linear_or(
#[no_mangle]
pub unsafe extern "C" fn sp_command_bitmap_linear_xor(
offset: usize,
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
compression: CompressionCode,
) -> *mut TypedCommand {
unsafe {
@ -363,23 +362,22 @@ pub unsafe extern "C" fn sp_command_bitmap_linear_xor(
#[inline]
unsafe fn sp_command_bitmap_linear_internal(
offset: usize,
bit_vec: *mut SPBitVec,
bit_vec: NonNull<SPBitVec>,
compression: CompressionCode,
operation: BinaryOperation,
) -> *mut TypedCommand {
assert!(!bit_vec.is_null());
let bit_vec = unsafe { *Box::from_raw(bit_vec) };
let bit_vec = unsafe { *Box::from_raw(bit_vec.as_ptr()) };
let compression = match compression.try_into() {
Ok(compression) => compression,
Err(_) => return std::ptr::null_mut(),
};
let command = servicepoint::BitVecCommand {
offset,
operation,
bitvec: bit_vec.into(),
compression,
}
.into();
let command = servicepoint::BitVecCommand {
offset,
operation,
bitvec: bit_vec.0,
compression,
}
.into();
Box::leak(Box::new(command))
}
@ -405,10 +403,9 @@ unsafe fn sp_command_bitmap_linear_internal(
pub unsafe extern "C" fn sp_command_cp437_data(
x: usize,
y: usize,
grid: *mut Cp437Grid,
grid: NonNull<Cp437Grid>,
) -> NonNull<TypedCommand> {
assert!(!grid.is_null());
let grid = *unsafe { Box::from_raw(grid) };
let grid = *unsafe { Box::from_raw(grid.as_ptr()) };
let result = Box::new(
servicepoint::Cp437GridCommand {
origin: servicepoint::Origin::new(x, y),
@ -441,10 +438,9 @@ pub unsafe extern "C" fn sp_command_cp437_data(
pub unsafe extern "C" fn sp_command_utf8_data(
x: usize,
y: usize,
grid: *mut CharGrid,
grid: NonNull<CharGrid>,
) -> NonNull<TypedCommand> {
assert!(!grid.is_null());
let grid = unsafe { *Box::from_raw(grid) };
let grid = unsafe { *Box::from_raw(grid.as_ptr()) };
let result = Box::new(
servicepoint::CharGridCommand {
origin: servicepoint::Origin::new(x, y),
@ -479,21 +475,20 @@ pub unsafe extern "C" fn sp_command_utf8_data(
pub unsafe extern "C" fn sp_command_bitmap_linear_win(
x: usize,
y: usize,
bitmap: *mut servicepoint::Bitmap,
bitmap: NonNull<Bitmap>,
compression: CompressionCode,
) -> *mut TypedCommand {
assert!(!bitmap.is_null());
let bitmap = unsafe { *Box::from_raw(bitmap) };
let bitmap = unsafe { *Box::from_raw(bitmap.as_ptr()) };
let compression = match compression.try_into() {
Ok(compression) => compression,
Err(_) => return std::ptr::null_mut(),
};
let command = servicepoint::BitmapCommand {
origin: servicepoint::Origin::new(x, y),
bitmap,
compression,
}
.into();
let command = servicepoint::BitmapCommand {
origin: servicepoint::Origin::new(x, y),
bitmap,
compression,
}
.into();
Box::leak(Box::new(command))
}
@ -518,7 +513,6 @@ pub unsafe extern "C" fn sp_command_bitmap_linear_win(
/// - `command` is not used concurrently or after this call
/// - `command` was not passed to another consuming function, e.g. to create a [SPPacket]
#[no_mangle]
pub unsafe extern "C" fn sp_command_free(command: *mut TypedCommand) {
assert!(!command.is_null());
_ = unsafe { Box::from_raw(command) };
pub unsafe extern "C" fn sp_command_free(command: NonNull<TypedCommand>) {
_ = unsafe { Box::from_raw(command.as_ptr()) };
}

33
src/connection.rs
View file

@ -14,6 +14,7 @@
use servicepoint::{Connection, Packet, TypedCommand, UdpConnection};
use std::ffi::{c_char, CStr};
use std::ptr::NonNull;
/// Creates a new instance of [SPConnection].
///
@ -31,10 +32,9 @@ use std::ffi::{c_char, CStr};
/// by explicitly calling `sp_connection_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_connection_open(
host: *const c_char,
host: NonNull<c_char>,
) -> *mut UdpConnection {
assert!(!host.is_null());
let host = unsafe { CStr::from_ptr(host) }
let host = unsafe { CStr::from_ptr(host.as_ptr()) }
.to_str()
.expect("Bad encoding");
let connection = match UdpConnection::open(host) {
@ -93,13 +93,11 @@ pub unsafe extern "C" fn sp_connection_open(
/// - `packet` is not used concurrently or after this call
#[no_mangle]
pub unsafe extern "C" fn sp_connection_send_packet(
connection: *const UdpConnection,
packet: *mut Packet,
connection: NonNull<UdpConnection>,
packet: NonNull<Packet>,
) -> bool {
assert!(!connection.is_null());
assert!(!packet.is_null());
let packet = unsafe { Box::from_raw(packet) };
unsafe { (*connection).send(*packet) }.is_ok()
let packet = unsafe { Box::from_raw(packet.as_ptr()) };
unsafe { connection.as_ref().send(*packet) }.is_ok()
}
/// Sends a [SPCommand] to the display using the [SPConnection].
@ -122,13 +120,11 @@ pub unsafe extern "C" fn sp_connection_send_packet(
/// - `command` is not used concurrently or after this call
#[no_mangle]
pub unsafe extern "C" fn sp_connection_send_command(
connection: *const UdpConnection,
command: *mut TypedCommand,
connection: NonNull<UdpConnection>,
command: NonNull<TypedCommand>,
) -> bool {
assert!(!connection.is_null());
assert!(!command.is_null());
let command = *unsafe { Box::from_raw(command) };
unsafe { (*connection).send(command) }.is_ok()
let command = *unsafe { Box::from_raw(command.as_ptr()) };
unsafe { connection.as_ref().send(command) }.is_ok()
}
/// Closes and deallocates a [SPConnection].
@ -144,7 +140,8 @@ pub unsafe extern "C" fn sp_connection_send_command(
/// - `connection` points to a valid [SPConnection]
/// - `connection` is not used concurrently or after this call
#[no_mangle]
pub unsafe extern "C" fn sp_connection_free(connection: *mut UdpConnection) {
assert!(!connection.is_null());
_ = unsafe { Box::from_raw(connection) };
pub unsafe extern "C" fn sp_connection_free(
connection: NonNull<UdpConnection>,
) {
_ = unsafe { Box::from_raw(connection.as_ptr()) };
}

47
src/cp437_grid.rs
View file

@ -35,7 +35,7 @@ pub unsafe extern "C" fn sp_cp437_grid_new(
width: usize,
height: usize,
) -> NonNull<Cp437Grid> {
let result = Box::new(Cp437Grid::new(width, height));
let result = Box::new(Cp437Grid::new(width, height));
NonNull::from(Box::leak(result))
}
@ -60,11 +60,9 @@ pub unsafe extern "C" fn sp_cp437_grid_new(
pub unsafe extern "C" fn sp_cp437_grid_load(
width: usize,
height: usize,
data: *const u8,
data_length: usize,
data: SPByteSlice,
) -> *mut Cp437Grid {
assert!(data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, data_length) };
let data = unsafe { data.as_slice() };
let grid = Cp437Grid::load(width, height, data);
if let Some(grid) = grid {
Box::leak(Box::new(grid))
@ -91,10 +89,9 @@ pub unsafe extern "C" fn sp_cp437_grid_load(
/// by explicitly calling `sp_cp437_grid_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_clone(
cp437_grid: *const Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
) -> NonNull<Cp437Grid> {
assert!(!cp437_grid.is_null());
let result = Box::new(unsafe { (*cp437_grid).clone() });
let result = Box::new(unsafe { cp437_grid.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -114,9 +111,8 @@ pub unsafe extern "C" fn sp_cp437_grid_clone(
///
/// [SPCommand]: [crate::SPCommand]
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_free(cp437_grid: *mut Cp437Grid) {
assert!(!cp437_grid.is_null());
_ = unsafe { Box::from_raw(cp437_grid) };
pub unsafe extern "C" fn sp_cp437_grid_free(cp437_grid: NonNull<Cp437Grid>) {
_ = unsafe { Box::from_raw(cp437_grid.as_ptr()) };
}
/// Gets the current value at the specified position.
@ -139,12 +135,11 @@ pub unsafe extern "C" fn sp_cp437_grid_free(cp437_grid: *mut Cp437Grid) {
/// - `cp437_grid` is not written to concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_get(
cp437_grid: *const Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
x: usize,
y: usize,
) -> u8 {
assert!(!cp437_grid.is_null());
unsafe { (*cp437_grid).get(x, y) }
unsafe { cp437_grid.as_ref().get(x, y) }
}
/// Sets the value of the specified position in the [SPCp437Grid].
@ -172,13 +167,12 @@ pub unsafe extern "C" fn sp_cp437_grid_get(
/// [SPBitVec]: [crate::SPBitVec]
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_set(
cp437_grid: *mut Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
x: usize,
y: usize,
value: u8,
) {
assert!(!cp437_grid.is_null());
unsafe { (*cp437_grid).set(x, y, value) };
unsafe { (*cp437_grid.as_ptr()).set(x, y, value) };
}
/// Sets the value of all cells in the [SPCp437Grid].
@ -200,11 +194,10 @@ pub unsafe extern "C" fn sp_cp437_grid_set(
/// - `cp437_grid` is not written to or read from concurrently
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_fill(
cp437_grid: *mut Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
value: u8,
) {
assert!(!cp437_grid.is_null());
unsafe { (*cp437_grid).fill(value) };
unsafe { (*cp437_grid.as_ptr()).fill(value) };
}
/// Gets the width of the [SPCp437Grid] instance.
@ -224,10 +217,9 @@ pub unsafe extern "C" fn sp_cp437_grid_fill(
/// - `cp437_grid` points to a valid [SPCp437Grid]
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_width(
cp437_grid: *const Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
) -> usize {
assert!(!cp437_grid.is_null());
unsafe { (*cp437_grid).width() }
unsafe { cp437_grid.as_ref().width() }
}
/// Gets the height of the [SPCp437Grid] instance.
@ -247,10 +239,9 @@ pub unsafe extern "C" fn sp_cp437_grid_width(
/// - `cp437_grid` points to a valid [SPCp437Grid]
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_height(
cp437_grid: *const Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
) -> usize {
assert!(!cp437_grid.is_null());
unsafe { (*cp437_grid).height() }
unsafe { cp437_grid.as_ref().height() }
}
/// Gets an unsafe reference to the data of the [SPCp437Grid] instance.
@ -270,7 +261,7 @@ pub unsafe extern "C" fn sp_cp437_grid_height(
/// - the returned memory range is never accessed concurrently, either via the [SPCp437Grid] or directly
#[no_mangle]
pub unsafe extern "C" fn sp_cp437_grid_unsafe_data_ref(
cp437_grid: *mut Cp437Grid,
cp437_grid: NonNull<Cp437Grid>,
) -> SPByteSlice {
unsafe {SPByteSlice::from_slice((*cp437_grid).data_ref_mut()) }
unsafe { SPByteSlice::from_slice((*cp437_grid.as_ptr()).data_ref_mut()) }
}

1
src/lib.rs
View file

@ -45,7 +45,6 @@ mod connection;
mod cp437_grid;
mod packet;
use std::time::Duration;
/// Actual hardware limit is around 28-29ms/frame. Rounded up for less dropped packets.

63
src/packet.rs
View file

@ -28,10 +28,9 @@ use std::ptr::NonNull;
/// by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_from_command(
command: *mut TypedCommand,
command: NonNull<TypedCommand>,
) -> *mut Packet {
assert!(!command.is_null());
let command = unsafe { *Box::from_raw(command) };
let command = unsafe { *Box::from_raw(command.as_ptr()) };
if let Ok(packet) = command.try_into() {
Box::leak(Box::new(packet))
} else {
@ -56,12 +55,8 @@ pub unsafe extern "C" fn sp_packet_from_command(
/// - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
/// by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_try_load(
data: *const u8,
length: usize,
) -> *mut Packet {
assert!(!data.is_null());
let data = unsafe { std::slice::from_raw_parts(data, length) };
pub unsafe extern "C" fn sp_packet_try_load(data: SPByteSlice) -> *mut Packet {
let data = unsafe { data.as_slice() };
match servicepoint::Packet::try_from(data) {
Err(_) => std::ptr::null_mut(),
Ok(packet) => Box::into_raw(Box::new(packet)),
@ -95,16 +90,12 @@ pub unsafe extern "C" fn sp_packet_try_load(
#[no_mangle]
pub unsafe extern "C" fn sp_packet_from_parts(
header: Header,
payload: *const u8,
payload_len: usize,
payload: *const SPByteSlice,
) -> NonNull<Packet> {
assert_eq!(payload.is_null(), payload_len == 0);
let payload = if payload.is_null() {
vec![]
} else {
let payload =
unsafe { std::slice::from_raw_parts(payload, payload_len) };
let payload = unsafe { (*payload).as_slice() };
Vec::from(payload)
};
@ -113,34 +104,34 @@ pub unsafe extern "C" fn sp_packet_from_parts(
}
#[no_mangle]
pub unsafe extern "C" fn sp_packet_get_header(packet: *mut Packet) -> *mut Header {
assert!(!packet.is_null());
&mut unsafe { (*packet).header }
pub unsafe extern "C" fn sp_packet_get_header(
packet: NonNull<Packet>,
) -> NonNull<Header> {
NonNull::from(&mut unsafe { (*packet.as_ptr()).header })
}
#[no_mangle]
pub unsafe extern "C" fn sp_packet_get_payload(packet: *mut Packet) -> SPByteSlice {
assert!(!packet.is_null());
unsafe { SPByteSlice::from_slice(&mut *(*packet).payload) }
pub unsafe extern "C" fn sp_packet_get_payload(
packet: NonNull<Packet>,
) -> SPByteSlice {
unsafe { SPByteSlice::from_slice(&mut *(*packet.as_ptr()).payload) }
}
#[no_mangle]
pub unsafe extern "C" fn sp_packet_set_payload(packet: *mut Packet, data: SPByteSlice) {
assert!(!packet.is_null());
unsafe {
(*packet).payload = data.as_slice().to_vec()
}
pub unsafe extern "C" fn sp_packet_set_payload(
packet: NonNull<Packet>,
data: SPByteSlice,
) {
unsafe { (*packet.as_ptr()).payload = data.as_slice().to_vec() }
}
#[no_mangle]
pub unsafe extern "C" fn sp_packet_write_to(
packet: *const Packet,
mut buffer: SPByteSlice,
packet: NonNull<Packet>,
buffer: SPByteSlice,
) {
assert!(!packet.is_null());
unsafe {
(*packet).serialize_to(buffer.as_slice_mut());
packet.as_ref().serialize_to(buffer.as_slice_mut());
}
}
@ -162,10 +153,9 @@ pub unsafe extern "C" fn sp_packet_write_to(
/// by explicitly calling `sp_packet_free`.
#[no_mangle]
pub unsafe extern "C" fn sp_packet_clone(
packet: *const Packet,
packet: NonNull<Packet>,
) -> NonNull<Packet> {
assert!(!packet.is_null());
let result = Box::new(unsafe { (*packet).clone() });
let result = Box::new(unsafe { packet.as_ref().clone() });
NonNull::from(Box::leak(result))
}
@ -182,7 +172,6 @@ pub unsafe extern "C" fn sp_packet_clone(
/// - `packet` points to a valid [SPPacket]
/// - `packet` is not used concurrently or after this call
#[no_mangle]
pub unsafe extern "C" fn sp_packet_free(packet: *mut Packet) {
assert!(!packet.is_null());
_ = unsafe { Box::from_raw(packet) }
pub unsafe extern "C" fn sp_packet_free(packet: NonNull<Packet>) {
_ = unsafe { Box::from_raw(packet.as_ptr()) }
}