RustPython
diff --git a/‎crates/capi/src/sliceobject.rs‎
Lines changed: 156 additions & 0 deletions b/‎crates/capi/src/sliceobject.rs‎
Lines changed: 156 additions & 0 deletions
@@ -1,11 +1,14 @@
 use crate::PyObject;
+use crate::object::define_py_check;
 use crate::pystate::with_vm;
 use crate::util::FfiPtrExt;
 use core::ffi::c_int;
 use rustpython_vm::PyPayload;
 use rustpython_vm::builtins::PySlice;
 use rustpython_vm::sliceable::SaturatedSlice;
 
+define_py_check!(fn PySlice_Check, types.slice_type);
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn PySlice_New(
     start: *mut PyObject,
@@ -62,6 +65,103 @@ pub unsafe extern "C" fn PySlice_AdjustIndices(
     slice_len as isize
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn PySlice_GetIndices(
+    r: *mut PyObject,
+    length: isize,
+    start: *mut isize,
+    stop: *mut isize,
+    step: *mut isize,
+) -> c_int {
+    with_vm(|vm| {
+        let slice = unsafe { r.assume_borrowed_and_cast::<PySlice>(vm) }?;
+        let step_val = if let Some(step) = &slice.step
+            && !vm.is_none(step)
+        {
+            let s: isize = step
+                .try_index(vm)?
+                .as_bigint()
+                .try_into()
+                .map_err(|_| vm.new_value_error("step out of range".to_owned()))?;
+            if s == 0 {
+                return Err(vm.new_value_error("slice step cannot be zero".to_owned()));
+            }
+            s
+        } else {
+            1
+        };
+        let start_val = if let Some(start) = &slice.start
+            && !vm.is_none(start)
+        {
+            let mut st: isize = start
+                .try_index(vm)?
+                .as_bigint()
+                .try_into()
+                .map_err(|_| vm.new_value_error("start out of range".to_owned()))?;
+            if st < 0 {
+                st += length;
+            }
+            st
+        } else if step_val < 0 {
+            length - 1
+        } else {
+            0
+        };
+        let stop_val = if !vm.is_none(&slice.stop) {
+            let mut sp: isize = slice
+                .stop
+                .try_index(vm)?
+                .as_bigint()
+                .try_into()
+                .map_err(|_| vm.new_value_error("stop out of range".to_owned()))?;
+            if sp < 0 {
+                sp += length;
+            }
+            sp
+        } else if step_val < 0 {
+            -1
+        } else {
+            length
+        };
+        if !start.is_null() {
+            unsafe { *start = start_val };
+        }
+        if !stop.is_null() {
+            unsafe { *stop = stop_val };
+        }
+        if !step.is_null() {
+            unsafe { *step = step_val };
+        }
+
+        if start_val > length || stop_val > length {
+            return Ok(-1);
+        }
+        if step_val < 0 && (start_val < -1 || stop_val < -1) {
+            return Ok(-1);
+        }
+        Ok(0)
+    })
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn PySlice_GetIndicesEx(
+    r: *mut PyObject,
+    length: isize,
+    start: *mut isize,
+    stop: *mut isize,
+    step: *mut isize,
+    slicelength: *mut isize,
+) -> c_int {
+    if unsafe { PySlice_Unpack(r, start, stop, step) } != 0 {
+        return -1;
+    }
+    let len = unsafe { PySlice_AdjustIndices(length, start, stop, *step) };
+    if !slicelength.is_null() {
+        unsafe { *slicelength = len };
+    }
+    0
+}
+
 #[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
@@ -93,4 +193,60 @@ mod tests {
             assert_eq!((indices.start, indices.stop, indices.step), (10, 1, -2));
         })
     }
+
+    #[test]
+    fn slice_get_indices_ex() {
+        Python::attach(|py| {
+            let slice = PySlice::new(py, 1, 5, 2);
+            let mut start = 0;
+            let mut stop = 0;
+            let mut step = 0;
+            let mut slicelen = 0;
+            let ret = unsafe {
+                super::PySlice_GetIndicesEx(
+                    slice.as_ptr().cast(),
+                    10,
+                    &mut start,
+                    &mut stop,
+                    &mut step,
+                    &mut slicelen,
+                )
+            };
+            assert_eq!(ret, 0);
+            assert_eq!((start, stop, step, slicelen), (1, 5, 2, 2));
+        });
+    }
+
+    #[test]
+    fn slice_get_indices_bounds() {
+        Python::attach(|py| {
+            let slice_ok = PySlice::new(py, 1, 4, 1);
+            let mut start = 0;
+            let mut stop = 0;
+            let mut step = 0;
+            let ret = unsafe {
+                super::PySlice_GetIndices(
+                    slice_ok.as_ptr().cast(),
+                    5,
+                    &mut start,
+                    &mut stop,
+                    &mut step,
+                )
+            };
+            assert_eq!(ret, 0);
+            assert_eq!((start, stop, step), (1, 4, 1));
+
+            let slice_out = PySlice::new(py, 1, 20, 1);
+            let ret_out = unsafe {
+                super::PySlice_GetIndices(
+                    slice_out.as_ptr().cast(),
+                    10,
+                    &mut start,
+                    &mut stop,
+                    &mut step,
+                )
+            };
+            assert_eq!(ret_out, -1);
+        });
+    }
 }