rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Issue 3223: reformat via cargo fmt

Browse Source
This commit is contained in:
Alexander McLin
2026-04-08 19:39:48 -04:00
parent fbc5345c9a
commit 091af28368
2 changed files with 70 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/ffi.rs
View File

@@ -65,16 +65,16 @@ impl FunctionImpl {
Integer: From<T>, Integer: From<T>,
T: Copy + TryInto<i64> + MightNotFitInFixnum, T: Copy + TryInto<i64> + MightNotFitInFixnum,
{ {
let n = unsafe { self.cif.call::<T>(self.code_ptr, args) }; let n = unsafe { self.cif.call::<T>(self.code_ptr, args) };
Ok(Value::Number(fixnum!(Number, n, arena))) Ok(Value::Number(fixnum!(Number, n, arena)))
} }
unsafe fn call_float<T>(&self, args: &[Arg], _: &mut Arena) -> Result<Value, FfiError> unsafe fn call_float<T>(&self, args: &[Arg], _: &mut Arena) -> Result<Value, FfiError>
where where
T: Into<f64>, T: Into<f64>,
{ {
let n = unsafe { self.cif.call::<T>(self.code_ptr, args) }; let n = unsafe { self.cif.call::<T>(self.code_ptr, args) };
Ok(Value::Number(Number::Float(OrderedFloat(n.into())))) Ok(Value::Number(Number::Float(OrderedFloat(n.into()))))
} }
unsafe fn call_ptr(&self, args: &[Arg], arena: &mut Arena) -> Result<Value, FfiError> { unsafe fn call_ptr(&self, args: &[Arg], arena: &mut Arena) -> Result<Value, FfiError> {
@@ -266,9 +266,9 @@ impl StructImpl {
let (new_layout, offset) = layout let (new_layout, offset) = layout
.extend(Layout::new::<T>()) .extend(Layout::new::<T>())
.map_err(|_| FfiError::LayoutError)?; .map_err(|_| FfiError::LayoutError)?;
*layout = new_layout; *layout = new_layout;
let n = unsafe { std::ptr::read::<T>(ptr.byte_offset(offset as isize).cast()) }; let n = unsafe { std::ptr::read::<T>(ptr.byte_offset(offset as isize).cast()) };
Ok(n) Ok(n)
} }
unsafe fn read_int<T>( unsafe fn read_int<T>(
@@ -280,9 +280,8 @@ impl StructImpl {
T: Copy + TryInto<i64> + MightNotFitInFixnum, T: Copy + TryInto<i64> + MightNotFitInFixnum,
Integer: From<T>, Integer: From<T>,
{ {
let n = unsafe { read_primitive::<T>(ptr, layout)? };
let n = unsafe { read_primitive::<T>(ptr, layout)? }; Ok(Value::Number(fixnum!(Number, n, arena)))
Ok(Value::Number(fixnum!(Number, n, arena)))
} }
unsafe fn read_float<T>( unsafe fn read_float<T>(
@@ -292,8 +291,8 @@ impl StructImpl {
where where
T: Into<f64>, T: Into<f64>,
{ {
let n = unsafe { read_primitive::<T>(ptr, layout)? }; let n = unsafe { read_primitive::<T>(ptr, layout)? };
Ok(Value::Number(Number::Float(OrderedFloat(n.into())))) Ok(Value::Number(Number::Float(OrderedFloat(n.into()))))
} }
let mut layout = Layout::from_size_align(0, 1).map_err(|_| FfiError::LayoutError)?; let mut layout = Layout::from_size_align(0, 1).map_err(|_| FfiError::LayoutError)?;
@@ -794,8 +793,8 @@ impl ForeignFunctionTable {
T: Copy + TryInto<i64> + MightNotFitInFixnum, T: Copy + TryInto<i64> + MightNotFitInFixnum,
Integer: From<T>, Integer: From<T>,
{ {
let n = unsafe { ptr.cast::<T>().read() }; let n = unsafe { ptr.cast::<T>().read() };
Value::Number(fixnum!(Number, n, arena)) Value::Number(fixnum!(Number, n, arena))
} }
let ptr = ptr.as_ptr()?; let ptr = ptr.as_ptr()?;

113
src/machine/heap.rs
View File

@@ -71,26 +71,26 @@ impl InnerHeap {
new_layout.size() <= isize::MAX as usize, new_layout.size() <= isize::MAX as usize,
"Allocation too large. We should probably GC (TODO)" "Allocation too large. We should probably GC (TODO)"
); );
let new_ptr = unsafe {
if self.byte_cap == 0 {
alloc::alloc(new_layout)
} else {
let old_layout =
alloc::Layout::from_size_align(self.byte_cap, size_of::<HeapCellValue>())
.unwrap();
alloc::realloc(self.ptr, old_layout, new_layout.size())
}
};
if !new_ptr.is_null() { let new_ptr = unsafe {
self.ptr = new_ptr; if self.byte_cap == 0 {
self.byte_cap = new_cap; alloc::alloc(new_layout)
true
} else { } else {
false let old_layout =
alloc::Layout::from_size_align(self.byte_cap, size_of::<HeapCellValue>())
.unwrap();
alloc::realloc(self.ptr, old_layout, new_layout.size())
} }
};
if !new_ptr.is_null() {
self.ptr = new_ptr;
self.byte_cap = new_cap;
true
} else {
false
}
} }
} }
@@ -110,20 +110,20 @@ unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan<'_> {
.position(|b| *b == 0u8) .position(|b| *b == 0u8)
.unwrap_or(heap_slice.len()); .unwrap_or(heap_slice.len());
let zero_byte_addr = unsafe { heap_slice.as_ptr().add(string_len) }; let zero_byte_addr = unsafe { heap_slice.as_ptr().add(string_len) };
let sentinel_len = pstr_sentinel_length(zero_byte_addr.addr()); let sentinel_len = pstr_sentinel_length(zero_byte_addr.addr());
let tail_idx = cell_index!( let tail_idx = cell_index!(
(string_len + sentinel_len).next_multiple_of(ALIGN) (string_len + sentinel_len).next_multiple_of(ALIGN)
+ if sentinel_len <= 1 { heap_index!(1) } else { 0 } + if sentinel_len <= 1 { heap_index!(1) } else { 0 }
); );
let str_slice = &heap_slice[..string_len]; let str_slice = &heap_slice[..string_len];
HeapStringScan { HeapStringScan {
string: unsafe { std::str::from_utf8_unchecked(str_slice) }, string: unsafe { std::str::from_utf8_unchecked(str_slice) },
tail_idx, tail_idx,
} }
} }
// Same as scan_slice_to_str but assumes that the slice is from the start of a string. // Same as scan_slice_to_str but assumes that the slice is from the start of a string.
@@ -142,10 +142,10 @@ unsafe fn scan_slice_to_str_from_start(heap_slice: &[u8]) -> HeapStringScan<'_>
let str_slice = &heap_slice[..string_len]; let str_slice = &heap_slice[..string_len];
HeapStringScan { HeapStringScan {
string: unsafe { std::str::from_utf8_unchecked(str_slice) }, string: unsafe { std::str::from_utf8_unchecked(str_slice) },
tail_idx, tail_idx,
} }
} }
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
@@ -282,28 +282,29 @@ impl ReservedHeapSection {
) )
}; };
let zero_region_idx = heap_index!(self.heap_cell_len) + str_byte_len; let zero_region_idx = heap_index!(self.heap_cell_len) + str_byte_len;
let align_offset = pstr_sentinel_length(zero_region_idx); let align_offset = pstr_sentinel_length(zero_region_idx);
unsafe { ptr::write_bytes(self.heap_ptr.add(zero_region_idx), 0u8, align_offset) }; unsafe { ptr::write_bytes(self.heap_ptr.add(zero_region_idx), 0u8, align_offset) };
cells_written = if align_offset == 1 { cells_written = if align_offset == 1 {
unsafe { ptr::write_bytes( unsafe {
ptr::write_bytes(
self.heap_ptr.add(zero_region_idx + 1), self.heap_ptr.add(zero_region_idx + 1),
0u8, 0u8,
size_of::<HeapCellValue>(), size_of::<HeapCellValue>(),
) )
}; };
// ensure there are at least two bytes in the boundary // ensure there are at least two bytes in the boundary
// buffer separating the string data from the tail // buffer separating the string data from the tail
// cell // cell
cell_index!(src.len() + align_offset + size_of::<HeapCellValue>()) cell_index!(src.len() + align_offset + size_of::<HeapCellValue>())
} else { } else {
cell_index!(src.len() + align_offset) cell_index!(src.len() + align_offset)
}; };
self.heap_cell_len += cells_written; self.heap_cell_len += cells_written;
cells_written cells_written
} }
@@ -627,15 +628,15 @@ impl Heap {
let len = heap_index_checked!(num_cells).ok_or(AllocError)?; let len = heap_index_checked!(num_cells).ok_or(AllocError)?;
loop { loop {
if self.free_space() >= len { if self.free_space() >= len {
section = ReservedHeapSection { section = ReservedHeapSection {
heap_ptr: self.inner.ptr, heap_ptr: self.inner.ptr,
heap_cell_len: self.cell_len(), heap_cell_len: self.cell_len(),
}; };
break; break;
} else if unsafe { !self.grow() } { } else if unsafe { !self.grow() } {
return Err(AllocError); return Err(AllocError);
} }
} }
Ok(HeapWriter { Ok(HeapWriter {
@@ -864,8 +865,8 @@ impl Heap {
let align_offset = pstr_sentinel_length(s_len); let align_offset = pstr_sentinel_length(s_len);
let copy_size = s_len + align_offset; let copy_size = s_len + align_offset;
loop { loop {
unsafe { unsafe {
if self.free_space() >= copy_size { if self.free_space() >= copy_size {
let slice = let slice =
std::slice::from_raw_parts_mut(self.inner.ptr, self.inner.byte_len + s_len); std::slice::from_raw_parts_mut(self.inner.ptr, self.inner.byte_len + s_len);