2014-05-03 23:27:38 +01:00
|
|
|
/*
|
2017-06-30 08:22:17 +01:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 23:27:38 +01:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
2019-01-31 08:55:21 +00:00
|
|
|
* Copyright (c) 2014 Damien P. George
|
|
|
|
* Copyright (c) 2014-2016 Paul Sokolovsky
|
2014-05-03 23:27:38 +01:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2014-04-12 16:44:32 +01:00
|
|
|
#include <string.h>
|
2015-08-05 00:45:30 +01:00
|
|
|
#include <unistd.h>
|
2014-01-08 00:43:48 +00:00
|
|
|
|
2015-01-01 20:27:54 +00:00
|
|
|
#include "py/objstr.h"
|
|
|
|
#include "py/stream.h"
|
2016-05-20 19:16:58 +01:00
|
|
|
#include "py/runtime.h"
|
2015-01-01 20:27:54 +00:00
|
|
|
|
2014-01-08 00:43:48 +00:00
|
|
|
// This file defines generic Python stream read/write methods which
|
|
|
|
// dispatch to the underlying stream interface of an object.
|
|
|
|
|
2014-05-06 23:51:07 +01:00
|
|
|
// TODO: should be in mpconfig.h
|
|
|
|
#define DEFAULT_BUFFER_SIZE 256
|
|
|
|
|
2014-02-12 16:31:30 +00:00
|
|
|
STATIC mp_obj_t stream_readall(mp_obj_t self_in);
|
2014-01-16 10:53:46 +00:00
|
|
|
|
2014-07-27 22:38:58 +01:00
|
|
|
#define STREAM_CONTENT_TYPE(stream) (((stream)->is_text) ? &mp_type_str : &mp_type_bytes)
|
2014-05-15 05:28:19 +01:00
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
// Returns error condition in *errcode, if non-zero, return value is number of bytes written
|
2017-05-29 08:08:14 +01:00
|
|
|
// before error condition occurred. If *errcode == 0, returns total bytes written (which will
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
// be equal to input size).
|
|
|
|
mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf_, mp_uint_t size, int *errcode, byte flags) {
|
|
|
|
byte *buf = buf_;
|
|
|
|
typedef mp_uint_t (*io_func_t)(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode);
|
|
|
|
io_func_t io_func;
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(stream);
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
if (flags & MP_STREAM_RW_WRITE) {
|
2016-06-18 16:19:24 +01:00
|
|
|
io_func = (io_func_t)stream_p->write;
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
} else {
|
2016-06-18 16:19:24 +01:00
|
|
|
io_func = stream_p->read;
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
*errcode = 0;
|
|
|
|
mp_uint_t done = 0;
|
|
|
|
while (size > 0) {
|
|
|
|
mp_uint_t out_sz = io_func(stream, buf, size, errcode);
|
|
|
|
// For read, out_sz == 0 means EOF. For write, it's unspecified
|
|
|
|
// what it means, but we don't make any progress, so returning
|
|
|
|
// is still the best option.
|
|
|
|
if (out_sz == 0) {
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
if (out_sz == MP_STREAM_ERROR) {
|
|
|
|
// If we read something before getting EAGAIN, don't leak it
|
|
|
|
if (mp_is_nonblocking_error(*errcode) && done != 0) {
|
|
|
|
*errcode = 0;
|
|
|
|
}
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
if (flags & MP_STREAM_RW_ONCE) {
|
|
|
|
return out_sz;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf += out_sz;
|
|
|
|
size -= out_sz;
|
|
|
|
done += out_sz;
|
|
|
|
}
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
2015-12-08 23:34:59 +00:00
|
|
|
const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) {
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(self_in);
|
2016-08-20 12:45:25 +01:00
|
|
|
const mp_stream_p_t *stream_p = type->protocol;
|
2015-12-08 23:34:59 +00:00
|
|
|
if (stream_p == NULL
|
|
|
|
|| ((flags & MP_STREAM_OP_READ) && stream_p->read == NULL)
|
|
|
|
|| ((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL)
|
|
|
|
|| ((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) {
|
2014-01-08 00:43:48 +00:00
|
|
|
// CPython: io.UnsupportedOperation, OSError subclass
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_OSError, "stream operation not supported");
|
2014-01-08 00:43:48 +00:00
|
|
|
}
|
2015-12-08 23:34:59 +00:00
|
|
|
return stream_p;
|
|
|
|
}
|
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
STATIC mp_obj_t stream_read_generic(size_t n_args, const mp_obj_t *args, byte flags) {
|
2014-07-16 11:45:10 +01:00
|
|
|
// What to do if sz < -1? Python docs don't specify this case.
|
|
|
|
// CPython does a readall, but here we silently let negatives through,
|
|
|
|
// and they will cause a MemoryError.
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t sz;
|
2014-01-16 10:53:46 +00:00
|
|
|
if (n_args == 1 || ((sz = mp_obj_get_int(args[1])) == -1)) {
|
|
|
|
return stream_readall(args[0]);
|
|
|
|
}
|
2014-06-15 21:23:36 +01:00
|
|
|
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
|
|
|
|
|
2014-06-15 21:23:36 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_STR_UNICODE
|
2015-12-08 23:34:59 +00:00
|
|
|
if (stream_p->is_text) {
|
2014-07-16 11:45:10 +01:00
|
|
|
// We need to read sz number of unicode characters. Because we don't have any
|
|
|
|
// buffering, and because the stream API can only read bytes, we must read here
|
|
|
|
// in units of bytes and must never over read. If we want sz chars, then reading
|
|
|
|
// sz bytes will never over-read, so we follow this approach, in a loop to keep
|
|
|
|
// reading until we have exactly enough chars. This will be 1 read for text
|
|
|
|
// with ASCII-only chars, and about 2 reads for text with a couple of non-ASCII
|
|
|
|
// chars. For text with lots of non-ASCII chars, it'll be pretty inefficient
|
|
|
|
// in time and memory.
|
|
|
|
|
|
|
|
vstr_t vstr;
|
|
|
|
vstr_init(&vstr, sz);
|
|
|
|
mp_uint_t more_bytes = sz;
|
|
|
|
mp_uint_t last_buf_offset = 0;
|
|
|
|
while (more_bytes > 0) {
|
|
|
|
char *p = vstr_add_len(&vstr, more_bytes);
|
|
|
|
int error;
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
mp_uint_t out_sz = mp_stream_read_exactly(args[0], p, more_bytes, &error);
|
|
|
|
if (error != 0) {
|
2014-07-16 11:45:10 +01:00
|
|
|
vstr_cut_tail_bytes(&vstr, more_bytes);
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2014-07-16 11:45:10 +01:00
|
|
|
// With non-blocking streams, we read as much as we can.
|
|
|
|
// If we read nothing, return None, just like read().
|
|
|
|
// Otherwise, return data read so far.
|
|
|
|
// TODO what if we have read only half a non-ASCII char?
|
|
|
|
if (vstr.len == 0) {
|
|
|
|
vstr_clear(&vstr);
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-07-16 11:45:10 +01:00
|
|
|
}
|
|
|
|
|
2014-07-27 22:38:58 +01:00
|
|
|
if (out_sz < more_bytes) {
|
2014-07-16 11:45:10 +01:00
|
|
|
// Finish reading.
|
|
|
|
// TODO what if we have read only half a non-ASCII char?
|
2014-07-22 00:51:07 +01:00
|
|
|
vstr_cut_tail_bytes(&vstr, more_bytes - out_sz);
|
|
|
|
if (out_sz == 0) {
|
2016-08-20 12:45:25 +01:00
|
|
|
break;
|
2014-07-22 00:51:07 +01:00
|
|
|
}
|
2014-07-16 11:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// count chars from bytes just read
|
|
|
|
for (mp_uint_t off = last_buf_offset;;) {
|
|
|
|
byte b = vstr.buf[off];
|
|
|
|
int n;
|
|
|
|
if (!UTF8_IS_NONASCII(b)) {
|
|
|
|
// 1-byte ASCII char
|
|
|
|
n = 1;
|
|
|
|
} else if ((b & 0xe0) == 0xc0) {
|
|
|
|
// 2-byte char
|
|
|
|
n = 2;
|
|
|
|
} else if ((b & 0xf0) == 0xe0) {
|
|
|
|
// 3-byte char
|
|
|
|
n = 3;
|
|
|
|
} else if ((b & 0xf8) == 0xf0) {
|
|
|
|
// 4-byte char
|
|
|
|
n = 4;
|
|
|
|
} else {
|
|
|
|
// TODO
|
|
|
|
n = 5;
|
|
|
|
}
|
|
|
|
if (off + n <= vstr.len) {
|
|
|
|
// got a whole char in n bytes
|
|
|
|
off += n;
|
|
|
|
sz -= 1;
|
|
|
|
last_buf_offset = off;
|
|
|
|
if (off >= vstr.len) {
|
|
|
|
more_bytes = sz;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// didn't get a whole char, so work out how many extra bytes are needed for
|
|
|
|
// this partial char, plus bytes for additional chars that we want
|
|
|
|
more_bytes = (off + n - vstr.len) + (sz - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-21 19:14:25 +00:00
|
|
|
return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
|
2014-06-15 21:23:36 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-01-21 22:48:37 +00:00
|
|
|
vstr_t vstr;
|
|
|
|
vstr_init_len(&vstr, sz);
|
2014-01-08 00:43:48 +00:00
|
|
|
int error;
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
mp_uint_t out_sz = mp_stream_rw(args[0], vstr.buf, sz, &error, flags);
|
|
|
|
if (error != 0) {
|
2015-01-21 22:48:37 +00:00
|
|
|
vstr_clear(&vstr);
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2014-05-06 23:39:38 +01:00
|
|
|
// https://docs.python.org/3.4/library/io.html#io.RawIOBase.read
|
|
|
|
// "If the object is in non-blocking mode and no bytes are available,
|
|
|
|
// None is returned."
|
|
|
|
// This is actually very weird, as naive truth check will treat
|
|
|
|
// this as EOF.
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-01-08 00:43:48 +00:00
|
|
|
} else {
|
2015-01-21 22:48:37 +00:00
|
|
|
vstr.len = out_sz;
|
2015-12-08 23:34:59 +00:00
|
|
|
return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
|
2014-01-08 00:43:48 +00:00
|
|
|
}
|
|
|
|
}
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
|
|
|
|
STATIC mp_obj_t stream_read(size_t n_args, const mp_obj_t *args) {
|
|
|
|
return stream_read_generic(n_args, args, MP_STREAM_RW_READ);
|
|
|
|
}
|
2016-04-10 12:41:28 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read_obj, 1, 2, stream_read);
|
2014-01-08 00:43:48 +00:00
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
STATIC mp_obj_t stream_read1(size_t n_args, const mp_obj_t *args) {
|
|
|
|
return stream_read_generic(n_args, args, MP_STREAM_RW_READ | MP_STREAM_RW_ONCE);
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read1_obj, 1, 2, stream_read1);
|
|
|
|
|
|
|
|
mp_obj_t mp_stream_write(mp_obj_t self_in, const void *buf, size_t len, byte flags) {
|
2014-01-08 00:43:48 +00:00
|
|
|
int error;
|
2020-02-27 04:36:53 +00:00
|
|
|
mp_uint_t out_sz = mp_stream_rw(self_in, (void *)buf, len, &error, flags);
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
if (error != 0) {
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2014-05-06 23:39:38 +01:00
|
|
|
// http://docs.python.org/3/library/io.html#io.RawIOBase.write
|
|
|
|
// "None is returned if the raw stream is set not to block and
|
|
|
|
// no single byte could be readily written to it."
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-01-08 00:43:48 +00:00
|
|
|
} else {
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(out_sz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-20 06:56:32 +01:00
|
|
|
// This is used to adapt a stream object to an mp_print_t interface
|
2015-11-27 17:01:44 +00:00
|
|
|
void mp_stream_write_adaptor(void *self, const char *buf, size_t len) {
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
mp_stream_write(MP_OBJ_FROM_PTR(self), buf, len, MP_STREAM_RW_WRITE);
|
2016-03-24 17:09:00 +00:00
|
|
|
}
|
|
|
|
|
2016-07-13 23:44:50 +01:00
|
|
|
STATIC mp_obj_t stream_write_method(size_t n_args, const mp_obj_t *args) {
|
2014-07-13 21:04:17 +01:00
|
|
|
mp_buffer_info_t bufinfo;
|
2016-07-13 23:44:50 +01:00
|
|
|
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
|
|
|
|
size_t max_len = (size_t)-1;
|
|
|
|
size_t off = 0;
|
|
|
|
if (n_args == 3) {
|
|
|
|
max_len = mp_obj_get_int_truncated(args[2]);
|
|
|
|
} else if (n_args == 4) {
|
|
|
|
off = mp_obj_get_int_truncated(args[2]);
|
|
|
|
max_len = mp_obj_get_int_truncated(args[3]);
|
|
|
|
if (off > bufinfo.len) {
|
|
|
|
off = bufinfo.len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bufinfo.len -= off;
|
2020-02-27 04:36:53 +00:00
|
|
|
return mp_stream_write(args[0], (byte *)bufinfo.buf + off, MIN(bufinfo.len, max_len), MP_STREAM_RW_WRITE);
|
2014-07-13 21:04:17 +01:00
|
|
|
}
|
2016-07-13 23:44:50 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_write_obj, 2, 4, stream_write_method);
|
2014-07-13 21:04:17 +01:00
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
STATIC mp_obj_t stream_write1_method(mp_obj_t self_in, mp_obj_t arg) {
|
|
|
|
mp_buffer_info_t bufinfo;
|
|
|
|
mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
|
|
|
|
return mp_stream_write(self_in, bufinfo.buf, bufinfo.len, MP_STREAM_RW_WRITE | MP_STREAM_RW_ONCE);
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_2(mp_stream_write1_obj, stream_write1_method);
|
|
|
|
|
2016-01-03 14:21:40 +00:00
|
|
|
STATIC mp_obj_t stream_readinto(size_t n_args, const mp_obj_t *args) {
|
2014-10-18 20:44:07 +01:00
|
|
|
mp_buffer_info_t bufinfo;
|
2014-10-23 19:22:08 +01:00
|
|
|
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_WRITE);
|
|
|
|
|
|
|
|
// CPython extension: if 2nd arg is provided, that's max len to read,
|
|
|
|
// instead of full buffer. Similar to
|
|
|
|
// https://docs.python.org/3/library/socket.html#socket.socket.recv_into
|
|
|
|
mp_uint_t len = bufinfo.len;
|
|
|
|
if (n_args > 2) {
|
2015-05-12 23:05:53 +01:00
|
|
|
len = mp_obj_get_int(args[2]);
|
2014-10-23 19:22:08 +01:00
|
|
|
if (len > bufinfo.len) {
|
|
|
|
len = bufinfo.len;
|
|
|
|
}
|
|
|
|
}
|
2014-10-18 20:44:07 +01:00
|
|
|
|
|
|
|
int error;
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-18 00:40:03 +01:00
|
|
|
mp_uint_t out_sz = mp_stream_read_exactly(args[0], bufinfo.buf, len, &error);
|
|
|
|
if (error != 0) {
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2014-10-18 20:44:07 +01:00
|
|
|
return mp_const_none;
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-10-18 20:44:07 +01:00
|
|
|
} else {
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(out_sz);
|
|
|
|
}
|
|
|
|
}
|
2016-04-10 12:41:28 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_readinto_obj, 2, 3, stream_readinto);
|
2014-10-18 20:44:07 +01:00
|
|
|
|
2014-02-12 16:31:30 +00:00
|
|
|
STATIC mp_obj_t stream_readall(mp_obj_t self_in) {
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(self_in);
|
2014-01-13 21:25:33 +00:00
|
|
|
|
2014-10-24 12:26:12 +01:00
|
|
|
mp_uint_t total_size = 0;
|
2015-01-21 19:14:25 +00:00
|
|
|
vstr_t vstr;
|
|
|
|
vstr_init(&vstr, DEFAULT_BUFFER_SIZE);
|
|
|
|
char *p = vstr.buf;
|
2015-01-23 15:58:05 +00:00
|
|
|
mp_uint_t current_read = DEFAULT_BUFFER_SIZE;
|
2014-01-13 21:25:33 +00:00
|
|
|
while (true) {
|
2014-10-24 12:26:12 +01:00
|
|
|
int error;
|
2015-12-08 23:34:59 +00:00
|
|
|
mp_uint_t out_sz = stream_p->read(self_in, p, current_read, &error);
|
2014-07-27 22:38:58 +01:00
|
|
|
if (out_sz == MP_STREAM_ERROR) {
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2014-05-06 23:48:12 +01:00
|
|
|
// With non-blocking streams, we read as much as we can.
|
|
|
|
// If we read nothing, return None, just like read().
|
|
|
|
// Otherwise, return data read so far.
|
|
|
|
if (total_size == 0) {
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-01-13 21:25:33 +00:00
|
|
|
}
|
|
|
|
if (out_sz == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
total_size += out_sz;
|
|
|
|
if (out_sz < current_read) {
|
|
|
|
current_read -= out_sz;
|
|
|
|
p += out_sz;
|
|
|
|
} else {
|
2015-01-21 22:48:37 +00:00
|
|
|
p = vstr_extend(&vstr, DEFAULT_BUFFER_SIZE);
|
2015-01-23 15:58:05 +00:00
|
|
|
current_read = DEFAULT_BUFFER_SIZE;
|
2014-01-13 21:25:33 +00:00
|
|
|
}
|
|
|
|
}
|
2014-01-22 14:35:10 +00:00
|
|
|
|
2015-01-21 19:14:25 +00:00
|
|
|
vstr.len = total_size;
|
2015-12-08 23:34:59 +00:00
|
|
|
return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
|
2014-01-13 21:25:33 +00:00
|
|
|
}
|
|
|
|
|
2014-01-15 21:39:44 +00:00
|
|
|
// Unbuffered, inefficient implementation of readline() for raw I/O files.
|
2016-01-03 14:21:40 +00:00
|
|
|
STATIC mp_obj_t stream_unbuffered_readline(size_t n_args, const mp_obj_t *args) {
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
|
2014-01-15 21:39:44 +00:00
|
|
|
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t max_size = -1;
|
2014-01-15 21:39:44 +00:00
|
|
|
if (n_args > 1) {
|
|
|
|
max_size = MP_OBJ_SMALL_INT_VALUE(args[1]);
|
|
|
|
}
|
|
|
|
|
2015-01-28 23:43:01 +00:00
|
|
|
vstr_t vstr;
|
2014-01-15 21:39:44 +00:00
|
|
|
if (max_size != -1) {
|
2015-01-28 23:43:01 +00:00
|
|
|
vstr_init(&vstr, max_size);
|
2014-01-15 21:39:44 +00:00
|
|
|
} else {
|
2015-01-28 23:43:01 +00:00
|
|
|
vstr_init(&vstr, 16);
|
2014-01-15 21:39:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
while (max_size == -1 || max_size-- != 0) {
|
2015-01-28 23:43:01 +00:00
|
|
|
char *p = vstr_add_len(&vstr, 1);
|
2014-10-24 12:26:12 +01:00
|
|
|
int error;
|
2015-12-08 23:34:59 +00:00
|
|
|
mp_uint_t out_sz = stream_p->read(args[0], p, 1, &error);
|
2014-07-27 22:38:58 +01:00
|
|
|
if (out_sz == MP_STREAM_ERROR) {
|
2015-10-18 13:37:19 +01:00
|
|
|
if (mp_is_nonblocking_error(error)) {
|
2015-01-28 23:43:01 +00:00
|
|
|
if (vstr.len == 1) {
|
2014-10-16 10:22:52 +01:00
|
|
|
// We just incremented it, but otherwise we read nothing
|
2016-10-27 20:12:59 +01:00
|
|
|
// and immediately got EAGAIN. This case is not well
|
2014-10-16 10:22:52 +01:00
|
|
|
// specified in
|
|
|
|
// https://docs.python.org/3/library/io.html#io.IOBase.readline
|
|
|
|
// unlike similar case for read(). But we follow the latter's
|
|
|
|
// behavior - return None.
|
2015-01-28 23:43:01 +00:00
|
|
|
vstr_clear(&vstr);
|
2014-10-16 10:22:52 +01:00
|
|
|
return mp_const_none;
|
|
|
|
} else {
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-01-15 21:39:44 +00:00
|
|
|
}
|
2014-01-22 08:34:45 +00:00
|
|
|
if (out_sz == 0) {
|
2020-02-27 04:36:53 +00:00
|
|
|
done:
|
2014-01-22 08:34:45 +00:00
|
|
|
// Back out previously added byte
|
|
|
|
// Consider, what's better - read a char and get OutOfMemory (so read
|
|
|
|
// char is lost), or allocate first as we do.
|
2015-01-28 23:43:01 +00:00
|
|
|
vstr_cut_tail_bytes(&vstr, 1);
|
2014-01-22 08:34:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*p == '\n') {
|
2014-01-15 21:39:44 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-01-28 23:43:01 +00:00
|
|
|
|
2015-12-08 23:34:59 +00:00
|
|
|
return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
|
2014-05-03 22:01:32 +01:00
|
|
|
}
|
2016-04-10 12:41:28 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_unbuffered_readline_obj, 1, 2, stream_unbuffered_readline);
|
2014-05-03 22:01:32 +01:00
|
|
|
|
|
|
|
// TODO take an optional extra argument (what does it do exactly?)
|
|
|
|
STATIC mp_obj_t stream_unbuffered_readlines(mp_obj_t self) {
|
|
|
|
mp_obj_t lines = mp_obj_new_list(0, NULL);
|
|
|
|
for (;;) {
|
|
|
|
mp_obj_t line = stream_unbuffered_readline(1, &self);
|
2014-06-13 21:46:21 +01:00
|
|
|
if (!mp_obj_is_true(line)) {
|
2014-05-03 22:01:32 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
mp_obj_list_append(lines, line);
|
|
|
|
}
|
|
|
|
return lines;
|
2014-01-15 21:39:44 +00:00
|
|
|
}
|
2014-05-03 22:01:32 +01:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_unbuffered_readlines_obj, stream_unbuffered_readlines);
|
2014-01-15 21:39:44 +00:00
|
|
|
|
2014-01-20 16:35:32 +00:00
|
|
|
mp_obj_t mp_stream_unbuffered_iter(mp_obj_t self) {
|
|
|
|
mp_obj_t l_in = stream_unbuffered_readline(1, &self);
|
2014-06-13 21:46:21 +01:00
|
|
|
if (mp_obj_is_true(l_in)) {
|
2014-01-20 16:35:32 +00:00
|
|
|
return l_in;
|
|
|
|
}
|
2014-04-17 23:19:36 +01:00
|
|
|
return MP_OBJ_STOP_ITERATION;
|
2014-01-20 16:35:32 +00:00
|
|
|
}
|
2014-01-15 21:39:44 +00:00
|
|
|
|
2018-03-07 06:48:53 +00:00
|
|
|
mp_obj_t mp_stream_close(mp_obj_t stream) {
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(stream);
|
2018-03-07 06:48:53 +00:00
|
|
|
int error;
|
|
|
|
mp_uint_t res = stream_p->ioctl(stream, MP_STREAM_CLOSE, 0, &error);
|
|
|
|
if (res == MP_STREAM_ERROR) {
|
|
|
|
mp_raise_OSError(error);
|
|
|
|
}
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_close_obj, mp_stream_close);
|
|
|
|
|
2016-01-03 14:21:40 +00:00
|
|
|
STATIC mp_obj_t stream_seek(size_t n_args, const mp_obj_t *args) {
|
2014-11-16 22:16:14 +00:00
|
|
|
struct mp_stream_seek_t seek_s;
|
|
|
|
// TODO: Could be uint64
|
|
|
|
seek_s.offset = mp_obj_get_int(args[1]);
|
2017-08-20 19:57:36 +01:00
|
|
|
seek_s.whence = SEEK_SET;
|
2014-11-16 22:16:14 +00:00
|
|
|
if (n_args == 3) {
|
|
|
|
seek_s.whence = mp_obj_get_int(args[2]);
|
|
|
|
}
|
|
|
|
|
2017-08-20 19:57:36 +01:00
|
|
|
// In POSIX, it's error to seek before end of stream, we enforce it here.
|
|
|
|
if (seek_s.whence == SEEK_SET && seek_s.offset < 0) {
|
|
|
|
mp_raise_OSError(MP_EINVAL);
|
|
|
|
}
|
|
|
|
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
|
2014-11-16 22:16:14 +00:00
|
|
|
int error;
|
2015-12-08 23:34:59 +00:00
|
|
|
mp_uint_t res = stream_p->ioctl(args[0], MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &error);
|
2014-11-16 22:16:14 +00:00
|
|
|
if (res == MP_STREAM_ERROR) {
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2014-11-16 22:16:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Could be uint64
|
|
|
|
return mp_obj_new_int_from_uint(seek_s.offset);
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_seek_obj, 2, 3, stream_seek);
|
|
|
|
|
2015-08-05 00:45:30 +01:00
|
|
|
STATIC mp_obj_t stream_tell(mp_obj_t self) {
|
|
|
|
mp_obj_t offset = MP_OBJ_NEW_SMALL_INT(0);
|
|
|
|
mp_obj_t whence = MP_OBJ_NEW_SMALL_INT(SEEK_CUR);
|
|
|
|
const mp_obj_t args[3] = {self, offset, whence};
|
|
|
|
return stream_seek(3, args);
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_tell_obj, stream_tell);
|
|
|
|
|
2016-07-26 22:39:10 +01:00
|
|
|
STATIC mp_obj_t stream_flush(mp_obj_t self) {
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(self);
|
2016-07-26 22:39:10 +01:00
|
|
|
int error;
|
|
|
|
mp_uint_t res = stream_p->ioctl(self, MP_STREAM_FLUSH, 0, &error);
|
|
|
|
if (res == MP_STREAM_ERROR) {
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2016-07-26 22:39:10 +01:00
|
|
|
}
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_flush_obj, stream_flush);
|
|
|
|
|
2016-04-10 10:45:46 +01:00
|
|
|
STATIC mp_obj_t stream_ioctl(size_t n_args, const mp_obj_t *args) {
|
|
|
|
mp_buffer_info_t bufinfo;
|
2016-04-10 11:36:44 +01:00
|
|
|
uintptr_t val = 0;
|
|
|
|
if (n_args > 2) {
|
2016-04-10 12:37:59 +01:00
|
|
|
if (mp_get_buffer(args[2], &bufinfo, MP_BUFFER_WRITE)) {
|
2016-04-10 11:36:44 +01:00
|
|
|
val = (uintptr_t)bufinfo.buf;
|
2016-04-10 12:37:59 +01:00
|
|
|
} else {
|
|
|
|
val = mp_obj_get_int_truncated(args[2]);
|
2016-04-10 11:36:44 +01:00
|
|
|
}
|
2016-04-10 10:45:46 +01:00
|
|
|
}
|
|
|
|
|
2018-06-13 02:54:44 +01:00
|
|
|
const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
|
2016-04-10 10:45:46 +01:00
|
|
|
int error;
|
2016-04-10 11:31:52 +01:00
|
|
|
mp_uint_t res = stream_p->ioctl(args[0], mp_obj_get_int(args[1]), val, &error);
|
2016-04-10 10:45:46 +01:00
|
|
|
if (res == MP_STREAM_ERROR) {
|
2016-10-07 03:31:59 +01:00
|
|
|
mp_raise_OSError(error);
|
2016-04-10 10:45:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return mp_obj_new_int(res);
|
|
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj, 2, 3, stream_ioctl);
|
2016-07-29 22:25:06 +01:00
|
|
|
|
2016-07-30 18:05:56 +01:00
|
|
|
#if MICROPY_STREAMS_POSIX_API
|
2016-07-29 22:25:06 +01:00
|
|
|
/*
|
|
|
|
* POSIX-like functions
|
|
|
|
*
|
|
|
|
* These functions have POSIX-compatible signature (except for "void *stream"
|
|
|
|
* first argument instead of "int fd"). They are useful to port existing
|
|
|
|
* POSIX-compatible software to work with MicroPython streams.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// errno-like variable. If any of the functions below returned with error
|
|
|
|
// status, this variable will contain error no.
|
|
|
|
int mp_stream_errno;
|
|
|
|
|
2018-08-14 08:36:08 +01:00
|
|
|
ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
|
2020-02-27 04:36:53 +00:00
|
|
|
mp_obj_base_t *o = stream;
|
2016-07-29 22:25:06 +01:00
|
|
|
const mp_stream_p_t *stream_p = o->type->protocol;
|
2018-08-14 08:36:08 +01:00
|
|
|
mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &mp_stream_errno);
|
2016-07-29 22:25:06 +01:00
|
|
|
if (out_sz == MP_STREAM_ERROR) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return out_sz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-14 08:36:08 +01:00
|
|
|
ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
|
2020-02-27 04:36:53 +00:00
|
|
|
mp_obj_base_t *o = stream;
|
2016-07-29 22:25:06 +01:00
|
|
|
const mp_stream_p_t *stream_p = o->type->protocol;
|
2018-08-14 08:36:08 +01:00
|
|
|
mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &mp_stream_errno);
|
2016-07-29 22:25:06 +01:00
|
|
|
if (out_sz == MP_STREAM_ERROR) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return out_sz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-14 08:36:08 +01:00
|
|
|
off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
|
2020-02-27 04:36:53 +00:00
|
|
|
const mp_obj_base_t *o = stream;
|
2016-07-29 22:25:06 +01:00
|
|
|
const mp_stream_p_t *stream_p = o->type->protocol;
|
|
|
|
struct mp_stream_seek_t seek_s;
|
|
|
|
seek_s.offset = offset;
|
|
|
|
seek_s.whence = whence;
|
2018-08-14 08:36:08 +01:00
|
|
|
mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &mp_stream_errno);
|
2016-07-29 22:25:06 +01:00
|
|
|
if (res == MP_STREAM_ERROR) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return seek_s.offset;
|
|
|
|
}
|
|
|
|
|
2018-08-14 08:36:08 +01:00
|
|
|
int mp_stream_posix_fsync(void *stream) {
|
2020-02-27 04:36:53 +00:00
|
|
|
mp_obj_base_t *o = stream;
|
2016-07-29 22:25:06 +01:00
|
|
|
const mp_stream_p_t *stream_p = o->type->protocol;
|
2018-08-14 08:36:08 +01:00
|
|
|
mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &mp_stream_errno);
|
2016-07-29 22:25:06 +01:00
|
|
|
if (res == MP_STREAM_ERROR) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2016-07-30 18:05:56 +01:00
|
|
|
|
|
|
|
#endif
|