ports/unix: Add full uos.dupterm support.

pi-anl · pi-anl · commit 42bfad90264c · 2020-05-27T16:31:43.000+10:00
diff --git a/ports/unix/main.c b/ports/unix/main.c
@@ -64,9 +64,12 @@ long heap_size = 1024 * 1024 * (sizeof(mp_uint_t) / 4);
 
 STATIC void stderr_print_strn(void *env, const char *str, size_t len) {
     (void)env;
+    #if MICROPY_PY_OS_DUPTERM
+    mp_uos_dupterm_tx_strn(str, len);
+    #else
     ssize_t ret;
     MP_HAL_RETRY_SYSCALL(ret, write(STDERR_FILENO, str, len), {});
-    mp_uos_dupterm_tx_strn(str, len);
+    #endif
 }
 
 const mp_print_t mp_stderr_print = {NULL, stderr_print_strn};
@@ -535,6 +538,10 @@ MP_NOINLINE int main_(int argc, char **argv) {
     }
     #endif
 
+    #if MICROPY_PY_OS_DUPTERM
+    init_dupterm_stdio();
+    #endif 
+
     // Here is some example code to create a class and instance of that class.
     // First is the Python, then the C code.
     //
diff --git a/ports/unix/mphalport.h b/ports/unix/mphalport.h
@@ -103,3 +103,7 @@ enum {
 
 void mp_hal_get_mac(int idx, uint8_t buf[6]);
 #endif
+
+#if MICROPY_PY_OS_DUPTERM
+void init_dupterm_stdio();
+#endif 
diff --git a/ports/unix/unix_mphal.c b/ports/unix/unix_mphal.c
@@ -33,6 +33,8 @@
 #include "py/mphal.h"
 #include "py/mpthread.h"
 #include "py/runtime.h"
+#include "py/stream.h"
+#include "py/mperrno.h"
 #include "extmod/misc.h"
 
 #ifndef _WIN32
@@ -64,8 +66,11 @@ STATIC void sighandler(int signum) {
 }
 #endif
 
+int mp_interrupt_char = -1;
+
 void mp_hal_set_interrupt_char(char c) {
     // configure terminal settings to (not) let ctrl-C through
+    mp_interrupt_char = c;
     if (c == CHAR_CTRL_C) {
         #ifndef _WIN32
         // enable signal handler
@@ -114,57 +119,85 @@ void mp_hal_stdio_mode_orig(void) {
 #endif
 
 #if MICROPY_PY_OS_DUPTERM
-static int call_dupterm_read(size_t idx) {
-    nlr_buf_t nlr;
-    if (nlr_push(&nlr) == 0) {
-        mp_obj_t read_m[3];
-        mp_load_method(MP_STATE_VM(dupterm_objs[idx]), MP_QSTR_read, read_m);
-        read_m[2] = MP_OBJ_NEW_SMALL_INT(1);
-        mp_obj_t res = mp_call_method_n_kw(1, 0, read_m);
-        if (res == mp_const_none) {
-            return -2;
-        }
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(res, &bufinfo, MP_BUFFER_READ);
-        if (bufinfo.len == 0) {
-            mp_printf(&mp_plat_print, "dupterm: EOF received, deactivating\n");
-            MP_STATE_VM(dupterm_objs[idx]) = MP_OBJ_NULL;
-            return -1;
-        }
-        nlr_pop();
-        return *(byte *)bufinfo.buf;
-    } else {
-        // Temporarily disable dupterm to avoid infinite recursion
-        mp_obj_t save_term = MP_STATE_VM(dupterm_objs[idx]);
-        MP_STATE_VM(dupterm_objs[idx]) = NULL;
-        mp_printf(&mp_plat_print, "dupterm: ");
-        mp_obj_print_exception(&mp_plat_print, nlr.ret_val);
-        MP_STATE_VM(dupterm_objs[idx]) = save_term;
+STATIC mp_uint_t unix_stdio_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
+    ssize_t ret;
+    MP_HAL_RETRY_SYSCALL(ret, read(STDIN_FILENO, (byte *)buf, size), {});
+    if (ret == 0) {
+        // return EAGAIN error to indicate non-blocking
+        *errcode = MP_EAGAIN;
+        return MP_STREAM_ERROR;
     }
+    return ret;
+}
+
+STATIC mp_uint_t unix_stdio_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    int ret;
+    MP_HAL_RETRY_SYSCALL(ret, write(STDOUT_FILENO, (const byte *)buf, size), {});
+    if (ret == 0) {
+        // return EAGAIN error to indicate non-blocking
+        *errcode = MP_EAGAIN;
+        return MP_STREAM_ERROR;
+    }
+    return ret;
+}
+
+STATIC mp_uint_t unix_stdio_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    *errcode = MP_EINVAL;
+    return MP_STREAM_ERROR;
+}
 
-    return -1;
+STATIC mp_obj_t unix_stdio_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args);
+
+STATIC const mp_stream_p_t unix_stdio_stream_p = {
+    .read = unix_stdio_read,
+    .write = unix_stdio_write,
+    .ioctl = unix_stdio_ioctl,
+};
+
+STATIC const mp_rom_map_elem_t unix_stdio_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj)},
+    { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj)},
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(unix_stdio_locals_dict, unix_stdio_locals_dict_table);
+
+const mp_obj_type_t unix_stdio_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_UNIX_STDIO,
+    .make_new = unix_stdio_make_new,
+    .protocol = &unix_stdio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&unix_stdio_locals_dict,
+};
+
+typedef struct _unix_stdio_obj_t {
+    mp_obj_base_t base;
+} unix_stdio_obj_t;
+
+STATIC const unix_stdio_obj_t unix_stdio_obj = {{&unix_stdio_type}};
+
+STATIC mp_obj_t unix_stdio_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    return MP_OBJ_FROM_PTR(&unix_stdio_obj);
+}
+
+void init_dupterm_stdio() {
+     MP_STATE_VM(dupterm_objs[0]) = MP_OBJ_FROM_PTR(&unix_stdio_obj);   
 }
 #endif
 
 int mp_hal_stdin_rx_chr(void) {
     #if MICROPY_PY_OS_DUPTERM
-    // TODO only support dupterm one slot at the moment
-    if (MP_STATE_VM(dupterm_objs[0]) != MP_OBJ_NULL) {
         int c;
         do {
-            c = call_dupterm_read(0);
+            c = mp_uos_dupterm_rx_chr();
         } while (c == -2);
-        if (c == -1) {
-            goto main_term;
-        }
         if (c == '\n') {
             c = '\r';
         }
         return c;
-    }
-main_term:;
-    #endif
-
+    #else
     unsigned char c;
     ssize_t ret;
     MP_HAL_RETRY_SYSCALL(ret, read(STDIN_FILENO, &c, 1), {});
@@ -174,12 +207,16 @@ main_term:;
         c = '\r';
     }
     return c;
+    #endif
 }
 
 void mp_hal_stdout_tx_strn(const char *str, size_t len) {
+    #if MICROPY_PY_OS_DUPTERM
+    mp_uos_dupterm_tx_strn(str, len);
+    #else
     ssize_t ret;
     MP_HAL_RETRY_SYSCALL(ret, write(STDOUT_FILENO, str, len), {});
-    mp_uos_dupterm_tx_strn(str, len);
+    #endif
 }
 
 // cooked is same as uncooked because the terminal does some postprocessing
