OpenPython v1.0 Ready

Author: EcmaXp

src/Makefile

@@ -36,7 +36,7 @@ CFLAGS += -O2 -DNDEBUG
 endif
 
 
-LDFLAGS = -nostdlib -T openpie.ld -Map=$@.map --cref
+LDFLAGS = -nostdlib -T openpython.ld -Map=$@.map --cref
 LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
 
 # Remove uncalled code from the final image.
@@ -59,7 +59,7 @@ SRC_C = \
 	modumsgpack.c \
 	moduvalue.c \
 	gccollect.c \
-	openpie_vfs.c \
+	openpython_vfs.c \
 	msgpack.c \
 	syscall.c \
 

src/build.py

@@ -15,9 +15,9 @@
 FOLDER = Path(__file__).parent
 BASE_FOLDER = FOLDER.parent
 OPMOD_PATH = BASE_FOLDER / "opmod"
-SOURCE_SYSCALL_TABLE: Path = OPMOD_PATH / "src/main/java/kr/pe/ecmaxp/openpie/arch/consts/OpenPieSystemCallTable.kt"
+SOURCE_SYSCALL_TABLE: Path = OPMOD_PATH / "src/main/java/kr/pe/ecmaxp/openpython/arch/consts/OpenPythonSystemCallTable.kt"
 TARGET_SYSCALL_TABLE: Path = FOLDER / "syscall_table.h"
-TARGET_FOLDER: Path = OPMOD_PATH / "src/main/resources/assets/openpie/firmwares/debug"  # TODO: place version
+TARGET_FOLDER: Path = OPMOD_PATH / "src/main/resources/assets/openpython/firmwares/debug"  # TODO: place version
 
 
 @dataclass

src/help.c

@@ -1,7 +1,7 @@
 #include "py/builtin.h"
 
-const char openpie_help_text[] =
-        "Welcome to MicroPython running under openpie!\n"
+const char openpython_help_text[] =
+        "Welcome to MicroPython running under openpython!\n"
         "\n"
         "For further help on a specific object, type help(obj)\n"
         #if MICROPY_PY_BUILTINS_HELP_MODULES

src/machine.c

@@ -45,9 +45,9 @@ void Reset_Handler(void) {
         }
     }
 
-    // OPENPIE_CONTROLLER->PENDING = (uint32_t) &MP_STATE_VM(mp_pending_exception);
-    // OPENPIE_CONTROLLER->EXCEPTION = (uint32_t) &MP_STATE_VM(mp_kbd_exception);
-    // OPENPIE_CONTROLLER->INTR_CHAR = (uint32_t) &mp_interrupt_char;
+    // OPENPYTHON_CONTROLLER->PENDING = (uint32_t) &MP_STATE_VM(mp_pending_exception);
+    // OPENPYTHON_CONTROLLER->EXCEPTION = (uint32_t) &MP_STATE_VM(mp_kbd_exception);
+    // OPENPYTHON_CONTROLLER->INTR_CHAR = (uint32_t) &mp_interrupt_char;
 
     // jump to board initialisation
     _start();

src/machine.h

@@ -1,5 +1,5 @@
-#ifndef OPENPIE_MACHINE_H
-#define OPENPIE_MACHINE_H
+#ifndef OPENPYTHON_MACHINE_H
+#define OPENPYTHON_MACHINE_H
 
 #include "py/objexcept.h"
 
@@ -9,4 +9,4 @@ void _exit(int status);
 void nlr_jump_fail(void *val);
 void NORETURN __fatal_error(const char *msg);
 
-#endif // OPENPIE_MACHINE_H
+#endif // OPENPYTHON_MACHINE_H

src/modules/bios.py

@@ -9,6 +9,70 @@ def bios():
         crash("no bios found; install a configured EEPROM with Python")
 
     eeprom = eeproms[0]
+    if True:
+        invoke(eeprom, 'setLabel', "EEPROM (micropython)")
+        invoke(eeprom, 'set', b"""#!micropython
+
+
+def main():
+    globals().pop('main')
+    from ucomponent import invoke, get_list as get_components
+    from ucomputer import crash, get_computer_address
+
+    def component(t):
+        seq = get_components(t)
+        return seq[0] if seq else None
+
+    def check_bootable(filesystems, address):
+        return address in filesystems and invoke(address, 'exists', '/init.py')
+
+    eeprom = __path__
+    filesystems = get_components("filesystem")
+
+    address = invoke(eeprom, 'getData').decode()
+    if not check_bootable(filesystems, address):
+        invoke(__path__, 'setData', b'')
+        for address in filesystems:
+            if check_bootable(filesystems, address):
+                invoke(eeprom, 'setData', address.encode())
+                break
+        else:
+            crash("no bootable medium found")
+
+    computer = get_computer_address()
+    invoke(computer, 'beep', 1000, 0.2)
+
+    gpu = component("gpu")
+    monitor = component("monitor")
+    if gpu and monitor:
+        invoke(gpu, "bind", monitor)
+
+    def load(address):
+        handle = invoke(address, 'open', '/init.py', 'r')
+        buffer = []
+
+        try:
+            while True:
+                buf = invoke(address, 'read', handle, 4096)
+                if not buf: break
+                buffer.append(buf)
+        finally:
+            invoke(address, 'close', handle)
+            handle.dispose()
+
+        content = b"".join(buffer)
+        return content.decode()
+
+    content = load(address)
+    context = {'__name__': '__main__', '__path__': address}
+    func = compile(content, '/init.py', "exec")
+    exec(func, context)
+
+
+if __name__ == '__main__':
+    main()
+""")
+
     data = invoke(eeprom, 'get')
     context = {'__name__': '__main__', '__path__': eeprom}
 

src/mpconfigport.h

@@ -121,7 +121,7 @@
 #define MICROPY_PY_BUILTINS_MIN_MAX (1)
 #define MICROPY_PY_BUILTINS_POW3 (1)
 #define MICROPY_PY_BUILTINS_HELP (1)
-#define MICROPY_PY_BUILTINS_HELP_TEXT openpie_help_text
+#define MICROPY_PY_BUILTINS_HELP_TEXT openpython_help_text
 #define MICROPY_PY_BUILTINS_HELP_MODULES (1)
 #define MICROPY_PY___FILE__ (1)
 #define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
@@ -203,9 +203,9 @@ extern const struct _mp_print_t debug_print;
 #define INT_FMT "%d"
 
 // Machine settings
-#define MICROPY_HW_BOARD_NAME "OpenPie"
+#define MICROPY_HW_BOARD_NAME "OpenPython"
 #define MICROPY_HW_MCU_NAME "Cortex-M0"
-#define MICROPY_OPENPIE_VFS (1)
+#define MICROPY_OPENPYTHON_VFS (1)
 
 #define MP_SSIZE_MAX (0x7fffffff)
 #define MP_NEED_LOG2 (1)
@@ -239,8 +239,8 @@ extern const struct _mp_obj_type_t mp_type_SystemError;
     mp_obj_t stderr_hook_obj; \
     mp_obj_t object_hook_obj; \
 
-#define mp_type_fileio mp_type_vfs_openpie_fileio
-#define mp_type_textio mp_type_vfs_openpie_textio
+#define mp_type_fileio mp_type_vfs_openpython_fileio
+#define mp_type_textio mp_type_vfs_openpython_textio
 
 #define mp_import_stat mp_vfs_import_stat
 #define mp_builtin_open mp_vfs_open

src/msgpack.h

@@ -1,5 +1,5 @@
-#ifndef OPENPIE_UMSGPACK_H
-#define OPENPIE_UMSGPACK_H
+#ifndef OPENPYTHON_UMSGPACK_H
+#define OPENPYTHON_UMSGPACK_H
 
 #include "py/obj.h"
 #include "lib/mpack/mpack.h"
@@ -19,4 +19,4 @@ void msgpack_dump_close(mpack_writer_t *writer);
 msgpack_result_t msgpack_dumps(mp_obj_t obj);
 msgpack_result_t msgpack_args_dumps(size_t n_args, const mp_obj_t *args);
 
-#endif // OPENPIE_UMSGPACK_H
+#endif // OPENPYTHON_UMSGPACK_H

src/openpie.ld src/openpython.ldsrc/openpie.ld renamed to src/openpython.ld

@@ -1,5 +1,5 @@
 /*
-    GNU linker script for OPENPIE
+    GNU linker script for OpenPython
 */
 
 /* Specify the memory areas */

src/openpie_vfs.c src/openpython_vfs.csrc/openpie_vfs.c renamed to src/openpython_vfs.c

@@ -32,35 +32,35 @@
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "py/mperrno.h"
-#include "openpie_vfs.h"
-#include "openpie_vfs.h"
+#include "openpython_vfs.h"
+#include "openpython_vfs.h"
 #include "syscall.h"
 
 
-#if MICROPY_OPENPIE_VFS
+#if MICROPY_OPENPYTHON_VFS
 
 
-typedef struct _mp_obj_vfs_openpie_file_t {
+typedef struct _mp_obj_vfs_openpython_file_t {
     mp_obj_base_t base;
     int fd;
-} mp_obj_vfs_openpie_file_t;
+} mp_obj_vfs_openpython_file_t;
 
-STATIC void check_fd_is_open(const mp_obj_vfs_openpie_file_t *o) {
+STATIC void check_fd_is_open(const mp_obj_vfs_openpython_file_t *o) {
     if (o->fd == -1) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "I/O operation on closed file"));
     }
 }
 
-STATIC void vfs_openpie_file_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+STATIC void vfs_openpython_file_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     // SVC_FUNCTION_START;
     (void) kind;
-    mp_obj_vfs_openpie_file_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_vfs_openpython_file_t *self = MP_OBJ_TO_PTR(self_in);
 
     mp_printf(print, "<io.%s fd=%d>", mp_obj_get_type_str(self_in), self->fd);
 }
 
-mp_obj_t mp_vfs_openpie_file_open(const mp_obj_type_t *type, mp_obj_t address_in, mp_obj_t path_in, mp_obj_t mode_in) {
-    mp_obj_vfs_openpie_file_t *o = m_new_obj(mp_obj_vfs_openpie_file_t);
+mp_obj_t mp_vfs_openpython_file_open(const mp_obj_type_t *type, mp_obj_t address_in, mp_obj_t path_in, mp_obj_t mode_in) {
+    mp_obj_vfs_openpython_file_t *o = m_new_obj(mp_obj_vfs_openpython_file_t);
     const char *address = mp_obj_str_get_str(address_in);
     const char *path = mp_obj_str_get_str(path_in);
     const char *mode = mp_obj_str_get_str(mode_in);
@@ -77,7 +77,7 @@ mp_obj_t mp_vfs_openpie_file_open(const mp_obj_type_t *type, mp_obj_t address_in
     return MP_OBJ_FROM_PTR(o);
 }
 
-STATIC mp_obj_t vfs_openpie_file_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t vfs_openpython_file_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     static const mp_arg_t allowed_args[] = {
             {MP_QSTR_address, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)}},
             {MP_QSTR_path,    MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)}},
@@ -86,26 +86,26 @@ STATIC mp_obj_t vfs_openpie_file_make_new(const mp_obj_type_t *type, size_t n_ar
 
     mp_arg_val_t arg_vals[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, args, MP_ARRAY_SIZE(allowed_args), allowed_args, arg_vals);
-    return mp_vfs_openpie_file_open(type, arg_vals[0].u_obj, arg_vals[1].u_obj, arg_vals[2].u_obj);
+    return mp_vfs_openpython_file_open(type, arg_vals[0].u_obj, arg_vals[1].u_obj, arg_vals[2].u_obj);
 }
 
-STATIC mp_obj_t vfs_openpie_file_fileno(mp_obj_t self_in) {
-    mp_obj_vfs_openpie_file_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t vfs_openpython_file_fileno(mp_obj_t self_in) {
+    mp_obj_vfs_openpython_file_t *self = MP_OBJ_TO_PTR(self_in);
     check_fd_is_open(self);
     return mp_obj_new_int(self->fd);
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_openpie_file_fileno_obj, vfs_openpie_file_fileno);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_openpython_file_fileno_obj, vfs_openpython_file_fileno);
 
-STATIC mp_obj_t vfs_openpie_file___exit__(size_t n_args, const mp_obj_t *args) {
+STATIC mp_obj_t vfs_openpython_file___exit__(size_t n_args, const mp_obj_t *args) {
     (void) n_args;
     return mp_stream_close(args[0]);
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vfs_openpie_file___exit___obj, 4, 4, vfs_openpie_file___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vfs_openpython_file___exit___obj, 4, 4, vfs_openpython_file___exit__);
 
-STATIC mp_uint_t vfs_openpie_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_vfs_openpie_file_t *o = MP_OBJ_TO_PTR(o_in);
+STATIC mp_uint_t vfs_openpython_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
+    mp_obj_vfs_openpython_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
 
     int count = 0;
@@ -117,8 +117,8 @@ STATIC mp_uint_t vfs_openpie_file_read(mp_obj_t o_in, void *buf, mp_uint_t size,
     return count;
 }
 
-STATIC mp_uint_t vfs_openpie_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_vfs_openpie_file_t *o = MP_OBJ_TO_PTR(o_in);
+STATIC mp_uint_t vfs_openpython_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
+    mp_obj_vfs_openpython_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
 #if MICROPY_PY_OS_DUPTERM
     if (o->flag & 1) {
@@ -150,8 +150,8 @@ STATIC mp_uint_t vfs_openpie_file_write(mp_obj_t o_in, const void *buf, mp_uint_
     return (mp_uint_t) written;
 }
 
-STATIC mp_uint_t vfs_openpie_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
-    mp_obj_vfs_openpie_file_t *o = MP_OBJ_TO_PTR(o_in);
+STATIC mp_uint_t vfs_openpython_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_vfs_openpython_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
     int errno;
     switch (request) {
@@ -188,7 +188,7 @@ STATIC mp_uint_t vfs_openpie_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintpt
 }
 
 STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
-        {MP_ROM_QSTR(MP_QSTR_fileno),    MP_ROM_PTR(&vfs_openpie_file_fileno_obj)},
+        {MP_ROM_QSTR(MP_QSTR_fileno),    MP_ROM_PTR(&vfs_openpython_file_fileno_obj)},
         {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)},
@@ -199,23 +199,23 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
         {MP_ROM_QSTR(MP_QSTR_flush),     MP_ROM_PTR(&mp_stream_flush_obj)},
         {MP_ROM_QSTR(MP_QSTR_close),     MP_ROM_PTR(&mp_stream_close_obj)},
         {MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj)},
-        {MP_ROM_QSTR(MP_QSTR___exit__),  MP_ROM_PTR(&vfs_openpie_file___exit___obj)},
+        {MP_ROM_QSTR(MP_QSTR___exit__),  MP_ROM_PTR(&vfs_openpython_file___exit___obj)},
 };
 
 STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
 
 #if MICROPY_PY_IO_FILEIO
 STATIC const mp_stream_p_t fileio_stream_p = {
-        .read = vfs_openpie_file_read,
-        .write = vfs_openpie_file_write,
-        .ioctl = vfs_openpie_file_ioctl,
+        .read = vfs_openpython_file_read,
+        .write = vfs_openpython_file_write,
+        .ioctl = vfs_openpython_file_ioctl,
 };
 
-const mp_obj_type_t mp_type_vfs_openpie_fileio = {
+const mp_obj_type_t mp_type_vfs_openpython_fileio = {
         {&mp_type_type},
         .name = MP_QSTR_FileIO,
-        .print = vfs_openpie_file_print,
-        .make_new = vfs_openpie_file_make_new,
+        .print = vfs_openpython_file_print,
+        .make_new = vfs_openpython_file_make_new,
         .getiter = mp_identity_getiter,
         .iternext = mp_stream_unbuffered_iter,
         .protocol = &fileio_stream_p,
@@ -224,21 +224,21 @@ const mp_obj_type_t mp_type_vfs_openpie_fileio = {
 #endif
 
 STATIC const mp_stream_p_t textio_stream_p = {
-        .read = vfs_openpie_file_read,
-        .write = vfs_openpie_file_write,
-        .ioctl = vfs_openpie_file_ioctl,
+        .read = vfs_openpython_file_read,
+        .write = vfs_openpython_file_write,
+        .ioctl = vfs_openpython_file_ioctl,
         .is_text = true,
 };
 
-const mp_obj_type_t mp_type_vfs_openpie_textio = {
+const mp_obj_type_t mp_type_vfs_openpython_textio = {
         {&mp_type_type},
         .name = MP_QSTR_TextIOWrapper,
-        .print = vfs_openpie_file_print,
-        .make_new = vfs_openpie_file_make_new,
+        .print = vfs_openpython_file_print,
+        .make_new = vfs_openpython_file_make_new,
         .getiter = mp_identity_getiter,
         .iternext = mp_stream_unbuffered_iter,
         .protocol = &textio_stream_p,
         .locals_dict = (mp_obj_dict_t *) &rawfile_locals_dict,
 };
 
-#endif // MICROPY_OPENPIE_VFS
+#endif // MICROPY_OPENPYTHON_VFS