From af0932a7793478f0b90b754d38955d69700b0bee Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 4 Jun 2018 15:54:26 +1000
Subject: [PATCH] py/modio: Add uio.IOBase class to allow to define user
streams.
A user class derived from IOBase and implementing readinto/write/ioctl can
now be used anywhere a native stream object is accepted.
The mapping from C to Python is:
stream_p->read --> readinto(buf)
stream_p->write --> write(buf)
stream_p->ioctl --> ioctl(request, arg)
Among other things it allows the user to:
- create an object which can be passed as the file argument to print:
print(..., file=myobj), and then print will pass all the data to the
object via the objects write method (same as CPython)
- pass a user object to uio.BufferedWriter to buffer the writes (same as
CPython)
- use select.select on a user object
- register user objects with select.poll, in particular so user objects can
be used with uasyncio
- create user files that can be returned from user filesystems, and import
can import scripts from these user files
For example:
class MyOut(io.IOBase):
def write(self, buf):
print('write', repr(buf))
return len(buf)
print('hello', file=MyOut())
The feature is enabled via MICROPY_PY_IO_IOBASE which is disabled by
default.
---
py/modio.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++
py/mpconfig.h | 5 ++++
2 files changed, 74 insertions(+)
diff --git a/py/modio.c b/py/modio.c
index 3a5c69c4c..e75432b28 100644
--- a/py/modio.c
+++ b/py/modio.c
@@ -30,6 +30,8 @@
#include "py/runtime.h"
#include "py/builtin.h"
#include "py/stream.h"
+#include "py/binary.h"
+#include "py/objarray.h"
#include "py/objstringio.h"
#include "py/frozenmod.h"
@@ -38,6 +40,70 @@
extern const mp_obj_type_t mp_type_fileio;
extern const mp_obj_type_t mp_type_textio;
+#if MICROPY_PY_IO_IOBASE
+
+STATIC const mp_obj_type_t mp_type_iobase;
+
+STATIC mp_obj_base_t iobase_singleton = {&mp_type_iobase};
+
+STATIC mp_obj_t iobase_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ (void)type;
+ (void)n_args;
+ (void)n_kw;
+ (void)args;
+ return MP_OBJ_FROM_PTR(&iobase_singleton);
+}
+
+STATIC mp_uint_t iobase_read_write(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode, qstr qst) {
+ mp_obj_t dest[3];
+ mp_load_method(obj, qst, dest);
+ mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, size, buf};
+ dest[2] = MP_OBJ_FROM_PTR(&ar);
+ mp_obj_t ret = mp_call_method_n_kw(1, 0, dest);
+ if (ret == mp_const_none) {
+ *errcode = MP_EAGAIN;
+ return MP_STREAM_ERROR;
+ } else {
+ return mp_obj_get_int(ret);
+ }
+}
+STATIC mp_uint_t iobase_read(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode) {
+ return iobase_read_write(obj, buf, size, errcode, MP_QSTR_readinto);
+}
+
+STATIC mp_uint_t iobase_write(mp_obj_t obj, const void *buf, mp_uint_t size, int *errcode) {
+ return iobase_read_write(obj, (void*)buf, size, errcode, MP_QSTR_write);
+}
+
+STATIC mp_uint_t iobase_ioctl(mp_obj_t obj, mp_uint_t request, uintptr_t arg, int *errcode) {
+ mp_obj_t dest[4];
+ mp_load_method(obj, MP_QSTR_ioctl, dest);
+ dest[2] = mp_obj_new_int_from_uint(request);
+ dest[3] = mp_obj_new_int_from_uint(arg);
+ mp_int_t ret = mp_obj_get_int(mp_call_method_n_kw(2, 0, dest));
+ if (ret >= 0) {
+ return ret;
+ } else {
+ *errcode = -ret;
+ return MP_STREAM_ERROR;
+ }
+}
+
+STATIC const mp_stream_p_t iobase_p = {
+ .read = iobase_read,
+ .write = iobase_write,
+ .ioctl = iobase_ioctl,
+};
+
+STATIC const mp_obj_type_t mp_type_iobase = {
+ { &mp_type_type },
+ .name = MP_QSTR_IOBase,
+ .make_new = iobase_make_new,
+ .protocol = &iobase_p,
+};
+
+#endif // MICROPY_PY_IO_IOBASE
+
#if MICROPY_PY_IO_BUFFEREDWRITER
typedef struct _mp_obj_bufwriter_t {
mp_obj_base_t base;
@@ -187,6 +253,9 @@ STATIC const mp_rom_map_elem_t mp_module_io_globals_table[] = {
// Note: mp_builtin_open_obj should be defined by port, it's not
// part of the core.
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
+ #if MICROPY_PY_IO_IOBASE
+ { MP_ROM_QSTR(MP_QSTR_IOBase), MP_ROM_PTR(&mp_type_iobase) },
+ #endif
#if MICROPY_PY_IO_RESOURCE_STREAM
{ MP_ROM_QSTR(MP_QSTR_resource_stream), MP_ROM_PTR(&resource_stream_obj) },
#endif
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 26c9cd92b..a85b22128 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -998,6 +998,11 @@ typedef double mp_float_t;
#define MICROPY_PY_IO (1)
#endif
+// Whether to provide "io.IOBase" class to support user streams
+#ifndef MICROPY_PY_IO_IOBASE
+#define MICROPY_PY_IO_IOBASE (0)
+#endif
+
// Whether to provide "uio.resource_stream()" function with
// the semantics of CPython's pkg_resources.resource_stream()
// (allows to access binary resources in frozen source packages).
--
GitLab