Lines Matching defs:buffer
48 _bufferediobase_readinto_generic(PyObject *self, Py_buffer *buffer, char readinto1)
56 data = _PyObject_CallMethod(self, attr, "n", buffer->len);
67 if (len > buffer->len) {
71 buffer->len, len);
75 memcpy(buffer->buf, PyBytes_AS_STRING(data), len);
84 buffer: Py_buffer(accept={rwbuffer})
89 _io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer)
92 return _bufferediobase_readinto_generic(self, buffer, 0);
97 buffer: Py_buffer(accept={rwbuffer})
102 _io__BufferedIOBase_readinto1_impl(PyObject *self, Py_buffer *buffer)
105 return _bufferediobase_readinto_generic(self, buffer, 1);
120 Disconnect this buffer from its underlying raw stream and return it.
122 After the raw stream has been detached, the buffer is in an unusable
171 "Write the given buffer to the IO stream.\n"
176 "Raises BlockingIOError if the buffer is full and the\n"
203 /* A static buffer of size `buffer_size` */
204 char *buffer;
205 /* Current logical position in the buffer. */
207 /* Position of the raw stream in the buffer. */
210 /* Just after the last buffered byte in the buffer, or -1 if the buffer
216 /* Just after the last byte waiting to be written, or -1 if the buffer
236 * They also share a single buffer for reading and writing. This enables
248 raw stream (according to the buffer size), but for now it is only done
325 (!self->buffer || \
377 if (self->buffer) {
378 PyMem_Free(self->buffer);
379 self->buffer = NULL;
395 if (self->buffer)
508 if (self->buffer) {
509 PyMem_Free(self->buffer);
510 self->buffer = NULL;
713 "buffer size must be strictly positive");
716 if (self->buffer)
717 PyMem_Free(self->buffer);
718 self->buffer = PyMem_Malloc(self->buffer_size);
719 if (self->buffer == NULL) {
947 _buffered_readinto_generic(buffered *self, Py_buffer *buffer, char readinto1)
957 if (n >= buffer->len) {
958 memcpy(buffer->buf, self->buffer + self->pos, buffer->len);
959 self->pos += buffer->len;
960 return PyLong_FromSsize_t(buffer->len);
962 memcpy(buffer->buf, self->buffer + self->pos, n);
980 for (remaining = buffer->len - written;
983 /* If remaining bytes is larger than internal buffer size, copy
984 * directly into caller's buffer. */
986 n = _bufferedreader_raw_read(self, (char *) buffer->buf + written,
991 buffer if we already have some data to return */
997 memcpy((char *) buffer->buf + written,
998 self->buffer + self->pos, n);
1031 buffer: Py_buffer(accept={rwbuffer})
1036 _io__Buffered_readinto_impl(buffered *self, Py_buffer *buffer)
1039 return _buffered_readinto_generic(self, buffer, 0);
1044 buffer: Py_buffer(accept={rwbuffer})
1049 _io__Buffered_readinto1_impl(buffered *self, Py_buffer *buffer)
1052 return _buffered_readinto_generic(self, buffer, 1);
1066 /* First, try to find a line in the buffer. This can run unlocked because
1072 start = self->buffer + self->pos;
1123 start = self->buffer;
1235 buffer. Other whence values must be managed without this optimization.
1240 /* Check if seeking leaves us inside the current buffer,
1264 /* Fallback: invoke raw seek() method and clear buffer */
1272 /* TODO: align on block boundary and read buffer if needed? */
1448 /* NOTE: the buffer needn't be released as its object is NULL. */
1501 n = _bufferedreader_raw_read(self, self->buffer + start, len);
1515 /* First copy what we have in the current buffer. */
1519 self->buffer + self->pos, current_size);
1524 /* We're going past the buffer's bounds, flush it */
1599 /* Read n bytes from the buffer if it can, otherwise return None.
1609 PyObject *res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);
1638 memcpy(out, self->buffer + self->pos, current_size);
1643 /* Flush the write buffer if necessary */
1652 /* We want to read a whole block at the end into buffer.
1695 memcpy(out + written, self->buffer + self->pos, r);
1701 memcpy(out + written, self->buffer + self->pos, remaining);
1725 2. we don't want to lose block alignment, so we can't shift the buffer
1727 Therefore, we either return `have` bytes (if > 0), or a full buffer.
1730 return PyBytes_FromStringAndSize(self->buffer + self->pos, have);
1733 /* Fill the buffer from the raw stream, and copy it to the result. */
1741 return PyBytes_FromStringAndSize(self->buffer, r);
1762 A buffer for a writeable sequential RawIO object.
1805 /* NOTE: the buffer needn't be released as its object is NULL. */
1863 self->buffer + self->write_pos,
1903 buffer: Py_buffer
1908 _io_BufferedWriter_write_impl(buffered *self, Py_buffer *buffer)
1933 if (buffer->len <= avail) {
1934 memcpy(self->buffer + self->pos, buffer->buf, buffer->len);
1938 ADJUST_POSITION(self, self->pos + buffer->len);
1941 written = buffer->len;
1945 /* First write the current buffer */
1953 /* Make some place by shifting the buffer. */
1955 memmove(self->buffer, self->buffer + self->write_pos,
1964 if (buffer->len <= avail) {
1967 memcpy(self->buffer + self->write_end, buffer->buf, buffer->len);
1968 self->write_end += buffer->len;
1969 self->pos += buffer->len;
1970 written = buffer->len;
1974 memcpy(self->buffer + self->write_end, buffer->buf, avail);
1987 position. This happens if the read buffer has been filled but not
1999 /* Then write buf itself. At this point the buffer has been emptied. */
2000 remaining = buffer->len;
2004 self, (char *) buffer->buf + written, buffer->len - written);
2010 /* Can't buffer everything, still buffer as much as possible */
2011 memcpy(self->buffer,
2012 (char *) buffer->buf + written, self->buffer_size);
2035 memcpy(self->buffer, (char *) buffer->buf + written, remaining);