Method call_scan_once

crates/stdlib/src/json.rs:507–617

Call scan_once and handle the result. Returns (value, end_char_idx, end_byte_idx).

(
            &self,
            scan_once: &PyObjectRef,
            pystr: PyUtf8StrRef,
            char_idx: usize,
            byte_idx: usize,
            memo: &mut HashMap<String, PyStrRef>,
 

        /// Call scan_once and handle the result.
        /// Returns (value, end_char_idx, end_byte_idx).
        fn call_scan_once(
            &self,
            scan_once: &PyObjectRef,
            pystr: PyUtf8StrRef,
            char_idx: usize,
            byte_idx: usize,
            memo: &mut HashMap<String, PyStrRef>,
            vm: &VirtualMachine,
        ) -> PyResult<(PyObjectRef, usize, usize)> {
            let bytes = pystr.as_bytes();
            let wtf8 = pystr.as_wtf8();
            let s = pystr.as_str();

            let first_byte = match bytes.get(byte_idx) {
                Some(&b) => b,
                None => return Err(self.make_decode_error("Expecting value", pystr, char_idx, vm)),
            };

            match first_byte {
                b'"' => {
                    // String - pass slice starting after the quote
                    let (wtf8_result, chars_consumed, bytes_consumed) =
                        machinery::scanstring(&wtf8[byte_idx + 1..], char_idx + 1, self.strict)
                            .map_err(|e| py_decode_error(e, pystr.clone().into_wtf8(), vm))?;
                    let py_str = vm.ctx.new_str(wtf8_result.to_string());
                    Ok((
                        py_str.into(),
                        char_idx + 1 + chars_consumed,
                        byte_idx + 1 + bytes_consumed,
                    ))
                }
                b'{' => {
                    // Object
                    self.parse_object(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
                }
                b'[' => {
                    // Array
                    self.parse_array(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
                }
                b'n' if starts_with_bytes(&bytes[byte_idx..], b"null") => {
                    // null
                    Ok((vm.ctx.none(), char_idx + 4, byte_idx + 4))
                }
                b't' if starts_with_bytes(&bytes[byte_idx..], b"true") => {
                    // true
                    Ok((vm.ctx.new_bool(true).into(), char_idx + 4, byte_idx + 4))
                }
                b'f' if starts_with_bytes(&bytes[byte_idx..], b"false") => {
                    // false
                    Ok((vm.ctx.new_bool(false).into(), char_idx + 5, byte_idx + 5))
                }
                b'N' if starts_with_bytes(&bytes[byte_idx..], b"NaN") => {
                    // NaN
                    let result = self.parse_constant.call(("NaN",), vm)?;
                    Ok((result, char_idx + 3, byte_idx + 3))
                }
                b'I' if starts_with_bytes(&bytes[byte_idx..], b"Infinity") => {
                    // Infinity