Rust-related/RustPython
1
0
Fork 1
mirror of https://github.com/RustPython/RustPython.git synced 2026-06-02 19:39:49 +09:00
Code Issues Packages Projects Releases Wiki Activity

Replace bufferish-types.borrow_value() with direct getters

Browse Source
This commit is contained in:
Noah
2021-05-15 18:25:15 -05:00
parent d6e79fbbbf
commit 1eae2c8a12
21 changed files with 85 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
vm/src/builtins/bytearray.rs
View File

@@ -26,8 +26,8 @@ use crate::slots::{
use crate::utils::Either;
use crate::vm::VirtualMachine;
use crate::{
BorrowValue, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable,
PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef,
PyRef, PyResult, PyValue, TypeProtocol,
};
use bstr::ByteSlice;
use crossbeam_utils::atomic::AtomicCell;
@@ -53,7 +53,7 @@ pub struct PyByteArray {
pub type PyByteArrayRef = PyRef<PyByteArray>;
impl<'a> BorrowValue<'a> for PyByteArray {
impl<'a> rustpython_common::borrow::BorrowValue<'a> for PyByteArray {
type Borrowed = PyMappedRwLockReadGuard<'a, [u8]>;
fn borrow_value(&'a self) -> Self::Borrowed {
@@ -194,7 +194,7 @@ impl PyByteArray {
fn iadd(zelf: PyRef<Self>, other: PyBytesLike, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
zelf.try_resizable(vm)?
.elements
.extend(&*other.borrow_value());
.extend(&*other.borrow_buf());
Ok(zelf)
}

12
vm/src/builtins/bytes.rs
View File

@@ -21,8 +21,8 @@ use crate::slots::{BufferProtocol, Comparable, Hashable, Iterable, PyComparisonO
use crate::utils::Either;
use crate::vm::VirtualMachine;
use crate::{
BorrowValue, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef,
PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef,
PyResult, PyValue, TryFromObject, TypeProtocol,
};
use crate::builtins::memory::{Buffer, BufferOptions};
@@ -44,7 +44,7 @@ pub struct PyBytes {
pub type PyBytesRef = PyRef<PyBytes>;
impl<'a> BorrowValue<'a> for PyBytes {
impl<'a> rustpython_common::borrow::BorrowValue<'a> for PyBytes {
type Borrowed = &'a [u8];
fn borrow_value(&'a self) -> Self::Borrowed {
@@ -134,7 +134,7 @@ impl PyBytes {
#[pymethod(name = "__add__")]
fn add(&self, other: PyBytesLike, vm: &VirtualMachine) -> PyObjectRef {
vm.ctx.new_bytes(self.inner.add(&*other.borrow_value()))
vm.ctx.new_bytes(self.inner.add(&*other.borrow_buf()))
}
#[pymethod(name = "__contains__")]
@@ -512,7 +512,7 @@ struct BytesBuffer {
impl Buffer for BytesBuffer {
fn obj_bytes(&self) -> BorrowedValue<[u8]> {
self.bytes.borrow_value().into()
self.bytes.as_bytes().into()
}
fn obj_bytes_mut(&self) -> BorrowedValueMut<[u8]> {
@@ -585,7 +585,7 @@ impl PyBytesIterator {}
impl PyIter for PyBytesIterator {
fn next(zelf: &PyRef<Self>, vm: &VirtualMachine) -> PyResult {
let pos = zelf.position.fetch_add(1);
if let Some(&ret) = zelf.bytes.borrow_value().get(pos) {
if let Some(&ret) = zelf.bytes.as_bytes().get(pos) {
Ok(vm.ctx.new_int(ret))
} else {
Err(vm.new_stop_iteration())

2
vm/src/builtins/code.rs
View File

@@ -47,7 +47,7 @@ fn borrow_obj_constant(obj: &PyObjectRef) -> BorrowedConstant<PyConstant> {
},
ref s @ super::pystr::PyStr => BorrowedConstant::Str { value: s.as_str() },
ref b @ super::bytes::PyBytes => BorrowedConstant::Bytes {
value: b.borrow_value()
value: b.as_bytes()
},
ref c @ PyCode => {
BorrowedConstant::Code { code: &c.code }

4
vm/src/builtins/float.rs
View File

@@ -12,7 +12,7 @@ use crate::function::{OptionalArg, OptionalOption};
use crate::slots::{Comparable, Hashable, PyComparisonOp};
use crate::VirtualMachine;
use crate::{
BorrowValue, IdProtocol, IntoPyObject,
IdProtocol, IntoPyObject,
PyArithmaticValue::{self, *},
PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
TryFromObject, TypeProtocol,
@@ -188,7 +188,7 @@ impl PyFloat {
vm.new_value_error(format!("could not convert string to float: '{}'", s))
})?
} else if let Some(bytes) = val.payload_if_subclass::<PyBytes>(vm) {
lexical_core::parse(bytes.borrow_value()).map_err(|_| {
lexical_core::parse(bytes.as_bytes()).map_err(|_| {
vm.new_value_error(format!(
"could not convert string to float: '{}'",
bytes.repr()

4
vm/src/builtins/int.rs
View File

@@ -800,11 +800,11 @@ fn try_int_radix(obj: &PyObjectRef, base: u32, vm: &VirtualMachine) -> PyResult<
bytes_to_int(s.as_bytes(), base)
}
bytes @ PyBytes => {
let bytes = bytes.borrow_value();
let bytes = bytes.as_bytes();
bytes_to_int(bytes, base)
}
bytearray @ PyByteArray => {
let inner = bytearray.borrow_value();
let inner = bytearray.borrow_buf();
bytes_to_int(&inner, base)
}
_ => {

13
vm/src/bytesinner.rs
View File

@@ -18,8 +18,7 @@ use crate::slots::PyComparisonOp;
use crate::utils::Either;
use crate::vm::VirtualMachine;
use crate::{
BorrowValue, IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyResult, PyValue,
TryFromObject,
IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyResult, PyValue, TryFromObject,
};
use rustpython_common::hash;
@@ -61,7 +60,7 @@ impl ByteInnerNewOptions {
let encoding = encoding
.ok_or_else(|| vm.new_type_error("string argument without an encoding".to_owned()))?;
let bytes = pystr::encode_string(s, Some(encoding), errors.into_option(), vm)?;
Ok(bytes.borrow_value().to_vec().into())
Ok(bytes.as_bytes().to_vec().into())
}
fn get_value_from_source(source: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyBytesInner> {
@@ -917,8 +916,8 @@ where
F: Fn(&[u8]) -> R,
{
match_class!(match obj {
i @ PyBytes => Some(f(i.borrow_value())),
j @ PyByteArray => Some(f(&j.borrow_value())),
i @ PyBytes => Some(f(i.as_bytes())),
j @ PyByteArray => Some(f(&j.borrow_buf())),
_ => None,
})
}
@@ -1076,7 +1075,7 @@ pub fn bytes_decode(
let DecodeArgs { encoding, errors } = args;
let encoding = encoding
.as_ref()
.map_or(crate::codecs::DEFAULT_ENCODING, |s| s.borrow_value());
.map_or(crate::codecs::DEFAULT_ENCODING, |s| s.as_str());
vm.state
.codec_registry
.decode_text(zelf, encoding, errors, vm)
@@ -1158,7 +1157,7 @@ pub fn bytes_to_hex(
s_guard.as_bytes()
}
Either::B(bytes) => {
b_guard = bytes.borrow_value();
b_guard = bytes.as_bytes();
b_guard
}
};

24
vm/src/byteslike.rs
View File

@@ -2,7 +2,7 @@ use crate::builtins::memory::{try_buffer_from_object, BufferRef};
use crate::builtins::PyStrRef;
use crate::common::borrow::{BorrowedValue, BorrowedValueMut};
use crate::vm::VirtualMachine;
use crate::{BorrowValue, PyObjectRef, PyResult, TryFromObject};
use crate::{PyObjectRef, PyResult, TryFromObject};
#[derive(Debug)]
pub struct PyBytesLike(BufferRef);
@@ -15,19 +15,19 @@ impl PyBytesLike {
where
F: FnOnce(&[u8]) -> R,
{
f(&*self.borrow_value())
f(&*self.borrow_buf())
}
pub fn len(&self) -> usize {
self.borrow_value().len()
self.borrow_buf().len()
}
pub fn is_empty(&self) -> bool {
self.borrow_value().is_empty()
self.borrow_buf().is_empty()
}
pub fn to_cow(&self) -> std::borrow::Cow<[u8]> {
self.borrow_value().to_vec().into()
self.borrow_buf().to_vec().into()
}
}
@@ -36,15 +36,15 @@ impl PyRwBytesLike {
where
F: FnOnce(&mut [u8]) -> R,
{
f(&mut *self.borrow_value())
f(&mut *self.borrow_buf_mut())
}
pub fn len(&self) -> usize {
self.borrow_value().len()
self.borrow_buf_mut().len()
}
pub fn is_empty(&self) -> bool {
self.borrow_value().is_empty()
self.borrow_buf_mut().is_empty()
}
}
@@ -73,7 +73,7 @@ impl TryFromObject for PyBytesLike {
}
}
impl<'a> BorrowValue<'a> for PyBytesLike {
impl<'a> rustpython_common::borrow::BorrowValue<'a> for PyBytesLike {
type Borrowed = BorrowedValue<'a, [u8]>;
fn borrow_value(&'a self) -> Self::Borrowed {
self.borrow_buf()
@@ -131,7 +131,7 @@ impl TryFromObject for PyRwBytesLike {
}
}
impl<'a> BorrowValue<'a> for PyRwBytesLike {
impl<'a> rustpython_common::borrow::BorrowValue<'a> for PyRwBytesLike {
type Borrowed = BorrowedValueMut<'a, [u8]>;
fn borrow_value(&'a self) -> Self::Borrowed {
self.borrow_buf_mut()
@@ -155,13 +155,13 @@ impl TryFromObject for BufOrStr {
impl BufOrStr {
pub fn borrow_bytes(&self) -> BorrowedValue<'_, [u8]> {
match self {
Self::Buf(b) => b.borrow_value(),
Self::Buf(b) => b.borrow_buf(),
Self::Str(s) => s.as_str().as_bytes().into(),
}
}
}
impl<'a> BorrowValue<'a> for BufOrStr {
impl<'a> rustpython_common::borrow::BorrowValue<'a> for BufOrStr {
type Borrowed = BorrowedValue<'a, [u8]>;
fn borrow_value(&'a self) -> Self::Borrowed {
self.borrow_bytes()

2
vm/src/cformat.rs
View File

@@ -389,7 +389,7 @@ impl CFormatSpec {
})?
.invoke((), vm)?;
let bytes = PyBytes::try_from_object(vm, bytes)?;
Ok(self.format_bytes(bytes.borrow_value()))
Ok(self.format_bytes(bytes.as_bytes()))
}
}
},

4
vm/src/py_io.rs
View File

@@ -2,7 +2,7 @@ use crate::builtins::bytes::PyBytes;
use crate::builtins::pystr::PyStr;
use crate::exceptions::PyBaseExceptionRef;
use crate::VirtualMachine;
use crate::{BorrowValue, PyObjectRef, PyResult};
use crate::{PyObjectRef, PyResult};
use std::{fmt, io, ops};
pub trait Write {
@@ -81,7 +81,7 @@ pub fn file_readline(obj: &PyObjectRef, size: Option<usize>, vm: &VirtualMachine
}
}
b @ PyBytes => {
let buf = b.borrow_value();
let buf = b.as_bytes();
if buf.is_empty() {
return Err(eof_err());
}

2
vm/src/stdlib/array.rs
View File

@@ -586,7 +586,7 @@ impl PyArray {
#[pymethod]
fn frombytes(zelf: PyRef<Self>, b: PyBytesLike, vm: &VirtualMachine) -> PyResult<()> {
let b = b.borrow_value();
let b = b.borrow_buf();
let itemsize = zelf.borrow_value().itemsize();
if b.len() % itemsize != 0 {
return Err(vm.new_value_error("bytes length not a multiple of item size".to_owned()));

2
vm/src/stdlib/ast.rs
View File

@@ -231,7 +231,7 @@ impl Node for ast::Constant {
}
}
ref s @ builtins::pystr::PyStr => ast::Constant::Str(s.as_str().to_owned()),
ref b @ builtins::bytes::PyBytes => ast::Constant::Bytes(b.borrow_value().to_owned()),
ref b @ builtins::bytes::PyBytes => ast::Constant::Bytes(b.as_bytes().to_owned()),
ref t @ builtins::tuple::PyTuple => {
ast::Constant::Tuple(
t.borrow_value()

2
vm/src/stdlib/fcntl.rs
View File

@@ -78,7 +78,7 @@ mod fcntl {
let buf_len = match buf_kind {
Either::A(rw_arg) => {
let mutate_flag = mutate_flag.unwrap_or(true);
let mut arg_buf = rw_arg.borrow_value();
let mut arg_buf = rw_arg.borrow_buf_mut();
if mutate_flag {
let ret =
unsafe { libc::ioctl(fd, request as _, arg_buf.as_mut_ptr()) };

4
vm/src/stdlib/hashlib.rs
View File

@@ -8,7 +8,7 @@ mod hashlib {
use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
use crate::function::{FuncArgs, OptionalArg};
use crate::vm::VirtualMachine;
use crate::{BorrowValue, PyResult, PyValue, StaticType};
use crate::{PyResult, PyValue, StaticType};
use blake2::{Blake2b, Blake2s};
use digest::DynDigest;
use md5::Md5;
@@ -72,7 +72,7 @@ mod hashlib {
#[pymethod(name = "update")]
fn update(&self, data: PyBytesRef) {
self.borrow_value_mut().input(data.borrow_value());
self.borrow_value_mut().input(data.as_bytes());
}
#[pymethod(name = "digest")]

53
vm/src/stdlib/io.rs
View File

@@ -91,8 +91,8 @@ mod _io {
use crate::utils::Either;
use crate::vm::{ReprGuard, VirtualMachine};
use crate::{
BorrowValue, IdProtocol, IntoPyObject, PyContext, PyIterable, PyObjectRef, PyRef, PyResult,
PyValue, StaticType, TryFromObject, TypeProtocol,
IdProtocol, IntoPyObject, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue,
StaticType, TryFromObject, TypeProtocol,
};
fn validate_whence(whence: i32) -> bool {
@@ -577,17 +577,17 @@ mod _io {
break;
}
Some(b) => {
if b.borrow_value().is_empty() {
if b.as_bytes().is_empty() {
break;
}
total_len += b.borrow_value().len();
total_len += b.as_bytes().len();
chunks.push(b)
}
}
}
let mut ret = Vec::with_capacity(total_len);
for b in chunks {
ret.extend_from_slice(b.borrow_value())
ret.extend_from_slice(b.as_bytes())
}
Ok(Some(ret))
}
@@ -619,9 +619,9 @@ mod _io {
if data.is(&bufobj) {
return Ok(l);
}
let mut buf = b.borrow_value();
let mut buf = b.borrow_buf_mut();
let data = PyBytesLike::try_from_object(vm, data)?;
let data = data.borrow_value();
let data = data.borrow_buf();
match buf.get_mut(..data.len()) {
Some(slice) => {
slice.copy_from_slice(&data);
@@ -912,7 +912,7 @@ mod _io {
let avail = self.buffer.len() - self.pos as usize;
let buf_len;
{
let buf = obj.borrow_value();
let buf = obj.borrow_buf();
buf_len = buf.len();
if buf.len() <= avail {
self.buffer[self.pos as usize..][..buf.len()].copy_from_slice(&buf);
@@ -1171,7 +1171,7 @@ mod _io {
let res = <Option<PyBytesRef>>::try_from_object(vm, res)?;
let ret = if let Some(mut data) = data {
if let Some(bytes) = res {
data.extend_from_slice(bytes.borrow_value());
data.extend_from_slice(bytes.as_bytes());
}
Some(PyBytes::from(data).into_ref(vm))
} else {
@@ -1188,8 +1188,8 @@ mod _io {
let read_data = <Option<PyBytesRef>>::try_from_object(vm, read_data)?;
match read_data {
Some(b) if !b.borrow_value().is_empty() => {
let l = b.borrow_value().len();
Some(b) if !b.as_bytes().is_empty() => {
let l = b.as_bytes().len();
read_size += l;
if self.abs_pos != -1 {
self.abs_pos += l as Offset;
@@ -1203,7 +1203,7 @@ mod _io {
let mut data = data.unwrap_or_default();
data.reserve(read_size);
for bytes in &chunks {
data.extend_from_slice(bytes.borrow_value())
data.extend_from_slice(bytes.as_bytes())
}
Some(PyBytes::from(data).into_ref(vm))
};
@@ -2000,7 +2000,7 @@ mod _io {
fn as_bytes(&self) -> &[u8] {
match self {
Self::Utf8(s) => s.as_str().as_bytes(),
Self::Bytes(b) => b.borrow_value(),
Self::Bytes(b) => b.as_bytes(),
}
}
}
@@ -2170,10 +2170,7 @@ mod _io {
let has_read1 = vm.get_attribute_opt(buffer.clone(), "read1")?.is_some();
let seekable = pybool::boolval(vm, vm.call_method(&buffer, "seekable", ())?)?;
let codec = vm
.state
.codec_registry
.lookup(encoding.borrow_value(), vm)?;
let codec = vm.state.codec_registry.lookup(encoding.as_str(), vm)?;
let encoder = if pybool::boolval(vm, vm.call_method(&buffer, "writable", ())?)? {
let incremental_encoder =
@@ -2425,7 +2422,7 @@ mod _io {
let mut skip_back = 1;
while skip_bytes > 0 {
cookie.set_decoder_state(decoder, vm)?;
let input = &next_input.borrow_value()[..skip_bytes as usize];
let input = &next_input.as_bytes()[..skip_bytes as usize];
let (bytes_decoded, chars_decoded) = decoder_decode(input)?;
if chars_decoded <= chars_to_skip {
let (dec_buffer, dec_flags) = decoder_getstate()?;
@@ -2455,7 +2452,7 @@ mod _io {
if chars_to_skip != 0 {
let mut chars_decoded = 0;
let mut bytes_decoded = 0;
let mut input = next_input.borrow_value();
let mut input = next_input.as_bytes();
input = &input[skip_bytes..];
while !input.is_empty() {
let (byte1, rest) = input.split_at(1);
@@ -2840,7 +2837,7 @@ mod _io {
use crate::builtins::{int, PyTuple};
let state_err = || vm.new_type_error("illegal decoder state".to_owned());
let state = state.downcast::<PyTuple>().map_err(|_| state_err())?;
match state.borrow_value() {
match state.as_slice() {
[buf, flags] => {
let buf = buf.clone().downcast::<PyBytes>().map_err(|obj| {
vm.new_type_error(format!(
@@ -2895,7 +2892,7 @@ mod _io {
input_chunk.class().name
))
})?;
let nbytes = buf.borrow_value().len();
let nbytes = buf.borrow_buf().len();
let eof = nbytes == 0;
let decoded = vm.call_method(decoder, "decode", (input_chunk, eof))?;
let decoded = check_decoded(decoded, vm)?;
@@ -2911,8 +2908,8 @@ mod _io {
if let Some((dec_buffer, dec_flags)) = dec_state {
// TODO: inplace append to bytes when refcount == 1
let mut next_input = dec_buffer.borrow_value().to_vec();
next_input.extend_from_slice(&*buf.borrow_value());
let mut next_input = dec_buffer.as_bytes().to_vec();
next_input.extend_from_slice(&*buf.borrow_buf());
self.snapshot = Some((dec_flags, PyBytes::from(next_input).into_ref(vm)));
}
@@ -3171,7 +3168,7 @@ mod _io {
) -> PyResult<BytesIORef> {
let raw_bytes = object
.flatten()
.map_or_else(Vec::new, |input| input.borrow_value().to_vec());
.map_or_else(Vec::new, |input| input.as_bytes().to_vec());
BytesIO {
buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))),
@@ -3230,7 +3227,7 @@ mod _io {
let mut buf = self.buffer(vm)?;
let ret = buf
.cursor
.read(&mut *obj.borrow_value())
.read(&mut *obj.borrow_buf_mut())
.map_err(|_| vm.new_value_error("Error readinto from Take".to_owned()))?;
Ok(ret)
@@ -3667,9 +3664,7 @@ mod fileio {
use crate::function::{FuncArgs, OptionalArg};
use crate::stdlib::os;
use crate::vm::VirtualMachine;
use crate::{
BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
};
use crate::{PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol};
use crossbeam_utils::atomic::AtomicCell;
use std::io::{Read, Write};
@@ -3973,7 +3968,7 @@ mod fileio {
let handle = self.get_fd(vm)?;
let mut buf = obj.borrow_value();
let mut buf = obj.borrow_buf_mut();
let mut f = handle.take(buf.len() as _);
let ret = f.read(&mut buf).map_err(|e| e.into_pyexception(vm))?;

3
vm/src/stdlib/marshal.rs
View File

@@ -6,7 +6,6 @@ mod decl {
use crate::builtins::code::{PyCode, PyCodeRef};
use crate::bytecode;
use crate::byteslike::PyBytesLike;
use crate::common::borrow::BorrowValue;
use crate::vm::VirtualMachine;
use crate::{PyObjectRef, PyResult, TryFromObject};
@@ -24,7 +23,7 @@ mod decl {
#[pyfunction]
fn loads(code_bytes: PyBytesLike, vm: &VirtualMachine) -> PyResult<PyCode> {
let code =
bytecode::CodeObject::from_bytes(&*code_bytes.borrow_value()).map_err(|e| match e {
bytecode::CodeObject::from_bytes(&*code_bytes.borrow_buf()).map_err(|e| match e {
bytecode::CodeDeserializeError::Eof => vm.new_exception_msg(
vm.ctx.exceptions.eof_error.clone(),
"end of file while deserializing bytecode".to_owned(),

6
vm/src/stdlib/os.rs
View File

@@ -691,11 +691,11 @@ mod _os {
) -> PyResult<()> {
let key: &ffi::OsStr = match key {
Either::A(ref s) => s.as_str().as_ref(),
Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
Either::B(ref b) => bytes_as_osstr(b.as_bytes(), vm)?,
};
let value: &ffi::OsStr = match value {
Either::A(ref s) => s.as_str().as_ref(),
Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
Either::B(ref b) => bytes_as_osstr(b.as_bytes(), vm)?,
};
env::set_var(key, value);
Ok(())
@@ -705,7 +705,7 @@ mod _os {
fn unsetenv(key: Either<PyStrRef, PyBytesRef>, vm: &VirtualMachine) -> PyResult<()> {
let key: &ffi::OsStr = match key {
Either::A(ref s) => s.as_str().as_ref(),
Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
Either::B(ref b) => bytes_as_osstr(b.as_bytes(), vm)?,
};
env::remove_var(key);
Ok(())

4
vm/src/stdlib/pystruct.rs
View File

@@ -709,7 +709,7 @@ pub(crate) mod _struct {
fn pack_char(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
let v = PyBytesRef::try_from_object(vm, arg)?;
let ch = *v.borrow_value().iter().exactly_one().map_err(|_| {
let ch = *v.as_bytes().iter().exactly_one().map_err(|_| {
new_struct_error(
vm,
"char format requires a bytes object of length 1".to_owned(),
@@ -894,7 +894,7 @@ pub(crate) mod _struct {
let spec = FormatSpec::decode_and_parse(vm, &fmt)?;
let fmt_str = match fmt {
Either::A(s) => s,
Either::B(b) => PyStr::from(std::str::from_utf8(b.borrow_value()).unwrap())
Either::B(b) => PyStr::from(std::str::from_utf8(b.as_bytes()).unwrap())
.into_ref_with_type(vm, vm.ctx.types.str_type.clone())?,
};
PyStruct { spec, fmt_str }.into_ref_with_type(vm, cls)

14
vm/src/stdlib/socket.rs
View File

@@ -470,7 +470,7 @@ impl PySocket {
) -> PyResult<usize> {
let flags = flags.unwrap_or(0);
let sock = self.sock();
let mut buf = buf.borrow_value();
let mut buf = buf.borrow_buf_mut();
let buf = &mut *buf;
self.sock_op(vm, SelectKind::Read, || {
sock.recv_with_flags(slice_as_uninit(buf), flags)
@@ -505,7 +505,7 @@ impl PySocket {
flags: OptionalArg<i32>,
vm: &VirtualMachine,
) -> PyResult<(usize, PyObjectRef)> {
let mut buf = buf.borrow_value();
let mut buf = buf.borrow_buf_mut();
let buf = &mut *buf;
let buf = match nbytes {
OptionalArg::Present(i) => {
@@ -534,7 +534,7 @@ impl PySocket {
vm: &VirtualMachine,
) -> PyResult<usize> {
let flags = flags.unwrap_or(0);
let buf = bytes.borrow_value();
let buf = bytes.borrow_buf();
let buf = &*buf;
self.sock_op(vm, SelectKind::Write, || {
self.sock().send_with_flags(buf, flags)
@@ -554,7 +554,7 @@ impl PySocket {
let deadline = timeout.map(Deadline::new);
let buf = bytes.borrow_value();
let buf = bytes.borrow_buf();
let buf = &*buf;
let mut buf_offset = 0;
// now we have like 3 layers of interrupt loop :)
@@ -595,7 +595,7 @@ impl PySocket {
OptionalArg::Missing => (0, arg2),
};
let addr = self.extract_address(address, "sendto", vm)?;
let buf = bytes.borrow_value();
let buf = bytes.borrow_buf();
let buf = &*buf;
self.sock_op(vm, SelectKind::Write, || {
self.sock().send_to_with_flags(buf, &addr, flags)
@@ -915,7 +915,7 @@ fn _socket_inet_aton(ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u
}
fn _socket_inet_ntoa(packed_ip: PyBytesLike, vm: &VirtualMachine) -> PyResult {
let packed_ip = packed_ip.borrow_value();
let packed_ip = packed_ip.borrow_buf();
let packed_ip = <&[u8; 4]>::try_from(&*packed_ip)
.map_err(|_| vm.new_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
Ok(vm.ctx.new_str(Ipv4Addr::from(*packed_ip).to_string()))
@@ -1165,7 +1165,7 @@ fn _socket_inet_ntop(
packed_ip: PyBytesLike,
vm: &VirtualMachine,
) -> PyResult<String> {
let packed_ip = packed_ip.borrow_value();
let packed_ip = packed_ip.borrow_buf();
match af_inet {
c::AF_INET => {
let packed_ip = <&[u8; 4]>::try_from(&*packed_ip).map_err(|_| {

4
vm/src/stdlib/ssl.rs
View File

@@ -846,7 +846,7 @@ impl PySslSocket {
#[pymethod]
fn write(&self, data: PyBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
let mut stream = self.stream.write();
let data = data.borrow_value();
let data = data.borrow_buf();
let data = &*data;
let timeout = SocketTimeout::get(stream.get_ref());
let state = ssl_select(stream.get_ref(), SslNeeds::Write, &timeout);
@@ -889,7 +889,7 @@ impl PySslSocket {
fn read(&self, n: usize, buffer: OptionalArg<PyRwBytesLike>, vm: &VirtualMachine) -> PyResult {
let mut stream = self.stream.write();
let mut inner_buffer = if let OptionalArg::Present(buffer) = &buffer {
Either::A(buffer.borrow_value())
Either::A(buffer.borrow_buf_mut())
} else {
Either::B(vec![0u8; n])
};

7
vm/src/stdlib/termios.rs
View File

@@ -76,11 +76,8 @@ mod termios {
))
})?;
for (cc, x) in termios.c_cc.iter_mut().zip(cc.iter()) {
*cc = if let Some(c) = x
.payload::<PyBytes>()
.filter(|b| b.borrow_value().len() == 1)
{
c.borrow_value()[0] as _
*cc = if let Some(c) = x.payload::<PyBytes>().filter(|b| b.as_bytes().len() == 1) {
c.as_bytes()[0] as _
} else if let Some(i) = x.payload::<PyInt>() {
int::try_to_primitive(i.as_bigint(), vm)?
} else {

6
vm/src/stdlib/zlib.rs
View File

@@ -11,7 +11,7 @@ mod decl {
use crate::function::OptionalArg;
use crate::types::create_simple_type;
use crate::vm::VirtualMachine;
use crate::{BorrowValue, IntoPyRef, PyResult, PyValue, StaticType};
use crate::{IntoPyRef, PyResult, PyValue, StaticType};
use adler32::RollingAdler32 as Adler32;
use crc32fast::Hasher as Crc32;
@@ -310,7 +310,7 @@ mod decl {
if stream_end && !leftover.is_empty() {
let mut unused_data = self.unused_data.lock();
let unused: Vec<_> = unused_data
.borrow_value()
.as_bytes()
.iter()
.chain(leftover)
.copied()
@@ -326,7 +326,7 @@ mod decl {
} else {
Some(args.max_length)
};
let data = args.data.borrow_value();
let data = args.data.borrow_buf();
let data = &*data;
let mut d = self.decompress.lock();