initial merge from v1.20.0; just satisifying conflicts

.git-blame-ignore-revs

@@ -1,4 +1,7 @@
-#all: Reformat remaining C code that doesn't have a space after a comma.
+# top: Update Python formatting to black "2023 stable style".
+8b2748269244304854b3462cb8902952b4dcb892
+
+# all: Reformat remaining C code that doesn't have a space after a comma.
 5b700b0af90591d6b1a2c087bb8de6b7f1bfdd2d
 
 # ports: Reformat more C and Python source code.

LICENSE

@@ -1,6 +1,6 @@
-MIT License
+The MIT License (MIT)
 
-Copyright (c) 2013-2022 Damien P. George and others
+Copyright (c) 2013-2023 Damien P. George
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,8 +9,8 @@ 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
+The above copyright notice and this permission notice shall be included in
-copies or substantial portions of the Software.
+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,

devices/ble_hci/common-hal/_bleio/att.c

@@ -44,7 +44,6 @@
 #include "shared-bindings/_bleio/Service.h"
 #include "shared-bindings/_bleio/UUID.h"
 #include "supervisor/shared/tick.h"
-#include "supervisor/shared/translate/translate.h"
 
 STATIC uint16_t max_mtu = BT_ATT_DEFAULT_LE_MTU;  // 23
 STATIC unsigned long timeout = 5000;

docs/library/array.rst

@@ -27,3 +27,55 @@ Classes
 
         Append new elements as contained in `iterable` to the end of
         array, growing it.
+
+    .. method:: __getitem__(index)
+
+        Indexed read of the array, called as ``a[index]`` (where ``a`` is an ``array``).
+        Returns a value if *index* is an ``int`` and an ``array`` if *index* is a slice.
+        Negative indices count from the end and ``IndexError`` is thrown if the index is
+        out of range.
+
+        **Note:** ``__getitem__`` cannot be called directly (``a.__getitem__(index)`` fails) and
+        is not present in ``__dict__``, however ``a[index]`` does work.
+
+    .. method:: __setitem__(index, value)
+
+        Indexed write into the array, called as ``a[index] = value`` (where ``a`` is an ``array``).
+        ``value`` is a single value if *index* is an ``int`` and an ``array`` if *index* is a slice.
+        Negative indices count from the end and ``IndexError`` is thrown if the index is out of range.
+
+        **Note:** ``__setitem__`` cannot be called directly (``a.__setitem__(index, value)`` fails) and
+        is not present in ``__dict__``, however ``a[index] = value`` does work.
+
+    .. method:: __len__()
+
+        Returns the number of items in the array, called as ``len(a)`` (where ``a`` is an ``array``).
+
+        **Note:** ``__len__`` cannot be called directly (``a.__len__()`` fails) and the
+        method is not present in ``__dict__``, however ``len(a)`` does work.
+
+    .. method:: __add__(other)
+
+        Return a new ``array`` that is the concatenation of the array with *other*, called as
+        ``a + other`` (where ``a`` and *other* are both ``arrays``).
+
+        **Note:** ``__add__`` cannot be called directly (``a.__add__(other)`` fails) and
+        is not present in ``__dict__``, however ``a + other`` does work.
+
+    .. method:: __iadd__(other)
+
+        Concatenates the array with *other* in-place, called as ``a += other`` (where ``a`` and *other*
+        are both ``arrays``).  Equivalent to ``extend(other)``.
+
+        **Note:** ``__iadd__`` cannot be called directly (``a.__iadd__(other)`` fails) and
+        is not present in ``__dict__``, however ``a += other`` does work.
+
+    .. method:: __repr__()
+
+        Returns the string representation of the array, called as ``str(a)`` or ``repr(a)```
+        (where ``a`` is an ``array``).  Returns the string ``"array(<type>, [<elements>])"``,
+        where ``<type>`` is the type code letter for the array and ``<elements>`` is a comma
+        seperated list of the elements of the array.
+
+        **Note:** ``__repr__`` cannot be called directly (``a.__repr__()`` fails) and
+        is not present in ``__dict__``, however ``str(a)`` and ``repr(a)`` both work.

docs/reference/glossary.rst

@@ -1,175 +0,0 @@
-Glossary
-========
-
-.. glossary::
-
-    baremetal
-        A system without a (full-fledged) operating system, for example an
-        :term:`MCU`-based system. When running on a baremetal system,
-        MicroPython effectively functions like a small operating system,
-        running user programs and providing a command interpreter
-        (:term:`REPL`).
-
-    buffer protocol
-        Any Python object that can be automatically converted into bytes, such
-        as ``bytes``, ``bytearray``, ``memoryview`` and ``str`` objects, which
-        all implement the "buffer protocol".
-
-    board
-        Typically this refers to a printed circuit board (PCB) containing a
-        :term:`microcontroller <MCU>` and supporting components.
-        MicroPython firmware is typically provided per-board, as the firmware
-        contains both MCU-specific functionality but also board-level
-        functionality such as drivers or pin names.
-
-    bytecode
-        A compact representation of a Python program that generated by
-        compiling the Python source code. This is what the VM actually
-        executes. Bytecode is typically generated automatically at runtime and
-        is invisible to the user. Note that while :term:`CPython` and
-        MicroPython both use bytecode, the format is different. You can also
-        pre-compile source code offline using the :term:`cross-compiler`.
-
-    callee-owned tuple
-        This is a MicroPython-specific construct where, for efficiency
-        reasons, some built-in functions or methods may re-use the same
-        underlying tuple object to return data. This avoids having to allocate
-        a new tuple for every call, and reduces heap fragmentation. Programs
-        should not hold references to callee-owned tuples and instead only
-        extract data from them (or make a copy).
-
-    CircuitPython
-        A variant of MicroPython developed by `Adafruit Industries
-        <https://circuitpython.org>`_.
-
-    CPython
-        CPython is the reference implementation of the Python programming
-        language, and the most well-known one. It is, however, one of many
-        implementations (including Jython, IronPython, PyPy, and MicroPython).
-        While MicroPython's implementation differs substantially from CPython,
-        it aims to maintain as much compatibility as possible.
-
-    cross-compiler
-        Also known as ``mpy-cross``. This tool runs on your PC and converts a
-        :term:`.py file` containing MicroPython code into a :term:`.mpy file`
-        containing MicroPython bytecode. This means it loads faster (the board
-        doesn't have to compile the code), and uses less space on flash (the
-        bytecode is more space efficient).
-
-    driver
-        A MicroPython library that implements support for a particular
-        component, such as a sensor or display.
-
-    FFI
-        Acronym for Foreign Function Interface. A mechanism used by the
-        :term:`MicroPython Unix port` to access operating system functionality.
-        This is not available on :term:`baremetal` ports.
-
-    filesystem
-        Most MicroPython ports and boards provide a filesystem stored in flash
-        that is available to user code via the standard Python file APIs such
-        as ``open()``. Some boards also make this internal filesystem
-        accessible to the host via USB mass-storage.
-
-    frozen module
-        A Python module that has been cross compiled and bundled into the
-        firmware image. This reduces RAM requirements as the code is executed
-        directly from flash.
-
-    Garbage Collector
-        A background process that runs in Python (and MicroPython) to reclaim
-        unused memory in the :term:`heap`.
-
-    GPIO
-        General-purpose input/output. The simplest means to control electrical
-        signals (commonly referred to as "pins") on a microcontroller. GPIO
-        typically allows pins to be either input or output, and to set or get
-        their digital value (logical "0" or "1"). MicroPython abstracts GPIO
-        access using the :class:`machine.Pin` and :class:`machine.Signal`
-        classes.
-
-    GPIO port
-        A group of :term:`GPIO` pins, usually based on hardware properties of
-        these pins (e.g. controllable by the same register).
-
-    heap
-        A region of RAM where MicroPython stores dynamic data. It is managed
-        automatically by the :term:`Garbage Collector`. Different MCUs and
-        boards have vastly different amounts of RAM available for the heap, so
-        this will affect how complex your program can be.
-
-    interned string
-        An optimisation used by MicroPython to improve the efficiency of
-        working with strings. An interned string is referenced by its (unique)
-        identity rather than its address and can therefore be quickly compared
-        just by its identifier. It also means that identical strings can be
-        de-duplicated in memory. String interning is almost always invisible to
-        the user.
-
-    MCU
-        Microcontroller. Microcontrollers usually have much less resources
-        than a desktop, laptop, or phone, but are smaller, cheaper and
-        require much less power. MicroPython is designed to be small and
-        optimized enough to run on an average modern microcontroller.
-
-    MicroPython port
-        MicroPython supports different :term:`boards <board>`, RTOSes, and
-        OSes, and can be relatively easily adapted to new systems. MicroPython
-        with support for a particular system is called a "port" to that
-        system. Different ports may have widely different functionality. This
-        documentation is intended to be a reference of the generic APIs
-        available across different ports ("MicroPython core"). Note that some
-        ports may still omit some APIs described here (e.g. due to resource
-        constraints). Any such differences, and port-specific extensions
-        beyond the MicroPython core functionality, would be described in the
-        separate port-specific documentation.
-
-    MicroPython Unix port
-        The unix port is one of the major :term:`MicroPython ports
-        <MicroPython port>`. It is intended to run on POSIX-compatible
-        operating systems, like Linux, MacOS, FreeBSD, Solaris, etc. It also
-        serves as the basis of Windows port. The Unix port is very useful for
-        quick development and testing of the MicroPython language and
-        machine-independent features. It can also function in a similar way to
-        :term:`CPython`'s ``python`` executable.
-
-    .mpy file
-        The output of the :term:`cross-compiler`. A compiled form of a
-        :term:`.py file` that contains MicroPython bytecode instead of Python
-        source code.
-
-    native
-        Usually refers to "native code", i.e. machine code for the target
-        microcontroller (such as ARM Thumb, Xtensa, x86/x64). The ``@native``
-        decorator can be applied to a MicroPython function to generate native
-        code instead of bytecode for that function, which will likely be
-        faster but use more RAM.
-
-    port
-        Usually short for :term:`MicroPython port`, but could also refer to
-        :term:`GPIO port`.
-
-    .py file
-        A file containing Python source code.
-
-    REPL
-        An acronym for "Read, Eval, Print, Loop". This is the interactive
-        Python prompt, useful for debugging or testing short snippets of code.
-        Most MicroPython boards make a REPL available over a UART, and this is
-        typically accessible on a host PC via USB.
-
-    stream
-        Also known as a "file-like object". A Python object which provides
-        sequential read-write access to the underlying data. A stream object
-        implements a corresponding interface, which consists of methods like
-        ``read()``, ``write()``, ``readinto()``, ``seek()``, ``flush()``,
-        ``close()``, etc. A stream is an important concept in MicroPython;
-        many I/O objects implement the stream interface, and thus can be used
-        consistently and interchangeably in different contexts. For more
-        information on streams in MicroPython, see the `io` module.
-
-    UART
-        Acronym for "Universal Asynchronous Receiver/Transmitter". This is a
-        peripheral that sends data over a pair of pins (TX & RX). Many boards
-        include a way to make at least one of the UARTs available to a host PC
-        as a serial port over USB.

docs/reference/mpyfiles.rst

@@ -1,199 +0,0 @@
-.. _mpy_files:
-
-MicroPython .mpy files
-======================
-
-MicroPython defines the concept of an .mpy file which is a binary container
-file format that holds precompiled code, and which can be imported like a
-normal .py module.  The file ``foo.mpy`` can be imported via ``import foo``,
-as long as ``foo.mpy`` can be found in the usual way by the import machinery.
-Usually, each directory listed in ``sys.path`` is searched in order.  When
-searching a particular directory ``foo.py`` is looked for first and if that
-is not found then ``foo.mpy`` is looked for, then the search continues in the
-next directory if neither is found.  As such, ``foo.py`` will take precedence
-over ``foo.mpy``.
-
-These .mpy files can contain bytecode which is usually generated from Python
-source files (.py files) via the ``mpy-cross`` program.  For some architectures
-an .mpy file can also contain native machine code, which can be generated in
-a variety of ways, most notably from C source code.
-
-Versioning and compatibility of .mpy files
-------------------------------------------
-
-A given .mpy file may or may not be compatible with a given MicroPython system.
-Compatibility is based on the following:
-
-* Version of the .mpy file: the version of the file must match the version
-  supported by the system loading it.
-
-* Sub-version of the .mpy file: if the .mpy file contains native machine code
-  then the sub-version of the file must match the version support by the
-  system loading it.  Otherwise, if there is no native machine code in the .mpy
-  file, then the sub-version is ignored when loading.
-
-* Small integer bits: the .mpy file will require a minimum number of bits in
-  a small integer and the system loading it must support at least this many
-  bits.
-
-* Native architecture: if the .mpy file contains native machine code then
-  it will specify the architecture of that machine code and the system
-  loading it must support execution of that architecture's code.
-
-If a MicroPython system supports importing .mpy files then the
-``sys.implementation._mpy`` field will exist and return an integer which
-encodes the version (lower 8 bits), features and native architecture.
-
-Trying to import an .mpy file that fails one of the first four tests will
-raise ``ValueError('incompatible .mpy file')``.  Trying to import an .mpy
-file that fails the native architecture test (if it contains native machine
-code) will raise ``ValueError('incompatible .mpy arch')``.
-
-If importing an .mpy file fails then try the following:
-
-* Determine the .mpy version and flags supported by your MicroPython system
-  by executing::
-
-    import sys
-    sys_mpy = sys.implementation._mpy
-    arch = [None, 'x86', 'x64',
-        'armv6', 'armv6m', 'armv7m', 'armv7em', 'armv7emsp', 'armv7emdp',
-        'xtensa', 'xtensawin'][sys_mpy >> 10]
-    print('mpy version:', sys_mpy & 0xff)
-    print('mpy flags:', end='')
-    if arch:
-        print(' -march=' + arch, end='')
-    print()
-
-* Check the validity of the .mpy file by inspecting the first two bytes of
-  the file.  The first byte should be an uppercase 'C' and the second byte
-  will be the version number, which should match the system version from above.
-  If it doesn't match then rebuild the .mpy file.
-
-* Check if the system .mpy version matches the version emitted by ``mpy-cross``
-  that was used to build the .mpy file, found by ``mpy-cross --version``.
-  If it doesn't match then recompile ``mpy-cross`` from the Git repository
-  checked out at the tag (or hash) reported by ``mpy-cross --version``.
-
-* Make sure you are using the correct ``mpy-cross`` flags, found by the code
-  above, or by inspecting the ``MPY_CROSS_FLAGS`` Makefile variable for the
-  port that you are using.
-
-The following table shows the correspondence between MicroPython release
-and .mpy version.
-
-=================== ============
-MicroPython release .mpy version
-=================== ============
-v1.19 and up        6
-v1.12 - v1.18       5
-v1.11               4
-v1.9.3 - v1.10      3
-v1.9 - v1.9.2       2
-v1.5.1 - v1.8.7     0
-=================== ============
-
-For completeness, the next table shows the Git commit of the main
-MicroPython repository at which the .mpy version was changed.
-
-=================== ========================================
-.mpy version change Git commit
-=================== ========================================
-5 to 6              f2040bfc7ee033e48acef9f289790f3b4e6b74e5
-4 to 5              5716c5cf65e9b2cb46c2906f40302401bdd27517
-3 to 4              9a5f92ea72754c01cc03e5efcdfe94021120531e
-2 to 3              ff93fd4f50321c6190e1659b19e64fef3045a484
-1 to 2              dd11af209d226b7d18d5148b239662e30ed60bad
-0 to 1              6a11048af1d01c78bdacddadd1b72dc7ba7c6478
-initial version 0   d8c834c95d506db979ec871417de90b7951edc30
-=================== ========================================
-
-Binary encoding of .mpy files
------------------------------
-
-MicroPython .mpy files are a binary container format with code objects (bytecode
-and native machine code) stored internally in a nested hierarchy.  The code for
-the outer module is stored first, and then its children follow.  Each child may
-have further children, for example in the case of a class having methods, or a
-function defining a lambda or comprehension.  To keep files small while still
-providing a large range of possible values it uses the concept of a
-variably-encoded-unsigned-integer (vuint) in many places.  Similar to utf-8
-encoding, this encoding stores 7 bits per byte with the 8th bit (MSB) set
-if one or more bytes follow.  The bits of the unsigned integer are stored
-in the vuint in LSB form.
-
-The top-level of an .mpy file consists of three parts:
-
-* The header.
-
-* The global qstr and constant tables.
-
-* The raw-code for the outer scope of the module.
-  This outer scope is executed when the .mpy file is imported.
-
-You can inspect the contents of a .mpy file by using ``mpy-tool.py``, for
-example (run from the root of the main MicroPython repository)::
-
-    $ ./tools/mpy-tool.py -xd myfile.mpy
-
-The header
-~~~~~~~~~~
-
-The .mpy header is:
-
-======  ================================
-size    field
-======  ================================
-byte    value 0x43 (ASCII 'C')
-byte    .mpy version number
-byte    feature flags
-byte    number of bits in a small int
-======  ================================
-
-The global qstr and constant tables
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-An .mpy file contains a single qstr table, and a single constant object table.
-These are global to the .mpy file, they are referenced by all nested raw-code
-objects.  The qstr table maps internal qstr number (internal to the .mpy file)
-to the resolved qstr number of the runtime that the .mpy file is imported into.
-This links the .mpy file with the rest of the system that it executes within.
-The constant object table is populated with references to all constant objects
-that the .mpy file needs.
-
-======  ================================
-size    field
-======  ================================
-vuint   number of qstrs
-vuint   number of constant objects
-...     qstr data
-...     encoded constant objects
-======  ================================
-
-Raw code elements
-~~~~~~~~~~~~~~~~~
-
-A raw-code element contains code, either bytecode or native machine code.  Its
-contents are:
-
-======  ================================
-size    field
-======  ================================
-vuint   type, size and whether there are sub-raw-code elements
-...     code (bytecode or machine code)
-vuint   number of sub-raw-code elements (only if non-zero)
-...     sub-raw-code elements
-======  ================================
-
-The first vuint in a raw-code element encodes the type of code stored in this
-element (the two least-significant bits), whether this raw-code has any
-children (the third least-significant bit), and the length of the code that
-follows (the amount of RAM to allocate for it).
-
-Following the vuint comes the code itself.  Unless the code type is viper code
-with relocations, this code is constant data and does not need to be modified.
-
-If this raw-code has any children (as indicated by a bit in the first vuint),
-following the code comes a vuint counting the number of sub-raw-code elements.
-
-Finally any sub-raw-code elements are stored, recursively.

docs/static/custom.css

@@ -0,0 +1,5 @@
+/* Workaround to force Sphinx to render tables to 100% and wordwrap */
+/* See https://stackoverflow.com/questions/69359978/grid-table-does-not-word-wrap for more details */
+.wy-table-responsive table td, .wy-table-responsive table th {
+    white-space: inherit;
+}

examples/natmod/ure/ure.c

@@ -32,8 +32,8 @@ void *memmove(void *dest, const void *src, size_t n) {
     return mp_fun_table.memmove_(dest, src, n);
 }
 
-mp_obj_type_t match_type;
+mp_obj_full_type_t match_type;
-mp_obj_type_t re_type;
+mp_obj_full_type_t re_type;
 
 #include "extmod/modure.c"
 
@@ -54,21 +54,21 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
 
     match_type.base.type = (void*)&mp_fun_table.type_type;
     match_type.name = MP_QSTR_match;
-    match_type.print = match_print;
+    MP_OBJ_TYPE_SET_SLOT(&match_type, print, match_print, 0);
     match_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_group), MP_OBJ_FROM_PTR(&match_group_obj) };
     match_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_groups), MP_OBJ_FROM_PTR(&match_groups_obj) };
     match_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_span), MP_OBJ_FROM_PTR(&match_span_obj) };
     match_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_start), MP_OBJ_FROM_PTR(&match_start_obj) };
     match_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_end), MP_OBJ_FROM_PTR(&match_end_obj) };
-    match_type.locals_dict = (void*)&match_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&match_type, locals_dict, (void*)&match_locals_dict, 1);
 
     re_type.base.type = (void*)&mp_fun_table.type_type;
     re_type.name = MP_QSTR_ure;
-    re_type.print = re_print;
+    MP_OBJ_TYPE_SET_SLOT(&re_type, print, re_print, 0);
     re_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_match), MP_OBJ_FROM_PTR(&re_match_obj) };
     re_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_search), MP_OBJ_FROM_PTR(&re_search_obj) };
     re_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_split), MP_OBJ_FROM_PTR(&re_split_obj) };
-    re_type.locals_dict = (void*)&re_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&re_type, locals_dict, (void*)&re_locals_dict, 1);
 
     mp_store_global(MP_QSTR_compile, MP_OBJ_FROM_PTR(&mod_re_compile_obj));
     mp_store_global(MP_QSTR_match, MP_OBJ_FROM_PTR(&re_match_obj));

examples/natmod/uzlib/uzlib.c

@@ -9,7 +9,6 @@ void *memset(void *s, int c, size_t n) {
 #endif
 
 mp_obj_full_type_t decompio_type;
-mp_stream_p_t decompio_stream_p;
 
 #include "extmod/moduzlib.c"
 
@@ -19,18 +18,14 @@ STATIC MP_DEFINE_CONST_DICT(decompio_locals_dict, decompio_locals_dict_table);
 mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
     MP_DYNRUNTIME_INIT_ENTRY
 
-    decompio_stream_p.name = MP_QSTR_protocol_stream;
-    decompio_stream_p.read = decompio_read;
-
     decompio_type.base.type = mp_fun_table.type_type;
-    decompio_type.flags = MP_TYPE_FLAG_EXTENDED;
     decompio_type.name = MP_QSTR_DecompIO;
-    decompio_type.make_new = decompio_make_new;
+    MP_OBJ_TYPE_SET_SLOT(&decompio_type, make_new, &decompio_make_new, 0);
-    decompio_type.ext[0].protocol = &decompio_stream_p;
+    MP_OBJ_TYPE_SET_SLOT(&decompio_type, protocol, &decompio_stream_p, 1);
     decompio_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_read), MP_OBJ_FROM_PTR(&mp_stream_read_obj) };
     decompio_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readinto), MP_OBJ_FROM_PTR(&mp_stream_readinto_obj) };
     decompio_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readline), MP_OBJ_FROM_PTR(&mp_stream_unbuffered_readline_obj) };
-    decompio_type.locals_dict = (void*)&decompio_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&decompio_type, locals_dict, (void*)&decompio_locals_dict, 2);
 
     mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_uzlib));
     mp_store_global(MP_QSTR_decompress, MP_OBJ_FROM_PTR(&mod_uzlib_decompress_obj));

examples/usercmodule/cexample/examplemodule.c

@@ -1,6 +1,9 @@
 // Include MicroPython API.
 #include "py/runtime.h"
 
+// Used to get the time in the Timer class example.
+#include "py/mphal.h"
+
 // This is the function which will be called from Python as cexample.add_ints(a, b).
 STATIC mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
     // Extract the ints from the micropython input objects.
@@ -13,6 +16,58 @@ STATIC mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
 // Define a Python reference to the function above.
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(example_add_ints_obj, example_add_ints);
 
+// This structure represents Timer instance objects.
+typedef struct _example_Timer_obj_t {
+    // All objects start with the base.
+    mp_obj_base_t base;
+    // Everything below can be thought of as instance attributes, but they
+    // cannot be accessed by MicroPython code directly. In this example we
+    // store the time at which the object was created.
+    mp_uint_t start_time;
+} example_Timer_obj_t;
+
+// This is the Timer.time() method. After creating a Timer object, this
+// can be called to get the time elapsed since creating the Timer.
+STATIC mp_obj_t example_Timer_time(mp_obj_t self_in) {
+    // The first argument is self. It is cast to the *example_Timer_obj_t
+    // type so we can read its attributes.
+    example_Timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    // Get the elapsed time and return it as a MicroPython integer.
+    mp_uint_t elapsed = mp_hal_ticks_ms() - self->start_time;
+    return mp_obj_new_int_from_uint(elapsed);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(example_Timer_time_obj, example_Timer_time);
+
+// This represents Timer.__new__ and Timer.__init__, which is called when
+// the user instantiates a Timer object.
+STATIC mp_obj_t example_Timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // Allocates the new object and sets the type.
+    example_Timer_obj_t *self = mp_obj_malloc(example_Timer_obj_t, type);
+
+    // Initializes the time for this Timer instance.
+    self->start_time = mp_hal_ticks_ms();
+
+    // The make_new function always returns self.
+    return MP_OBJ_FROM_PTR(self);
+}
+
+// This collects all methods and other static class attributes of the Timer.
+// The table structure is similar to the module table, as detailed below.
+STATIC const mp_rom_map_elem_t example_Timer_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&example_Timer_time_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(example_Timer_locals_dict, example_Timer_locals_dict_table);
+
+// This defines the type(Timer) object.
+MP_DEFINE_CONST_OBJ_TYPE(
+    example_type_Timer,
+    MP_QSTR_Timer,
+    MP_TYPE_FLAG_NONE,
+    make_new, example_Timer_make_new,
+    locals_dict, &example_Timer_locals_dict
+    );
+
 // Define all properties of the module.
 // Table entries are key/value pairs of the attribute name (a string)
 // and the MicroPython object reference.
@@ -21,6 +76,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(example_add_ints_obj, example_add_ints);
 STATIC const mp_rom_map_elem_t example_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_cexample) },
     { MP_ROM_QSTR(MP_QSTR_add_ints), MP_ROM_PTR(&example_add_ints_obj) },
+    { MP_ROM_QSTR(MP_QSTR_Timer),    MP_ROM_PTR(&example_type_Timer) },
 };
 STATIC MP_DEFINE_CONST_DICT(example_module_globals, example_module_globals_table);
 

extmod/extmod.mk

@@ -1,4 +1,68 @@
-# This makefile fragment provides rules to build 3rd-party components for extmod modules
+# This makefile fragment adds the source code files for the core extmod modules
+# and provides rules to build 3rd-party components for extmod modules.
+
+SRC_EXTMOD_C += \
+	extmod/machine_bitstream.c \
+	extmod/machine_i2c.c \
+	extmod/machine_mem.c \
+	extmod/machine_pinbase.c \
+	extmod/machine_pulse.c \
+	extmod/machine_pwm.c \
+	extmod/machine_signal.c \
+	extmod/machine_spi.c \
+	extmod/machine_timer.c \
+	extmod/modbluetooth.c \
+	extmod/modbtree.c \
+	extmod/modframebuf.c \
+	extmod/modlwip.c \
+	extmod/modnetwork.c \
+	extmod/modonewire.c \
+	extmod/moduasyncio.c \
+	extmod/modubinascii.c \
+	extmod/moducryptolib.c \
+	extmod/moductypes.c \
+	extmod/moduhashlib.c \
+	extmod/moduheapq.c \
+	extmod/modujson.c \
+	extmod/moduos.c \
+	extmod/moduplatform.c\
+	extmod/modurandom.c \
+	extmod/modure.c \
+	extmod/moduselect.c \
+	extmod/modusocket.c \
+	extmod/modussl_axtls.c \
+	extmod/modussl_mbedtls.c \
+	extmod/modutimeq.c \
+	extmod/moduwebsocket.c \
+	extmod/moduzlib.c \
+	extmod/modwebrepl.c \
+	extmod/network_cyw43.c \
+	extmod/network_lwip.c \
+	extmod/network_ninaw10.c \
+	extmod/network_wiznet5k.c \
+	extmod/uos_dupterm.c \
+	extmod/utime_mphal.c \
+	extmod/vfs.c \
+	extmod/vfs_blockdev.c \
+	extmod/vfs_fat.c \
+	extmod/vfs_fat_diskio.c \
+	extmod/vfs_fat_file.c \
+	extmod/vfs_lfs.c \
+	extmod/vfs_posix.c \
+	extmod/vfs_posix_file.c \
+	extmod/vfs_reader.c \
+	extmod/virtpin.c \
+	shared/libc/abort_.c \
+	shared/libc/printf.c \
+
+SRC_THIRDPARTY_C += \
+
+PY_O += $(addprefix $(BUILD)/, $(SRC_EXTMOD_C:.c=.o))
+PY_O += $(addprefix $(BUILD)/, $(SRC_THIRDPARTY_C:.c=.o))
+SRC_QSTR += $(SRC_EXTMOD_C)
+
+CFLAGS += $(CFLAGS_EXTMOD) $(CFLAGS_THIRDPARTY)
+LDFLAGS += $(LDFLAGS_EXTMOD) $(LDFLAGS_THIRDPARTY)
 
 ################################################################################
 # VFS FAT FS
@@ -6,11 +70,11 @@
 OOFATFS_DIR = lib/oofatfs
 
 # this sets the config file for FatFs
-CFLAGS_MOD += -DFFCONF_H=\"$(OOFATFS_DIR)/ffconf.h\"
+CFLAGS_THIRDPARTY += -DFFCONF_H=\"$(OOFATFS_DIR)/ffconf.h\"
 
 ifeq ($(MICROPY_VFS_FAT),1)
-CFLAGS_MOD += -DMICROPY_VFS_FAT=1
+CFLAGS_EXTMOD += -DMICROPY_VFS_FAT=1
-SRC_MOD += $(addprefix $(OOFATFS_DIR)/,\
+SRC_THIRDPARTY_C += $(addprefix $(OOFATFS_DIR)/,\
 	ff.c \
 	ffunicode.c \
 	)
@@ -22,18 +86,18 @@ endif
 LITTLEFS_DIR = lib/littlefs
 
 ifeq ($(MICROPY_VFS_LFS1),1)
-CFLAGS_MOD += -DMICROPY_VFS_LFS1=1
+CFLAGS_EXTMOD += -DMICROPY_VFS_LFS1=1
-CFLAGS_MOD += -DLFS1_NO_MALLOC -DLFS1_NO_DEBUG -DLFS1_NO_WARN -DLFS1_NO_ERROR -DLFS1_NO_ASSERT
+CFLAGS_THIRDPARTY += -DLFS1_NO_MALLOC -DLFS1_NO_DEBUG -DLFS1_NO_WARN -DLFS1_NO_ERROR -DLFS1_NO_ASSERT
-SRC_MOD += $(addprefix $(LITTLEFS_DIR)/,\
+SRC_THIRDPARTY_C += $(addprefix $(LITTLEFS_DIR)/,\
 	lfs1.c \
 	lfs1_util.c \
 	)
 endif
 
 ifeq ($(MICROPY_VFS_LFS2),1)
-CFLAGS_MOD += -DMICROPY_VFS_LFS2=1
+CFLAGS_EXTMOD += -DMICROPY_VFS_LFS2=1
-CFLAGS_MOD += -DLFS2_NO_MALLOC -DLFS2_NO_DEBUG -DLFS2_NO_WARN -DLFS2_NO_ERROR -DLFS2_NO_ASSERT
+CFLAGS_THIRDPARTY += -DLFS2_NO_MALLOC -DLFS2_NO_DEBUG -DLFS2_NO_WARN -DLFS2_NO_ERROR -DLFS2_NO_ASSERT
-SRC_MOD += $(addprefix $(LITTLEFS_DIR)/,\
+SRC_THIRDPARTY_C += $(addprefix $(LITTLEFS_DIR)/,\
 	lfs2.c \
 	lfs2_util.c \
 	)
@@ -45,12 +109,14 @@ endif
 # ussl
 
 ifeq ($(MICROPY_PY_USSL),1)
-CFLAGS_MOD += -DMICROPY_PY_USSL=1
+CFLAGS_EXTMOD += -DMICROPY_PY_USSL=1
 ifeq ($(MICROPY_SSL_AXTLS),1)
 CFLAGS_MOD += -DMICROPY_SSL_AXTLS=1 -I$(TOP)/lib/axtls/ssl -I$(TOP)/lib/axtls/crypto -I$(TOP)/extmod/axtls-include
 AXTLS_DIR = lib/axtls
+GIT_SUBMODULES += $(AXTLS_DIR)
+CFLAGS_EXTMOD += -DMICROPY_SSL_AXTLS=1 -I$(TOP)/lib/axtls/ssl -I$(TOP)/lib/axtls/crypto -I$(TOP)/extmod/axtls-include
 $(BUILD)/$(AXTLS_DIR)/%.o: CFLAGS += -Wno-all -Wno-unused-parameter -Wno-uninitialized -Wno-sign-compare -Wno-old-style-definition -Dmp_stream_errno=errno $(AXTLS_DEFS_EXTRA)
-SRC_MOD += $(addprefix $(AXTLS_DIR)/,\
+SRC_THIRDPARTY_C += $(addprefix $(AXTLS_DIR)/,\
 	ssl/asn1.c \
 	ssl/loader.c \
 	ssl/tls1.c \
@@ -67,8 +133,12 @@ SRC_MOD += $(addprefix $(AXTLS_DIR)/,\
 	)
 else ifeq ($(MICROPY_SSL_MBEDTLS),1)
 MBEDTLS_DIR = lib/mbedtls
-CFLAGS_MOD += -DMICROPY_SSL_MBEDTLS=1 -I$(TOP)/$(MBEDTLS_DIR)/include
+MBEDTLS_CONFIG_FILE ?= \"mbedtls/mbedtls_config.h\"
-SRC_MOD += $(addprefix $(MBEDTLS_DIR)/library/,\
+GIT_SUBMODULES += $(MBEDTLS_DIR)
+CFLAGS_EXTMOD += -DMBEDTLS_CONFIG_FILE=$(MBEDTLS_CONFIG_FILE)
+CFLAGS_EXTMOD += -DMICROPY_SSL_MBEDTLS=1 -I$(TOP)/$(MBEDTLS_DIR)/include
+SRC_THIRDPARTY_C += lib/mbedtls_errors/mp_mbedtls_errors.c
+SRC_THIRDPARTY_C += $(addprefix $(MBEDTLS_DIR)/library/,\
 	aes.c \
 	aesni.c \
 	arc4.c \
@@ -96,7 +166,6 @@ SRC_MOD += $(addprefix $(MBEDTLS_DIR)/library/,\
 	ecp_curves.c \
 	entropy.c \
 	entropy_poll.c \
-	error.c \
 	gcm.c \
 	havege.c \
 	hmac_drbg.c \
@@ -148,13 +217,14 @@ endif
 # lwip
 
 ifeq ($(MICROPY_PY_LWIP),1)
+GIT_SUBMODULES += lib/lwip
 # A port should add an include path where lwipopts.h can be found (eg extmod/lwip-include)
 LWIP_DIR = lib/lwip/src
 INC += -I$(TOP)/$(LWIP_DIR)/include
-CFLAGS_MOD += -DMICROPY_PY_LWIP=1
+CFLAGS_EXTMOD += -DMICROPY_PY_LWIP=1
-$(BUILD)/$(LWIP_DIR)/core/ipv4/dhcp.o: CFLAGS_MOD += -Wno-address
+$(BUILD)/$(LWIP_DIR)/core/ipv4/dhcp.o: CFLAGS += -Wno-address
-SRC_MOD += extmod/modlwip.c shared/netutils/netutils.c
+SRC_THIRDPARTY_C += shared/netutils/netutils.c
-SRC_MOD += $(addprefix $(LWIP_DIR)/,\
+SRC_THIRDPARTY_C += $(addprefix $(LWIP_DIR)/,\
 	apps/mdns/mdns.c \
 	core/def.c \
 	core/dns.c \
@@ -193,8 +263,8 @@ SRC_MOD += $(addprefix $(LWIP_DIR)/,\
 	netif/ethernet.c \
 	)
 ifeq ($(MICROPY_PY_LWIP_SLIP),1)
-CFLAGS_MOD += -DMICROPY_PY_LWIP_SLIP=1
+CFLAGS_EXTMOD += -DMICROPY_PY_LWIP_SLIP=1
-SRC_MOD += $(LWIP_DIR)/netif/slipif.c
+SRC_THIRDPARTY_C += $(LWIP_DIR)/netif/slipif.c
 endif
 endif
 
@@ -205,8 +275,7 @@ ifeq ($(MICROPY_PY_BTREE),1)
 BTREE_DIR = lib/berkeley-db-1.xx
 BTREE_DEFS = -D__DBINTERFACE_PRIVATE=1 -Dmpool_error=printf -Dabort=abort_ "-Dvirt_fd_t=void*" $(BTREE_DEFS_EXTRA)
 INC += -I$(TOP)/$(BTREE_DIR)/PORT/include
-SRC_MOD += extmod/modbtree.c
+SRC_THIRDPARTY_C += $(addprefix $(BTREE_DIR)/,\
-SRC_MOD += $(addprefix $(BTREE_DIR)/,\
 	btree/bt_close.c \
 	btree/bt_conv.c \
 	btree/bt_debug.c \
@@ -222,9 +291,79 @@ SRC_MOD += $(addprefix $(BTREE_DIR)/,\
 	btree/bt_utils.c \
 	mpool/mpool.c \
 	)
-CFLAGS_MOD += -DMICROPY_PY_BTREE=1
+CFLAGS_EXTMOD += -DMICROPY_PY_BTREE=1
 # we need to suppress certain warnings to get berkeley-db to compile cleanly
 # and we have separate BTREE_DEFS so the definitions don't interfere with other source code
 $(BUILD)/$(BTREE_DIR)/%.o: CFLAGS += -Wno-old-style-definition -Wno-sign-compare -Wno-unused-parameter $(BTREE_DEFS)
 $(BUILD)/extmod/modbtree.o: CFLAGS += $(BTREE_DEFS)
 endif
+
+################################################################################
+# networking
+
+ifeq ($(MICROPY_PY_NETWORK_CYW43),1)
+CYW43_DIR = lib/cyw43-driver
+GIT_SUBMODULES += $(CYW43_DIR)
+CFLAGS_EXTMOD += -DMICROPY_PY_NETWORK_CYW43=1
+SRC_THIRDPARTY_C += $(addprefix $(CYW43_DIR)/src/,\
+	cyw43_ctrl.c \
+	cyw43_lwip.c \
+	cyw43_ll.c \
+	cyw43_sdio.c \
+	cyw43_stats.c \
+	)
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+DRIVERS_SRC_C += drivers/cyw43/cywbt.c
+endif
+
+$(BUILD)/$(CYW43_DIR)/src/cyw43_%.o: CFLAGS += -std=c11
+endif # MICROPY_PY_NETWORK_CYW43
+
+ifneq ($(MICROPY_PY_NETWORK_WIZNET5K),)
+ifneq ($(MICROPY_PY_NETWORK_WIZNET5K),0)
+WIZNET5K_DIR=lib/wiznet5k
+GIT_SUBMODULES += lib/wiznet5k
+INC += -I$(TOP)/$(WIZNET5K_DIR) -I$(TOP)/$(WIZNET5K_DIR)/Ethernet
+CFLAGS += -DMICROPY_PY_NETWORK_WIZNET5K=$(MICROPY_PY_NETWORK_WIZNET5K) -D_WIZCHIP_=$(MICROPY_PY_NETWORK_WIZNET5K)
+CFLAGS_THIRDPARTY += -DWIZCHIP_PREFIXED_EXPORTS=1
+ifeq ($(MICROPY_PY_LWIP),1)
+# When using MACRAW mode (with lwIP), maximum buffer space must be used for the raw socket
+CFLAGS_THIRDPARTY += -DWIZCHIP_USE_MAX_BUFFER
+endif
+SRC_THIRDPARTY_C += $(addprefix $(WIZNET5K_DIR)/,\
+	Ethernet/W$(MICROPY_PY_NETWORK_WIZNET5K)/w$(MICROPY_PY_NETWORK_WIZNET5K).c \
+	Ethernet/wizchip_conf.c \
+	Ethernet/socket.c \
+	Internet/DNS/dns.c \
+	Internet/DHCP/dhcp.c \
+	)
+endif
+endif
+
+################################################################################
+# bluetooth
+
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+CFLAGS_EXTMOD += -DMICROPY_PY_BLUETOOTH=1
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+$(error Cannot enable both NimBLE and BTstack at the same time)
+endif
+endif
+
+ifneq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+ifneq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+$(error Must enable one of MICROPY_BLUETOOTH_NIMBLE or MICROPY_BLUETOOTH_BTSTACK)
+endif
+endif
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+include $(TOP)/extmod/nimble/nimble.mk
+endif
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+include $(TOP)/extmod/btstack/btstack.mk
+endif
+
+endif

extmod/moduasyncio.c

@@ -35,8 +35,6 @@
 #include "shared-bindings/supervisor/__init__.h"
 #endif
 
-#include "supervisor/shared/translate/translate.h"
-
 // Used when task cannot be guaranteed to be non-NULL.
 #define TASK_PAIRHEAP(task) ((task) ? &(task)->pairheap : NULL)
 
@@ -65,32 +63,19 @@ STATIC const mp_obj_type_t task_queue_type;
 STATIC const mp_obj_type_t task_type;
 
 STATIC mp_obj_t task_queue_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 task_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf);
 
 /******************************************************************************/
 // Ticks for task ordering in pairing heap
 
-// CIRCUITPY-style ticks
-#define _TICKS_PERIOD (1lu << 29)
-#define _TICKS_MAX (_TICKS_PERIOD - 1)
-#define _TICKS_HALFPERIOD (_TICKS_PERIOD >> 1)
-#if !CIRCUITPY || (defined(__unix__) || defined(__APPLE__))
 STATIC mp_obj_t ticks(void) {
-    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & _TICKS_MAX);
+    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
 }
-#else
-// We don't share the implementation above because our supervisor_ticks_ms
-// starts the epoch about 65 seconds before the first overflow (see
-// shared-bindings/supervisor/__init__.c). We assume/require that
-// supervisor.ticks_ms is picked as the ticks implementation under
-// CircuitPython for the Python-coded bits of asyncio.
-#define ticks() supervisor_ticks_ms()
-#endif
 
 STATIC mp_int_t ticks_diff(mp_obj_t t1_in, mp_obj_t t0_in) {
     mp_uint_t t0 = MP_OBJ_SMALL_INT_VALUE(t0_in);
     mp_uint_t t1 = MP_OBJ_SMALL_INT_VALUE(t1_in);
-    mp_int_t diff = ((t1 - t0 + _TICKS_HALFPERIOD) & _TICKS_MAX) - _TICKS_HALFPERIOD;
+    mp_int_t diff = ((t1 - t0 + MICROPY_PY_UTIME_TICKS_PERIOD / 2) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1))
+        - MICROPY_PY_UTIME_TICKS_PERIOD / 2;
     return diff;
 }
 
@@ -160,20 +145,16 @@ STATIC const mp_rom_map_elem_t task_queue_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_push), MP_ROM_PTR(&task_queue_push_obj) },
     { MP_ROM_QSTR(MP_QSTR_pop), MP_ROM_PTR(&task_queue_pop_obj) },
     { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&task_queue_remove_obj) },
-
-    // CIRCUITPYTHON: remove these after the bundle need not support 8.x
-    { MP_ROM_QSTR(MP_QSTR_push_head), MP_ROM_PTR(&task_queue_push_obj) },
-    { MP_ROM_QSTR(MP_QSTR_push_sorted), MP_ROM_PTR(&task_queue_push_obj) },
-    { MP_ROM_QSTR(MP_QSTR_pop_head), MP_ROM_PTR(&task_queue_pop_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(task_queue_locals_dict, task_queue_locals_dict_table);
 
-STATIC const mp_obj_type_t task_queue_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    task_queue_type,
-    .name = MP_QSTR_TaskQueue,
+    MP_QSTR_TaskQueue,
-    .make_new = task_queue_make_new,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (mp_obj_dict_t *)&task_queue_locals_dict,
+    make_new, task_queue_make_new,
-};
+    locals_dict, &task_queue_locals_dict
+    );
 
 /******************************************************************************/
 // Task class
@@ -247,12 +228,6 @@ STATIC mp_obj_t task_cancel(mp_obj_t self_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_cancel_obj, task_cancel);
 
-// CIRCUITPY provides __await__().
-STATIC mp_obj_t task_await(mp_obj_t self_in) {
-    return task_getiter(self_in, NULL);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_await_obj, task_await);
-
 STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
     if (dest[0] == MP_OBJ_NULL) {
@@ -271,10 +246,6 @@ STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             dest[1] = self_in;
         } else if (attr == MP_QSTR_ph_key) {
             dest[0] = self->ph_key;
-            // CIRCUITPY provides __await__().
-        } else if (attr == MP_QSTR___await__) {
-            dest[0] = MP_OBJ_FROM_PTR(&task_await_obj);
-            dest[1] = self_in;
         }
     } else if (dest[1] != MP_OBJ_NULL) {
         // Store
@@ -307,14 +278,8 @@ STATIC mp_obj_t task_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
 STATIC mp_obj_t task_iternext(mp_obj_t self_in) {
     mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
     if (TASK_IS_DONE(self)) {
-        // CIRCUITPY
+        // Task finished, raise return value to caller so it can continue.
-        if (self->data == mp_const_none) {
+        nlr_raise(self->data);
-            // Task finished but has already been sent to the loop's exception handler.
-            mp_raise_StopIteration(MP_OBJ_NULL);
-        } else {
-            // Task finished, raise return value to caller so it can continue.
-            nlr_raise(self->data);
-        }
     } else {
         // Put calling task on waiting queue.
         mp_obj_t cur_task = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_cur_task));
@@ -326,27 +291,25 @@ STATIC mp_obj_t task_iternext(mp_obj_t self_in) {
     return mp_const_none;
 }
 
-STATIC const mp_obj_type_t task_type = {
+STATIC const mp_getiter_iternext_custom_t task_getiter_iternext = {
-    { &mp_type_type },
+    .getiter = task_getiter,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    .iternext = task_iternext,
-    .name = MP_QSTR_Task,
-    .make_new = task_make_new,
-    .attr = task_attr,
-    MP_TYPE_EXTENDED_FIELDS(
-        .getiter = task_getiter,
-        .iternext = task_iternext,
-        ),
 };
 
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    task_type,
+    MP_QSTR_Task,
+    MP_TYPE_FLAG_ITER_IS_CUSTOM,
+    make_new, task_make_new,
+    attr, task_attr,
+    iter, &task_getiter_iternext
+    );
+
 /******************************************************************************/
 // C-level uasyncio module
 
 STATIC const mp_rom_map_elem_t mp_module_uasyncio_globals_table[] = {
-    #if CIRCUITPY
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__asyncio) },
-    #else
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__uasyncio) },
-    #endif
     { MP_ROM_QSTR(MP_QSTR_TaskQueue), MP_ROM_PTR(&task_queue_type) },
     { MP_ROM_QSTR(MP_QSTR_Task), MP_ROM_PTR(&task_type) },
 };

extmod/modubinascii.c

@@ -30,11 +30,14 @@
 
 #include "py/runtime.h"
 #include "py/binary.h"
-
+#include "py/objstr.h"
-#include "supervisor/shared/translate/translate.h"
 
 #if MICROPY_PY_UBINASCII
 
+#if MICROPY_PY_BUILTINS_BYTES_HEX
+STATIC mp_obj_t bytes_hex_as_bytes(size_t n_args, const mp_obj_t *args) {
+    return mp_obj_bytes_hex(n_args, args, &mp_type_bytes);
+
 static void check_not_unicode(const mp_obj_t arg) {
     #if MICROPY_CPYTHON_COMPAT
     if (mp_obj_is_str(arg)) {
@@ -42,76 +45,13 @@ static void check_not_unicode(const mp_obj_t arg) {
     }
     #endif
 }
-STATIC mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args) {
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bytes_hex_as_bytes_obj, 1, 2, bytes_hex_as_bytes);
-    // First argument is the data to convert.
-    // Second argument is an optional separator to be used between values.
-    const char *sep = NULL;
-    mp_buffer_info_t bufinfo;
-    check_not_unicode(args[0]);
-    mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
 
-    // Code below assumes non-zero buffer length when computing size with
+STATIC mp_obj_t bytes_fromhex_bytes(mp_obj_t data) {
-    // separator, so handle the zero-length case here.
+    return mp_obj_bytes_fromhex(MP_OBJ_FROM_PTR(&mp_type_bytes), data);
-    if (bufinfo.len == 0) {
-        return mp_const_empty_bytes;
-    }
-
-    vstr_t vstr;
-    size_t out_len = bufinfo.len * 2;
-    if (n_args > 1) {
-        // 1-char separator between hex numbers
-        out_len += bufinfo.len - 1;
-        sep = mp_obj_str_get_str(args[1]);
-    }
-    vstr_init_len(&vstr, out_len);
-    byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
-    for (mp_uint_t i = bufinfo.len; i--;) {
-        byte d = (*in >> 4);
-        if (d > 9) {
-            d += 'a' - '9' - 1;
-        }
-        *out++ = d + '0';
-        d = (*in++ & 0xf);
-        if (d > 9) {
-            d += 'a' - '9' - 1;
-        }
-        *out++ = d + '0';
-        if (sep != NULL && i != 0) {
-            *out++ = *sep;
-        }
-    }
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_hexlify_obj, 1, 2, mod_binascii_hexlify);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(bytes_fromhex_obj, bytes_fromhex_bytes);
-
+#endif
-STATIC mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
-
-    if ((bufinfo.len & 1) != 0) {
-        mp_raise_ValueError(MP_ERROR_TEXT("odd-length string"));
-    }
-    vstr_t vstr;
-    vstr_init_len(&vstr, bufinfo.len / 2);
-    byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
-    byte hex_byte = 0;
-    for (mp_uint_t i = bufinfo.len; i--;) {
-        byte hex_ch = *in++;
-        if (unichar_isxdigit(hex_ch)) {
-            hex_byte += unichar_xdigit_value(hex_ch);
-        } else {
-            mp_raise_ValueError(MP_ERROR_TEXT("non-hex digit found"));
-        }
-        if (i & 1) {
-            hex_byte <<= 4;
-        } else {
-            *out++ = hex_byte;
-            hex_byte = 0;
-        }
-    }
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_unhexlify_obj, mod_binascii_unhexlify);
 
 // If ch is a character in the base64 alphabet, and is not a pad character, then
 // the corresponding integer between 0 and 63, inclusively, is returned.
@@ -171,7 +111,7 @@ STATIC mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
         mp_raise_ValueError(MP_ERROR_TEXT("incorrect padding"));
     }
 
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_a2b_base64_obj, mod_binascii_a2b_base64);
 
@@ -184,6 +124,7 @@ STATIC mp_obj_t mod_binascii_b2a_base64(size_t n_args, const mp_obj_t *pos_args,
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     uint8_t newline = args[ARG_newline].u_bool;
+    // CIRCUITPY
     check_not_unicode(pos_args[0]);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(pos_args[0], &bufinfo, MP_BUFFER_READ);
@@ -234,7 +175,7 @@ STATIC mp_obj_t mod_binascii_b2a_base64(size_t n_args, const mp_obj_t *pos_args,
     if (newline) {
         *out = '\n';
     }
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_binascii_b2a_base64_obj, 1, mod_binascii_b2a_base64);
 
@@ -305,22 +246,25 @@ static uint32_t from_uzlib_crc32(const void *data, unsigned int length, uint32_t
 
 STATIC mp_obj_t mod_binascii_crc32(size_t n_args, const mp_obj_t *args) {
     mp_buffer_info_t bufinfo;
-    check_not_unicode(args[0]);
     mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
     uint32_t crc = (n_args > 1) ? mp_obj_get_int_truncated(args[1]) : 0;
-    crc = from_uzlib_crc32(bufinfo.buf, bufinfo.len, crc ^ 0xffffffff);
+    crc = uzlib_crc32(bufinfo.buf, bufinfo.len, crc ^ 0xffffffff);
     return mp_obj_new_int_from_uint(crc ^ 0xffffffff);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_crc32_obj, 1, 2, mod_binascii_crc32);
-
+#endif
 
 STATIC const mp_rom_map_elem_t mp_module_binascii_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_binascii) },
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ubinascii) },
-    { MP_ROM_QSTR(MP_QSTR_hexlify), MP_ROM_PTR(&mod_binascii_hexlify_obj) },
+    #if MICROPY_PY_BUILTINS_BYTES_HEX
-    { MP_ROM_QSTR(MP_QSTR_unhexlify), MP_ROM_PTR(&mod_binascii_unhexlify_obj) },
+    { MP_ROM_QSTR(MP_QSTR_hexlify), MP_ROM_PTR(&bytes_hex_as_bytes_obj) },
+    { MP_ROM_QSTR(MP_QSTR_unhexlify), MP_ROM_PTR(&bytes_fromhex_obj) },
+    #endif
     { MP_ROM_QSTR(MP_QSTR_a2b_base64), MP_ROM_PTR(&mod_binascii_a2b_base64_obj) },
     { MP_ROM_QSTR(MP_QSTR_b2a_base64), MP_ROM_PTR(&mod_binascii_b2a_base64_obj) },
+    #if MICROPY_PY_UBINASCII_CRC32
     { MP_ROM_QSTR(MP_QSTR_crc32), MP_ROM_PTR(&mod_binascii_crc32_obj) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_binascii_globals, mp_module_binascii_globals_table);

extmod/moductypes.c

@@ -32,8 +32,6 @@
 #include "py/objtuple.h"
 #include "py/binary.h"
 
-#include "supervisor/shared/translate/translate.h"
-
 #if MICROPY_PY_UCTYPES
 
 // The uctypes module allows defining the layout of a raw data structure (using
@@ -192,7 +190,7 @@ STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, int layout_type, mp_uint_
             // but scalar structure field is lowered into native Python int, so all
             // type info is lost. So, we cannot say if it's scalar type description,
             // or such lowered scalar.
-            mp_raise_TypeError(MP_ERROR_TEXT("cannot unambiguously get sizeof scalar"));
+            mp_raise_TypeError(MP_ERROR_TEXT("can't unambiguously get sizeof scalar"));
         }
         syntax_error();
     }
@@ -504,8 +502,8 @@ STATIC void uctypes_struct_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t base_in, mp_obj_t index_in, mp_obj_t value) {
+STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
-    mp_obj_uctypes_struct_t *self = mp_obj_cast_to_native_base(base_in, &uctypes_struct_type);
+    mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (value == MP_OBJ_NULL) {
         // delete
@@ -561,7 +559,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t base_in, mp_obj_t index_in, mp_ob
             }
 
         } else if (agg_type == PTR) {
-            byte *p = *(void **)(void *)self->addr;
+            byte *p = *(void **)self->addr;
             if (mp_obj_is_small_int(t->items[1])) {
                 uint val_type = GET_TYPE(MP_OBJ_SMALL_INT_VALUE(t->items[1]), VAL_TYPE_BITS);
                 return get_aligned(val_type, p, index);
@@ -590,7 +588,7 @@ STATIC mp_obj_t uctypes_struct_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
                 mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
                 uint agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
                 if (agg_type == PTR) {
-                    byte *p = *(void **)(void *)self->addr;
+                    byte *p = *(void **)self->addr;
                     return mp_obj_new_int((mp_int_t)(uintptr_t)p);
                 }
             }
@@ -636,19 +634,17 @@ STATIC mp_obj_t uctypes_struct_bytes_at(mp_obj_t ptr, mp_obj_t size) {
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytes_at_obj, uctypes_struct_bytes_at);
 
-STATIC const mp_obj_type_t uctypes_struct_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    uctypes_struct_type,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_struct,
-    .name = MP_QSTR_struct,
+    MP_TYPE_FLAG_NONE,
-    .print = uctypes_struct_print,
+    make_new, uctypes_struct_make_new,
-    .make_new = uctypes_struct_make_new,
+    print, uctypes_struct_print,
-    .attr = uctypes_struct_attr,
+    attr, uctypes_struct_attr,
-    MP_TYPE_EXTENDED_FIELDS(
+    subscr, uctypes_struct_subscr,
-        .subscr = uctypes_struct_subscr,
+    unary_op, uctypes_struct_unary_op,
-        .unary_op = uctypes_struct_unary_op,
+    buffer, uctypes_get_buffer
-        .buffer_p = { .get_buffer = uctypes_get_buffer },
+    );
-        ),
-};
 
 STATIC const mp_rom_map_elem_t mp_module_uctypes_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uctypes) },

extmod/moduhashlib.c

@@ -29,8 +29,6 @@
 
 #include "py/runtime.h"
 
-#include "supervisor/shared/translate/translate.h"
-
 #if MICROPY_PY_UHASHLIB
 
 #if MICROPY_SSL_MBEDTLS
@@ -111,7 +109,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     vstr_t vstr;
     vstr_init_len(&vstr, 32);
     mbedtls_sha256_finish_ret((mbedtls_sha256_context *)&self->state, (unsigned char *)vstr.buf);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 
 #else
@@ -154,7 +152,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     vstr_t vstr;
     vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
     sha256_final((CRYAL_SHA256_CTX *)self->state, (byte *)vstr.buf);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 #endif
 
@@ -168,12 +166,13 @@ STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(uhashlib_sha256_locals_dict, uhashlib_sha256_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_sha256_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    uhashlib_sha256_type,
-    .name = MP_QSTR_sha256,
+    MP_QSTR_sha256,
-    .make_new = uhashlib_sha256_make_new,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (void *)&uhashlib_sha256_locals_dict,
+    make_new, uhashlib_sha256_make_new,
-};
+    locals_dict, &uhashlib_sha256_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_UHASHLIB_SHA1
@@ -207,7 +206,7 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     vstr_t vstr;
     vstr_init_len(&vstr, SHA1_SIZE);
     SHA1_Final((byte *)vstr.buf, (SHA1_CTX *)self->state);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 #endif
 
@@ -248,7 +247,7 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     vstr_init_len(&vstr, 20);
     mbedtls_sha1_finish_ret((mbedtls_sha1_context *)self->state, (byte *)vstr.buf);
     mbedtls_sha1_free((mbedtls_sha1_context *)self->state);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 #endif
 
@@ -261,12 +260,13 @@ STATIC const mp_rom_map_elem_t uhashlib_sha1_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(uhashlib_sha1_locals_dict, uhashlib_sha1_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_sha1_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    uhashlib_sha1_type,
-    .name = MP_QSTR_sha1,
+    MP_QSTR_sha1,
-    .make_new = uhashlib_sha1_make_new,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (void *)&uhashlib_sha1_locals_dict,
+    make_new, uhashlib_sha1_make_new,
-};
+    locals_dict, &uhashlib_sha1_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_UHASHLIB_MD5
@@ -300,7 +300,7 @@ STATIC mp_obj_t uhashlib_md5_digest(mp_obj_t self_in) {
     vstr_t vstr;
     vstr_init_len(&vstr, MD5_SIZE);
     MD5_Final((byte *)vstr.buf, (MD5_CTX *)self->state);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 #endif // MICROPY_SSL_AXTLS
 
@@ -341,7 +341,7 @@ STATIC mp_obj_t uhashlib_md5_digest(mp_obj_t self_in) {
     vstr_init_len(&vstr, 16);
     mbedtls_md5_finish_ret((mbedtls_md5_context *)self->state, (byte *)vstr.buf);
     mbedtls_md5_free((mbedtls_md5_context *)self->state);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+    return mp_obj_new_bytes_from_vstr(&vstr);
 }
 #endif // MICROPY_SSL_MBEDTLS
 
@@ -354,12 +354,13 @@ STATIC const mp_rom_map_elem_t uhashlib_md5_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(uhashlib_md5_locals_dict, uhashlib_md5_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_md5_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    uhashlib_md5_type,
-    .name = MP_QSTR_md5,
+    MP_QSTR_md5,
-    .make_new = uhashlib_md5_make_new,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (void *)&uhashlib_md5_locals_dict,
+    make_new, uhashlib_md5_make_new,
-};
+    locals_dict, &uhashlib_md5_locals_dict
+    );
 #endif // MICROPY_PY_UHASHLIB_MD5
 
 STATIC const mp_rom_map_elem_t mp_module_uhashlib_globals_table[] = {

extmod/moduheapq.c

@@ -27,8 +27,6 @@
 #include "py/objlist.h"
 #include "py/runtime.h"
 
-#include "supervisor/shared/translate/translate.h"
-
 #if MICROPY_PY_UHEAPQ
 
 // the algorithm here is modelled on CPython's heapq.py

extmod/modujson.c

@@ -34,8 +34,6 @@
 #include "py/runtime.h"
 #include "py/stream.h"
 
-#include "supervisor/shared/translate/translate.h"
-
 #if MICROPY_PY_UJSON
 
 #if MICROPY_PY_UJSON_SEPARATORS
@@ -71,7 +69,7 @@ STATIC mp_obj_t mod_ujson_dump_helper(size_t n_args, const mp_obj_t *pos_args, m
         vstr_t vstr;
         vstr_init_print(&vstr, 8, &print_ext.base);
         mp_obj_print_helper(&print_ext.base, pos_args[0], PRINT_JSON);
-        return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
+        return mp_obj_new_str_from_utf8_vstr(&vstr);
     } else {
         // dump(obj, stream)
         print_ext.base.data = MP_OBJ_TO_PTR(pos_args[1]);
@@ -107,7 +105,7 @@ STATIC mp_obj_t mod_ujson_dumps(mp_obj_t obj) {
     mp_print_t print;
     vstr_init_print(&vstr, 8, &print);
     mp_obj_print_helper(&print, obj, PRINT_JSON);
-    return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
+    return mp_obj_new_str_from_utf8_vstr(&vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_dumps_obj, mod_ujson_dumps);
 #endif
@@ -332,7 +330,7 @@ STATIC mp_obj_t _mod_ujson_load(mp_obj_t stream_obj, bool return_first_json) {
                     S_NEXT(s);
                 }
                 if (flt) {
-                    next = mp_parse_num_decimal(vstr.buf, vstr.len, false, false, NULL);
+                    next = mp_parse_num_float(vstr.buf, vstr.len, false, NULL);
                 } else {
                     next = mp_parse_num_integer(vstr.buf, vstr.len, 10, NULL);
                 }

extmod/moduplatform.h

@@ -37,11 +37,11 @@
 
 #if defined(__ARM_ARCH)
 #define MICROPY_PLATFORM_ARCH   "arm"
-#elif defined(__x86_64__) || defined(_WIN64)
+#elif defined(__x86_64__) || defined(_M_X64)
 #define MICROPY_PLATFORM_ARCH   "x86_64"
 #elif defined(__i386__) || defined(_M_IX86)
 #define MICROPY_PLATFORM_ARCH   "x86"
-#elif defined(__xtensa__) || defined(_M_IX86)
+#elif defined(__xtensa__)
 #define MICROPY_PLATFORM_ARCH   "xtensa"
 #else
 #define MICROPY_PLATFORM_ARCH   ""

extmod/modure.c

@@ -33,16 +33,17 @@
 #include "py/objstr.h"
 #include "py/stackctrl.h"
 
+#if MICROPY_PY_BUILTINS_STR_UNICODE
+#include "py/unicode.h"
+#endif
+
 #if MICROPY_PY_URE
 
 #define re1_5_stack_chk() MP_STACK_CHECK()
 
 #include "lib/re1.5/re1.5.h"
 
-// CIRCUITPY
-#if MICROPY_PY_URE_DEBUG
 #define FLAG_DEBUG 0x1000
-#endif
 
 typedef struct _mp_obj_re_t {
     mp_obj_base_t base;
@@ -124,6 +125,18 @@ STATIC void match_span_helper(size_t n_args, const mp_obj_t *args, mp_obj_t span
         e = self->caps[no * 2 + 1] - begin;
     }
 
+    #if MICROPY_PY_BUILTINS_STR_UNICODE
+    if (mp_obj_get_type(self->str) == &mp_type_str) {
+        const byte *begin = (const byte *)mp_obj_str_get_str(self->str);
+        if (s != -1) {
+            s = utf8_ptr_to_index(begin, begin + s);
+        }
+        if (e != -1) {
+            e = utf8_ptr_to_index(begin, begin + e);
+        }
+    }
+    #endif
+
     span[0] = mp_obj_new_int(s);
     span[1] = mp_obj_new_int(e);
 }
@@ -166,12 +179,13 @@ STATIC const mp_rom_map_elem_t match_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(match_locals_dict, match_locals_dict_table);
 
-STATIC const mp_obj_type_t match_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    match_type,
-    .name = MP_QSTR_match,
+    MP_QSTR_match,
-    .print = match_print,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (void *)&match_locals_dict,
+    print, match_print,
-};
+    locals_dict, &match_locals_dict
+    );
 #endif
 
 STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -183,7 +197,7 @@ STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
 STATIC mp_obj_t ure_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     (void)n_args;
     mp_obj_re_t *self;
-    if (mp_obj_is_type(args[0], &re_type)) {
+    if (mp_obj_is_type(args[0], (mp_obj_type_t *)&re_type)) {
         self = MP_OBJ_TO_PTR(args[0]);
     } else {
         self = MP_OBJ_TO_PTR(mod_re_compile(1, args));
@@ -232,7 +246,7 @@ STATIC mp_obj_t ure_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
         return mp_const_none;
     }
 
-    match->base.type = &match_type;
+    match->base.type = (mp_obj_type_t *)&match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = args[1];
     return MP_OBJ_FROM_PTR(match);
@@ -277,7 +291,7 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
         mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte *)subj.begin, caps[0] - subj.begin);
         mp_obj_list_append(retval, s);
         if (self->re.sub > 0) {
-            mp_raise_NotImplementedError(MP_ERROR_TEXT("Splitting with sub-captures"));
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("splitting with sub-captures"));
         }
         subj.begin = caps[1];
         if (maxsplit > 0 && --maxsplit == 0) {
@@ -297,7 +311,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(re_split_obj, 2, 3, re_split);
 
 STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
     mp_obj_re_t *self;
-    if (mp_obj_is_type(args[0], &re_type)) {
+    if (mp_obj_is_type(args[0], (mp_obj_type_t *)&re_type)) {
         self = MP_OBJ_TO_PTR(args[0]);
     } else {
         self = MP_OBJ_TO_PTR(mod_re_compile(1, args));
@@ -320,7 +334,7 @@ STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
     vstr_t vstr_return;
     vstr_return.buf = NULL; // We'll init the vstr after the first match
     mp_obj_match_t *match = mp_local_alloc(sizeof(mp_obj_match_t) + caps_num * sizeof(char *));
-    match->base.type = &match_type;
+    match->base.type = (mp_obj_type_t *)&match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = where;
 
@@ -405,7 +419,11 @@ STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
     // Add post-match string
     vstr_add_strn(&vstr_return, subj.begin, subj.end - subj.begin);
 
-    return mp_obj_new_str_from_vstr(mp_obj_get_type(where), &vstr_return);
+    if (mp_obj_get_type(where) == &mp_type_str) {
+        return mp_obj_new_str_from_utf8_vstr(&vstr_return);
+    } else {
+        return mp_obj_new_bytes_from_vstr(&vstr_return);
+    }
 }
 
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(re_sub_obj, 3, 5, re_sub_helper);
@@ -424,16 +442,13 @@ STATIC const mp_rom_map_elem_t re_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(re_locals_dict, re_locals_dict_table);
 
-STATIC const mp_obj_type_t re_type = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    re_type,
-    #if CIRCUITPY
+    MP_QSTR_ure,
-    .name = MP_QSTR_re,
+    MP_TYPE_FLAG_NONE,
-    #else
+    print, re_print,
-    .name = MP_QSTR_ure,
+    locals_dict, &re_locals_dict
-    #endif
+    );
-    .print = re_print,
-    .locals_dict = (void *)&re_locals_dict,
-};
 #endif
 
 STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
@@ -443,14 +458,12 @@ STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
     if (size == -1) {
         goto error;
     }
-    mp_obj_re_t *o = mp_obj_malloc_var(mp_obj_re_t, char, size, &re_type);
+    mp_obj_re_t *o = mp_obj_malloc_var(mp_obj_re_t, char, size, (mp_obj_type_t *)&re_type);
     #if MICROPY_PY_URE_DEBUG
     int flags = 0;
     if (n_args > 1) {
         flags = mp_obj_get_int(args[1]);
     }
-    #else
-    (void)n_args;
     #endif
     int error = re1_5_compilecode(&o->re, re_str);
     if (error != 0) {

extmod/moduselect.c

@@ -30,7 +30,6 @@
 
 #include <stdio.h>
 
-#include "py/stream.h"
 #include "py/runtime.h"
 #include "py/obj.h"
 #include "py/objlist.h"
@@ -172,8 +171,7 @@ STATIC mp_obj_t select_select(size_t n_args, const mp_obj_t *args) {
             mp_map_deinit(&poll_map);
             return mp_obj_new_tuple(3, list_array);
         }
-        // CIRCUITPY
+        MICROPY_EVENT_POLL_HOOK
-        RUN_BACKGROUND_TASKS;
     }
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_select_select_obj, 3, 4, select_select);
@@ -252,11 +250,7 @@ STATIC mp_uint_t poll_poll_internal(uint n_args, const mp_obj_t *args) {
         if (n_ready > 0 || (timeout != (mp_uint_t)-1 && mp_hal_ticks_ms() - start_tick >= timeout)) {
             break;
         }
-        // CIRCUITPY
+        MICROPY_EVENT_POLL_HOOK
-        RUN_BACKGROUND_TASKS;
-        if (mp_hal_is_interrupted()) {
-            return 0;
-        }
     }
 
     return n_ready;
@@ -343,16 +337,13 @@ STATIC const mp_rom_map_elem_t poll_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(poll_locals_dict, poll_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_poll = {
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    mp_type_poll,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_poll,
-    .name = MP_QSTR_poll,
+    MP_TYPE_FLAG_ITER_IS_ITERNEXT,
-    .locals_dict = (void *)&poll_locals_dict,
+    iter, poll_iternext,
-    MP_TYPE_EXTENDED_FIELDS(
+    locals_dict, &poll_locals_dict
-        .getiter = mp_identity_getiter,
+    );
-        .iternext = poll_iternext,
-        ),
-};
 
 // poll()
 STATIC mp_obj_t select_poll(void) {

extmod/modutimeq.c

@@ -1,239 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2014 Damien P. George
- * Copyright (c) 2016-2017 Paul Sokolovsky
- *
- * 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.
- */
-
-#include <string.h>
-
-#include "py/objlist.h"
-#include "py/runtime.h"
-#include "py/smallint.h"
-
-#include "supervisor/shared/translate/translate.h"
-
-#if MICROPY_PY_UTIMEQ
-
-#define MODULO MICROPY_PY_UTIME_TICKS_PERIOD
-
-#define DEBUG 0
-
-// the algorithm here is modelled on CPython's heapq.py
-
-struct qentry {
-    mp_uint_t time;
-    mp_uint_t id;
-    mp_obj_t callback;
-    mp_obj_t args;
-};
-
-typedef struct _mp_obj_utimeq_t {
-    mp_obj_base_t base;
-    mp_uint_t alloc;
-    mp_uint_t len;
-    struct qentry items[];
-} mp_obj_utimeq_t;
-
-STATIC mp_uint_t utimeq_id;
-
-STATIC mp_obj_utimeq_t *utimeq_get_heap(mp_obj_t heap_in) {
-    return MP_OBJ_TO_PTR(heap_in);
-}
-
-STATIC bool time_less_than(struct qentry *item, struct qentry *parent) {
-    mp_uint_t item_tm = item->time;
-    mp_uint_t parent_tm = parent->time;
-    mp_uint_t res = parent_tm - item_tm;
-    if (res == 0) {
-        // TODO: This actually should use the same "ring" logic
-        // as for time, to avoid artifacts when id's overflow.
-        return item->id < parent->id;
-    }
-    if ((mp_int_t)res < 0) {
-        res += MODULO;
-    }
-    return res && res < (MODULO / 2);
-}
-
-STATIC mp_obj_t utimeq_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, 1, 1, false);
-    mp_uint_t alloc = mp_obj_get_int(args[0]);
-    mp_obj_utimeq_t *o = mp_obj_malloc_var(mp_obj_utimeq_t, struct qentry, alloc, type);
-    memset(o->items, 0, sizeof(*o->items) * alloc);
-    o->alloc = alloc;
-    o->len = 0;
-    return MP_OBJ_FROM_PTR(o);
-}
-
-STATIC void utimeq_heap_siftdown(mp_obj_utimeq_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
-    struct qentry item = heap->items[pos];
-    while (pos > start_pos) {
-        mp_uint_t parent_pos = (pos - 1) >> 1;
-        struct qentry *parent = &heap->items[parent_pos];
-        bool lessthan = time_less_than(&item, parent);
-        if (lessthan) {
-            heap->items[pos] = *parent;
-            pos = parent_pos;
-        } else {
-            break;
-        }
-    }
-    heap->items[pos] = item;
-}
-
-STATIC void utimeq_heap_siftup(mp_obj_utimeq_t *heap, mp_uint_t pos) {
-    mp_uint_t start_pos = pos;
-    mp_uint_t end_pos = heap->len;
-    struct qentry item = heap->items[pos];
-    for (mp_uint_t child_pos = 2 * pos + 1; child_pos < end_pos; child_pos = 2 * pos + 1) {
-        // choose right child if it's <= left child
-        if (child_pos + 1 < end_pos) {
-            bool lessthan = time_less_than(&heap->items[child_pos], &heap->items[child_pos + 1]);
-            if (!lessthan) {
-                child_pos += 1;
-            }
-        }
-        // bubble up the smaller child
-        heap->items[pos] = heap->items[child_pos];
-        pos = child_pos;
-    }
-    heap->items[pos] = item;
-    utimeq_heap_siftdown(heap, start_pos, pos);
-}
-
-STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
-    (void)n_args;
-    mp_obj_t heap_in = args[0];
-    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
-    if (heap->len == heap->alloc) {
-        mp_raise_IndexError(MP_ERROR_TEXT("queue overflow"));
-    }
-    mp_uint_t l = heap->len;
-    heap->items[l].time = MP_OBJ_SMALL_INT_VALUE(args[1]);
-    heap->items[l].id = utimeq_id++;
-    heap->items[l].callback = args[2];
-    heap->items[l].args = args[3];
-    utimeq_heap_siftdown(heap, 0, heap->len);
-    heap->len++;
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_utimeq_heappush_obj, 4, 4, mod_utimeq_heappush);
-
-STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
-    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
-    if (heap->len == 0) {
-        mp_raise_IndexError(MP_ERROR_TEXT("empty heap"));
-    }
-    mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref);
-    if (!mp_obj_is_type(list_ref, &mp_type_list) || ret->len < 3) {
-        mp_raise_TypeError(NULL);
-    }
-
-    struct qentry *item = &heap->items[0];
-    ret->items[0] = MP_OBJ_NEW_SMALL_INT(item->time);
-    ret->items[1] = item->callback;
-    ret->items[2] = item->args;
-    heap->len -= 1;
-    heap->items[0] = heap->items[heap->len];
-    heap->items[heap->len].callback = MP_OBJ_NULL; // so we don't retain a pointer
-    heap->items[heap->len].args = MP_OBJ_NULL;
-    if (heap->len) {
-        utimeq_heap_siftup(heap, 0);
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_utimeq_heappop_obj, mod_utimeq_heappop);
-
-STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
-    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
-    if (heap->len == 0) {
-        mp_raise_IndexError(MP_ERROR_TEXT("empty heap"));
-    }
-
-    struct qentry *item = &heap->items[0];
-    return MP_OBJ_NEW_SMALL_INT(item->time);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_utimeq_peektime_obj, mod_utimeq_peektime);
-
-#if DEBUG
-STATIC mp_obj_t mod_utimeq_dump(mp_obj_t heap_in) {
-    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
-    for (int i = 0; i < heap->len; i++) {
-        printf(UINT_FMT "\t%p\t%p\n", heap->items[i].time,
-            MP_OBJ_TO_PTR(heap->items[i].callback), MP_OBJ_TO_PTR(heap->items[i].args));
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_utimeq_dump_obj, mod_utimeq_dump);
-#endif
-
-STATIC mp_obj_t utimeq_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
-    mp_obj_utimeq_t *self = MP_OBJ_TO_PTR(self_in);
-    switch (op) {
-        case MP_UNARY_OP_BOOL:
-            return mp_obj_new_bool(self->len != 0);
-        case MP_UNARY_OP_LEN:
-            return MP_OBJ_NEW_SMALL_INT(self->len);
-        default:
-            return MP_OBJ_NULL;      // op not supported
-    }
-}
-
-STATIC const mp_rom_map_elem_t utimeq_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_push), MP_ROM_PTR(&mod_utimeq_heappush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_pop), MP_ROM_PTR(&mod_utimeq_heappop_obj) },
-    { MP_ROM_QSTR(MP_QSTR_peektime), MP_ROM_PTR(&mod_utimeq_peektime_obj) },
-    #if DEBUG
-    { MP_ROM_QSTR(MP_QSTR_dump), MP_ROM_PTR(&mod_utimeq_dump_obj) },
-    #endif
-};
-
-STATIC MP_DEFINE_CONST_DICT(utimeq_locals_dict, utimeq_locals_dict_table);
-
-STATIC const mp_obj_type_t utimeq_type = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EXTENDED,
-    .name = MP_QSTR_utimeq,
-    .make_new = utimeq_make_new,
-    .locals_dict = (void *)&utimeq_locals_dict,
-    MP_TYPE_EXTENDED_FIELDS(
-        .unary_op = utimeq_unary_op,
-        ),
-};
-
-STATIC const mp_rom_map_elem_t mp_module_utimeq_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utimeq) },
-    { MP_ROM_QSTR(MP_QSTR_utimeq), MP_ROM_PTR(&utimeq_type) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(mp_module_utimeq_globals, mp_module_utimeq_globals_table);
-
-const mp_obj_module_t mp_module_utimeq = {
-    .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t *)&mp_module_utimeq_globals,
-};
-
-MP_REGISTER_MODULE(MP_QSTR_utimeq, mp_module_utimeq);
-
-#endif // MICROPY_PY_UTIMEQ

extmod/moduzlib.c

@@ -31,8 +31,6 @@
 #include "py/stream.h"
 #include "py/mperrno.h"
 
-#include "supervisor/shared/translate/translate.h"
-
 #if MICROPY_PY_UZLIB
 
 #define UZLIB_CONF_PARANOID_CHECKS (1)
@@ -138,22 +136,19 @@ STATIC const mp_rom_map_elem_t decompio_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(decompio_locals_dict, decompio_locals_dict_table);
 #endif
 
-#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_stream_p_t decompio_stream_p = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
     .read = decompio_read,
 };
 
-STATIC const mp_obj_type_t decompio_type = {
+#if !MICROPY_ENABLE_DYNRUNTIME
-    { &mp_type_type },
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    decompio_type,
-    .name = MP_QSTR_DecompIO,
+    MP_QSTR_DecompIO,
-    .make_new = decompio_make_new,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (void *)&decompio_locals_dict,
+    make_new, decompio_make_new,
-    MP_TYPE_EXTENDED_FIELDS(
+    protocol, &decompio_stream_p,
-        .protocol = &decompio_stream_p,
+    locals_dict, &decompio_locals_dict
-        ),
+    );
-};
 #endif
 
 STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {

extmod/utime_mphal.c

@@ -95,6 +95,19 @@ STATIC mp_obj_t time_ticks_add(mp_obj_t ticks_in, mp_obj_t delta_in) {
     // we assume that first argument come from ticks_xx so is small int
     mp_uint_t ticks = MP_OBJ_SMALL_INT_VALUE(ticks_in);
     mp_uint_t delta = mp_obj_get_int(delta_in);
+
+    // Check that delta does not overflow the range that ticks_diff can handle.
+    // This ensures the following:
+    //  - ticks_diff(ticks_add(T, delta), T) == delta
+    //  - ticks_diff(T, ticks_add(T, delta)) == -delta
+    // The latter requires excluding delta=-TICKS_PERIOD/2.
+    //
+    // This unsigned comparison is equivalent to a signed comparison of:
+    //   delta <= -TICKS_PERIOD/2 || delta >= TICKS_PERIOD/2
+    if (delta + MICROPY_PY_UTIME_TICKS_PERIOD / 2 - 1 >= MICROPY_PY_UTIME_TICKS_PERIOD - 1) {
+        mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("ticks interval overflow"));
+    }
+
     return MP_OBJ_NEW_SMALL_INT((ticks + delta) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_ticks_add_obj, time_ticks_add);

extmod/vfs.c

@@ -96,11 +96,12 @@ mp_vfs_mount_t *mp_vfs_lookup_path(const char *path, const char **path_out) {
 STATIC mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
     const char *path = mp_obj_str_get_str(path_in);
     const char *p_out;
-    *path_out = mp_const_none;
     mp_vfs_mount_t *vfs = mp_vfs_lookup_path(path, &p_out);
     if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT) {
         *path_out = mp_obj_new_str_of_type(mp_obj_get_type(path_in),
             (const byte *)p_out, strlen(p_out));
+    } else {
+        *path_out = MP_OBJ_NULL;
     }
     return vfs;
 }
@@ -131,8 +132,9 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
     }
 
     // If the mounted object has the VFS protocol, call its import_stat helper
-    const mp_vfs_proto_t *proto = (mp_vfs_proto_t *)mp_proto_get(MP_QSTR_protocol_vfs, vfs->obj);
+    const mp_obj_type_t *type = mp_obj_get_type(vfs->obj);
-    if (proto != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, protocol)) {
+        const mp_vfs_proto_t *proto = MP_OBJ_TYPE_GET_SLOT(type, protocol);
         return proto->import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     }
 
@@ -171,7 +173,7 @@ STATIC mp_obj_t mp_vfs_autodetect(mp_obj_t bdev_obj) {
             #if MICROPY_VFS_LFS1
             if (memcmp(&buf[32], "littlefs", 8) == 0) {
                 // LFS1
-                mp_obj_t vfs = mp_type_vfs_lfs1.make_new(&mp_type_vfs_lfs1, 1, 0, &bdev_obj);
+                mp_obj_t vfs = MP_OBJ_TYPE_GET_SLOT(&mp_type_vfs_lfs1, make_new)(&mp_type_vfs_lfs1, 1, 0, &bdev_obj);
                 nlr_pop();
                 return vfs;
             }
@@ -179,7 +181,7 @@ STATIC mp_obj_t mp_vfs_autodetect(mp_obj_t bdev_obj) {
             #if MICROPY_VFS_LFS2
             if (memcmp(&buf[0], "littlefs", 8) == 0) {
                 // LFS2
-                mp_obj_t vfs = mp_type_vfs_lfs2.make_new(&mp_type_vfs_lfs2, 1, 0, &bdev_obj);
+                mp_obj_t vfs = MP_OBJ_TYPE_GET_SLOT(&mp_type_vfs_lfs2, make_new)(&mp_type_vfs_lfs2, 1, 0, &bdev_obj);
                 nlr_pop();
                 return vfs;
             }
@@ -192,7 +194,7 @@ STATIC mp_obj_t mp_vfs_autodetect(mp_obj_t bdev_obj) {
     #endif
 
     #if MICROPY_VFS_FAT
-    return mp_fat_vfs_type.make_new(&mp_fat_vfs_type, 1, 0, &bdev_obj);
+    return MP_OBJ_TYPE_GET_SLOT(&mp_fat_vfs_type, make_new)(&mp_fat_vfs_type, 1, 0, &bdev_obj);
     #endif
 
     // no filesystem found
@@ -311,7 +313,7 @@ mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
     #if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX
     // If the file is an integer then delegate straight to the POSIX handler
     if (mp_obj_is_small_int(args[ARG_file].u_obj)) {
-        return mp_vfs_posix_file_open(&mp_type_textio, args[ARG_file].u_obj, args[ARG_mode].u_obj);
+        return mp_vfs_posix_file_open(&mp_type_vfs_posix_textio, args[ARG_file].u_obj, args[ARG_mode].u_obj);
     }
     #endif
 
@@ -363,6 +365,7 @@ mp_obj_t mp_vfs_getcwd(void) {
 }
 MP_DEFINE_CONST_FUN_OBJ_0(mp_vfs_getcwd_obj, mp_vfs_getcwd);
 
+// CIRCUITPY: accessible from shared-module/os/__init__.c
 mp_obj_t mp_vfs_ilistdir_it_iternext(mp_obj_t self_in) {
     mp_vfs_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
     if (self->is_iter) {
@@ -402,7 +405,7 @@ mp_obj_t mp_vfs_ilistdir(size_t n_args, const mp_obj_t *args) {
         path_in = MP_OBJ_NEW_QSTR(MP_QSTR_);
     }
 
-    mp_obj_t path_out = mp_const_none;
+    mp_obj_t path_out;
     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
 
     if (vfs == MP_VFS_ROOT) {
@@ -535,4 +538,7 @@ int mp_vfs_mount_and_chdir_protected(mp_obj_t bdev, mp_obj_t mount_point) {
     return ret;
 }
 
+MP_REGISTER_ROOT_POINTER(struct _mp_vfs_mount_t *vfs_cur);
+MP_REGISTER_ROOT_POINTER(struct _mp_vfs_mount_t *vfs_mount_table);
+
 #endif // MICROPY_VFS

extmod/vfs_fat.c

@@ -28,6 +28,10 @@
 #include "py/mpconfig.h"
 #if MICROPY_VFS_FAT
 
+#if !MICROPY_ENABLE_FINALISER
+#error "MICROPY_VFS_FAT requires MICROPY_ENABLE_FINALISER"
+#endif
+
 #if !MICROPY_VFS
 #error "with MICROPY_VFS_FAT enabled, must also enable MICROPY_VFS"
 #endif
@@ -41,7 +45,6 @@
 #include "extmod/vfs_fat.h"
 #include "shared/timeutils/timeutils.h"
 #include "supervisor/filesystem.h"
-#include "supervisor/shared/translate/translate.h"
 
 #if FF_MAX_SS == FF_MIN_SS
 #define SECSIZE(fs) (FF_MIN_SS)
@@ -101,7 +104,7 @@ STATIC void verify_fs_writable(fs_user_mount_t *vfs) {
     }
 }
 
-#if FF_FS_REENTRANT
+#if _FS_REENTRANT
 STATIC mp_obj_t fat_vfs_del(mp_obj_t self_in) {
     mp_obj_fat_vfs_t *self = MP_OBJ_TO_PTR(self_in);
     // f_umount only needs to be called to release the sync object
@@ -177,6 +180,13 @@ STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
     return MP_OBJ_STOP_ITERATION;
 }
 
+STATIC mp_obj_t mp_vfs_fat_ilistdir_it_del(mp_obj_t self_in) {
+    mp_vfs_fat_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
+    // ignore result / error because we may be closing a second time.
+    f_closedir(&self->dir);
+    return mp_const_none;
+}
+
 STATIC mp_obj_t fat_vfs_ilistdir_func(size_t n_args, const mp_obj_t *args) {
     mp_obj_fat_vfs_t *self = MP_OBJ_TO_PTR(args[0]);
     bool is_str_type = true;
@@ -191,8 +201,10 @@ STATIC mp_obj_t fat_vfs_ilistdir_func(size_t n_args, const mp_obj_t *args) {
     }
 
     // Create a new iterator object to list the dir
-    mp_vfs_fat_ilistdir_it_t *iter = mp_obj_malloc(mp_vfs_fat_ilistdir_it_t, &mp_type_polymorph_iter);
+    mp_vfs_fat_ilistdir_it_t *iter = m_new_obj_with_finaliser(mp_vfs_fat_ilistdir_it_t);
+    iter->base.type = &mp_type_polymorph_iter_with_finaliser;
     iter->iternext = mp_vfs_fat_ilistdir_it_iternext;
+    iter->finaliser = mp_vfs_fat_ilistdir_it_del;
     iter->is_str = is_str_type;
     FRESULT res = f_opendir(&self->fatfs, &iter->dir, path);
     if (res != FR_OK) {
@@ -495,7 +507,7 @@ STATIC const mp_obj_property_t fat_vfs_label_obj = {
 #endif
 
 STATIC const mp_rom_map_elem_t fat_vfs_locals_dict_table[] = {
-    #if FF_FS_REENTRANT
+    #if _FS_REENTRANT
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&fat_vfs_del_obj) },
     #endif
     { MP_ROM_QSTR(MP_QSTR_mkfs), MP_ROM_PTR(&fat_vfs_mkfs_obj) },
@@ -524,16 +536,13 @@ STATIC const mp_vfs_proto_t fat_vfs_proto = {
     .import_stat = fat_vfs_import_stat,
 };
 
-const mp_obj_type_t mp_fat_vfs_type = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    mp_fat_vfs_type,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_VfsFat,
-    .name = MP_QSTR_VfsFat,
+    MP_TYPE_FLAG_NONE,
-    .make_new = fat_vfs_make_new,
+    make_new, fat_vfs_make_new,
-    .locals_dict = (mp_obj_dict_t *)&fat_vfs_locals_dict,
+    protocol, &fat_vfs_proto,
-    MP_TYPE_EXTENDED_FIELDS(
+    locals_dict, &fat_vfs_locals_dict
-        .protocol = &fat_vfs_proto,
+    );
-        ),
-
-};
 
 #endif // MICROPY_VFS_FAT

extmod/vfs_fat_file.c

@@ -148,17 +148,62 @@ STATIC mp_uint_t file_obj_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
     }
 }
 
-// Note: encoding is ignored for now; it's also not a valid kwarg for CPython's FileIO,
+// TODO gc hook to close the file if not already closed
-// but by adding it here we can use one single mp_arg_t array for open() and FileIO's constructor
+
-STATIC const mp_arg_t file_open_args[] = {
+STATIC const mp_rom_map_elem_t vfs_fat_rawfile_locals_dict_table[] = {
-    { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
-    { MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_r)} },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
-    { MP_QSTR_encoding, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_NONE} },
+    { 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) },
+    { 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_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), 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(&file_obj___exit___obj) },
 };
 #define FILE_OPEN_NUM_ARGS MP_ARRAY_SIZE(file_open_args)
 
-// CIRCUITPY is more careful about validating the open mode.
+STATIC MP_DEFINE_CONST_DICT(vfs_fat_rawfile_locals_dict, vfs_fat_rawfile_locals_dict_table);
-STATIC mp_obj_t file_open(fs_user_mount_t *vfs, const mp_obj_type_t *type, mp_arg_val_t *args) {
+
+STATIC const mp_stream_p_t vfs_fat_fileio_stream_p = {
+    .read = file_obj_read,
+    .write = file_obj_write,
+    .ioctl = file_obj_ioctl,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_fat_fileio,
+    MP_QSTR_FileIO,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
+    print, file_obj_print,
+    protocol, &vfs_fat_fileio_stream_p,
+    locals_dict, &vfs_fat_rawfile_locals_dict
+    );
+
+STATIC const mp_stream_p_t vfs_fat_textio_stream_p = {
+    .read = file_obj_read,
+    .write = file_obj_write,
+    .ioctl = file_obj_ioctl,
+    .is_text = true,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_fat_textio,
+    MP_QSTR_TextIOWrapper,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
+    print, file_obj_print,
+    protocol, &vfs_fat_textio_stream_p,
+    locals_dict, &vfs_fat_rawfile_locals_dict
+    );
+
+// Factory function for I/O stream classes
+STATIC mp_obj_t fat_vfs_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
+    fs_user_mount_t *self = MP_OBJ_TO_PTR(self_in);
+
+    const mp_obj_type_t *type = &mp_type_vfs_fat_textio;
     int mode = 0;
     const char *mode_s = mp_obj_str_get_str(args[1].u_obj);
     uint32_t rwxa_count = 0;
@@ -222,6 +267,7 @@ STATIC mp_obj_t file_open(fs_user_mount_t *vfs, const mp_obj_type_t *type, mp_ar
         m_del_obj(pyb_file_obj_t, o);
         mp_raise_OSError_errno_str(fresult_to_errno_table[res], args[0].u_obj);
     }
+    // CIRCUITPY does fast seek.
     // If we're reading, turn on fast seek.
     if (mode == FA_READ) {
         // One call to determine how much space we need.
@@ -249,87 +295,6 @@ STATIC mp_obj_t file_open(fs_user_mount_t *vfs, const mp_obj_type_t *type, mp_ar
 
     return MP_OBJ_FROM_PTR(o);
 }
-
+MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fat_vfs_open);
-STATIC mp_obj_t file_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    mp_arg_val_t arg_vals[FILE_OPEN_NUM_ARGS];
-    mp_arg_parse_all_kw_array(n_args, n_kw, args, FILE_OPEN_NUM_ARGS, file_open_args, arg_vals);
-    return file_open(NULL, type, arg_vals);
-}
-
-// TODO gc hook to close the file if not already closed
-
-STATIC const mp_rom_map_elem_t vfs_fat_rawfile_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) },
-    { 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_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
-    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
-    { MP_ROM_QSTR(MP_QSTR___del__), 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(&file_obj___exit___obj) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(vfs_fat_rawfile_locals_dict, vfs_fat_rawfile_locals_dict_table);
-
-#if MICROPY_PY_IO_FILEIO
-STATIC const mp_stream_p_t vfs_fat_fileio_stream_p = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
-    .read = file_obj_read,
-    .write = file_obj_write,
-    .ioctl = file_obj_ioctl,
-};
-
-const mp_obj_type_t mp_type_vfs_fat_fileio = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EXTENDED,
-    .name = MP_QSTR_FileIO,
-    .print = file_obj_print,
-    .make_new = file_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
-    MP_TYPE_EXTENDED_FIELDS(
-        .getiter = mp_identity_getiter,
-        .iternext = mp_stream_unbuffered_iter,
-        .protocol = &vfs_fat_fileio_stream_p,
-        ),
-};
-#endif
-
-STATIC const mp_stream_p_t vfs_fat_textio_stream_p = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
-    .read = file_obj_read,
-    .write = file_obj_write,
-    .ioctl = file_obj_ioctl,
-    .is_text = true,
-};
-
-const mp_obj_type_t mp_type_vfs_fat_textio = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EXTENDED,
-    .name = MP_QSTR_TextIOWrapper,
-    .print = file_obj_print,
-    .make_new = file_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
-    MP_TYPE_EXTENDED_FIELDS(
-        .getiter = mp_identity_getiter,
-        .iternext = mp_stream_unbuffered_iter,
-        .protocol = &vfs_fat_textio_stream_p,
-        ),
-};
-
-// Factory function for I/O stream classes
-STATIC mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode) {
-    // TODO: analyze buffering args and instantiate appropriate type
-    fs_user_mount_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_arg_val_t arg_vals[FILE_OPEN_NUM_ARGS];
-    arg_vals[0].u_obj = path;
-    arg_vals[1].u_obj = mode;
-    arg_vals[2].u_obj = mp_const_none;
-    return file_open(self, &mp_type_vfs_fat_textio, arg_vals);
-}
-MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fatfs_builtin_open_self);
 
 #endif // MICROPY_VFS && MICROPY_VFS_FAT

extmod/vfs_lfs.c

@@ -26,12 +26,13 @@
 
 #include "py/runtime.h"
 #include "py/mphal.h"
+
+#if MICROPY_VFS && (MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2)
+
 #include "shared/timeutils/timeutils.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_lfs.h"
 
-#if MICROPY_VFS && (MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2)
-
 enum { LFS_MAKE_ARG_bdev, LFS_MAKE_ARG_readsize, LFS_MAKE_ARG_progsize, LFS_MAKE_ARG_lookahead, LFS_MAKE_ARG_mtime };
 
 static const mp_arg_t lfs_make_allowed_args[] = {

extmod/vfs_lfsx.c

@@ -24,6 +24,9 @@
  * THE SOFTWARE.
  */
 
+// This file should be compiled when included from vfs_lfs.c.
+#if defined(LFS_BUILD_VERSION)
+
 #include <stdio.h>
 #include <string.h>
 
@@ -36,6 +39,10 @@
 #include "extmod/vfs.h"
 #include "shared/timeutils/timeutils.h"
 
+#if !MICROPY_ENABLE_FINALISER
+#error "MICROPY_VFS_LFS requires MICROPY_ENABLE_FINALISER"
+#endif
+
 STATIC int MP_VFS_LFSx(dev_ioctl)(const struct LFSx_API (config) * c, int cmd, int arg, bool must_return_int) {
     mp_obj_t ret = mp_vfs_blockdev_ioctl(c->context, cmd, arg);
     int ret_i = 0;
@@ -155,6 +162,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(MP_VFS_LFSx(open_obj), MP_VFS_LFSx(file_open));
 typedef struct MP_VFS_LFSx (_ilistdir_it_t) {
     mp_obj_base_t base;
     mp_fun_1_t iternext;
+    mp_fun_1_t finaliser;
     bool is_str;
     MP_OBJ_VFS_LFSx *vfs;
     LFSx_API(dir_t) dir;
@@ -163,11 +171,16 @@ typedef struct MP_VFS_LFSx (_ilistdir_it_t) {
 STATIC mp_obj_t MP_VFS_LFSx(ilistdir_it_iternext)(mp_obj_t self_in) {
     MP_VFS_LFSx(ilistdir_it_t) * self = MP_OBJ_TO_PTR(self_in);
 
+    if (self->vfs == NULL) {
+        return MP_OBJ_STOP_ITERATION;
+    }
+
     struct LFSx_API (info) info;
     for (;;) {
         int ret = LFSx_API(dir_read)(&self->vfs->lfs, &self->dir, &info);
         if (ret == 0) {
             LFSx_API(dir_close)(&self->vfs->lfs, &self->dir);
+            self->vfs = NULL;
             return MP_OBJ_STOP_ITERATION;
         }
         if (!(info.name[0] == '.' && (info.name[1] == '\0'
@@ -190,6 +203,14 @@ STATIC mp_obj_t MP_VFS_LFSx(ilistdir_it_iternext)(mp_obj_t self_in) {
     return MP_OBJ_FROM_PTR(t);
 }
 
+STATIC mp_obj_t MP_VFS_LFSx(ilistdir_it_del)(mp_obj_t self_in) {
+    MP_VFS_LFSx(ilistdir_it_t) * self = MP_OBJ_TO_PTR(self_in);
+    if (self->vfs != NULL) {
+        LFSx_API(dir_close)(&self->vfs->lfs, &self->dir);
+    }
+    return mp_const_none;
+}
+
 STATIC mp_obj_t MP_VFS_LFSx(ilistdir_func)(size_t n_args, const mp_obj_t *args) {
     MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(args[0]);
     bool is_str_type = true;
@@ -203,14 +224,17 @@ STATIC mp_obj_t MP_VFS_LFSx(ilistdir_func)(size_t n_args, const mp_obj_t *args)
         path = vstr_null_terminated_str(&self->cur_dir);
     }
 
-    MP_VFS_LFSx(ilistdir_it_t) * iter = mp_obj_malloc(MP_VFS_LFSx(ilistdir_it_t), &mp_type_polymorph_iter);
+    MP_VFS_LFSx(ilistdir_it_t) * iter = m_new_obj_with_finaliser(MP_VFS_LFSx(ilistdir_it_t));
+    iter->base.type = &mp_type_polymorph_iter_with_finaliser;
+
     iter->iternext = MP_VFS_LFSx(ilistdir_it_iternext);
+    iter->finaliser = MP_VFS_LFSx(ilistdir_it_del);
     iter->is_str = is_str_type;
-    iter->vfs = self;
     int ret = LFSx_API(dir_open)(&self->lfs, &iter->dir, path);
     if (ret < 0) {
         mp_raise_OSError(-ret);
     }
+    iter->vfs = self;
     return MP_OBJ_FROM_PTR(iter);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(MP_VFS_LFSx(ilistdir_obj), 1, 2, MP_VFS_LFSx(ilistdir_func));
@@ -481,17 +505,21 @@ STATIC const mp_vfs_proto_t MP_VFS_LFSx(proto) = {
     .import_stat = MP_VFS_LFSx(import_stat),
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx = {
+#if LFS_BUILD_VERSION == 1
-    { &mp_type_type },
+#define VFS_LFSx_QSTR MP_QSTR_VfsLfs1
-    .flags = MP_TYPE_FLAG_EXTENDED,
+#else
-    #if LFS_BUILD_VERSION == 1
+#define VFS_LFSx_QSTR MP_QSTR_VfsLfs2
-    .name = MP_QSTR_VfsLfs1,
+#endif
-    #else
+
-    .name = MP_QSTR_VfsLfs2,
+MP_DEFINE_CONST_OBJ_TYPE(
-    #endif
+    MP_TYPE_VFS_LFSx,
-    .make_new = MP_VFS_LFSx(make_new),
+    VFS_LFSx_QSTR,
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(locals_dict),
+    MP_TYPE_FLAG_NONE,
-    MP_TYPE_EXTENDED_FIELDS(
+    make_new, MP_VFS_LFSx(make_new),
-        .protocol = &MP_VFS_LFSx(proto),
+    protocol, &MP_VFS_LFSx(proto),
-        ),
+    locals_dict, &MP_VFS_LFSx(locals_dict)
-};
+    );
+
+#undef VFS_LFSx_QSTR
+
+#endif // defined(LFS_BUILD_VERSION)

extmod/vfs_lfsx_file.c

@@ -24,6 +24,9 @@
  * THE SOFTWARE.
  */
 
+// This file should be compiled when included from vfs_lfs.c.
+#if defined(LFS_BUILD_VERSION)
+
 #include <stdio.h>
 #include <string.h>
 
@@ -68,11 +71,9 @@ mp_obj_t MP_VFS_LFSx(file_open)(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mod
             case '+':
                 flags |= LFSx_MACRO(_O_RDWR);
                 break;
-            #if MICROPY_PY_IO_FILEIO
             case 'b':
                 type = &MP_TYPE_VFS_LFSx_(_fileio);
                 break;
-            #endif
             case 't':
                 type = &MP_TYPE_VFS_LFSx_(_textio);
                 break;
@@ -216,45 +217,35 @@ STATIC const mp_rom_map_elem_t MP_VFS_LFSx(file_locals_dict_table)[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(file_locals_dict), MP_VFS_LFSx(file_locals_dict_table));
 
-#if MICROPY_PY_IO_FILEIO
 STATIC const mp_stream_p_t MP_VFS_LFSx(fileio_stream_p) = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
     .read = MP_VFS_LFSx(file_read),
     .write = MP_VFS_LFSx(file_write),
     .ioctl = MP_VFS_LFSx(file_ioctl),
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx_(_fileio) = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    MP_TYPE_VFS_LFSx_(_fileio),
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_FileIO,
-    .name = MP_QSTR_FileIO,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
-    .print = MP_VFS_LFSx(file_print),
+    print, MP_VFS_LFSx(file_print),
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
+    protocol, &MP_VFS_LFSx(fileio_stream_p),
-    MP_TYPE_EXTENDED_FIELDS(
+    locals_dict, &MP_VFS_LFSx(file_locals_dict)
-        .getiter = mp_identity_getiter,
+    );
-        .iternext = mp_stream_unbuffered_iter,
-        .protocol = &MP_VFS_LFSx(fileio_stream_p),
-        ),
-};
-#endif
 
 STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
     .read = MP_VFS_LFSx(file_read),
     .write = MP_VFS_LFSx(file_write),
     .ioctl = MP_VFS_LFSx(file_ioctl),
     .is_text = true,
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx_(_textio) = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    MP_TYPE_VFS_LFSx_(_textio),
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_TextIOWrapper,
-    .name = MP_QSTR_TextIOWrapper,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
-    .print = MP_VFS_LFSx(file_print),
+    print, MP_VFS_LFSx(file_print),
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
+    protocol, &MP_VFS_LFSx(textio_stream_p),
-    MP_TYPE_EXTENDED_FIELDS(
+    locals_dict, &MP_VFS_LFSx(file_locals_dict)
-        .getiter = mp_identity_getiter,
+    );
-        .iternext = mp_stream_unbuffered_iter,
+
-        .protocol = &MP_VFS_LFSx(textio_stream_p),
+#endif // defined(LFS_BUILD_VERSION)
-        ),
-};

extmod/vfs_posix.c

@@ -31,11 +31,17 @@
 #include "extmod/vfs.h"
 #include "extmod/vfs_posix.h"
 
-#if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX
+#if MICROPY_VFS_POSIX
 
+#if !MICROPY_ENABLE_FINALISER
+#error "MICROPY_VFS_POSIX requires MICROPY_ENABLE_FINALISER"
+#endif
+
+#include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <unistd.h>
 #include <dirent.h>
 #ifdef _MSC_VER
 #include <direct.h> // For mkdir etc.
@@ -138,7 +144,7 @@ STATIC mp_obj_t vfs_posix_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode
     if (!mp_obj_is_small_int(path_in)) {
         path_in = vfs_posix_get_path_obj(self, path_in);
     }
-    return mp_vfs_posix_file_open(&mp_type_textio, path_in, mode_in);
+    return mp_vfs_posix_file_open(&mp_type_vfs_posix_textio, path_in, mode_in);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_open_obj, vfs_posix_open);
 
@@ -162,6 +168,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_getcwd_obj, vfs_posix_getcwd);
 typedef struct _vfs_posix_ilistdir_it_t {
     mp_obj_base_t base;
     mp_fun_1_t iternext;
+    mp_fun_1_t finaliser;
     bool is_str;
     DIR *dir;
 } vfs_posix_ilistdir_it_t;
@@ -185,7 +192,7 @@ STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
         MP_THREAD_GIL_ENTER();
         const char *fn = dirent->d_name;
 
-        if (fn[0] == '.' && (fn[1] == 0 || fn[1] == '.')) {
+        if (fn[0] == '.' && (fn[1] == 0 || (fn[1] == '.' && fn[2] == 0))) {
             // skip . and ..
             continue;
         }
@@ -226,10 +233,22 @@ STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
     }
 }
 
+STATIC mp_obj_t vfs_posix_ilistdir_it_del(mp_obj_t self_in) {
+    vfs_posix_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->dir != NULL) {
+        MP_THREAD_GIL_EXIT();
+        closedir(self->dir);
+        MP_THREAD_GIL_ENTER();
+    }
+    return mp_const_none;
+}
+
 STATIC mp_obj_t vfs_posix_ilistdir(mp_obj_t self_in, mp_obj_t path_in) {
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
-    vfs_posix_ilistdir_it_t *iter = mp_obj_malloc(vfs_posix_ilistdir_it_t, &mp_type_polymorph_iter);
+    vfs_posix_ilistdir_it_t *iter = m_new_obj_with_finaliser(vfs_posix_ilistdir_it_t);
+    iter->base.type = &mp_type_polymorph_iter_with_finaliser;
     iter->iternext = vfs_posix_ilistdir_it_iternext;
+    iter->finaliser = vfs_posix_ilistdir_it_del;
     iter->is_str = mp_obj_get_type(path_in) == &mp_type_str;
     const char *path = vfs_posix_get_path_str(self, path_in);
     if (path[0] == '\0') {
@@ -378,19 +397,16 @@ STATIC const mp_rom_map_elem_t vfs_posix_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(vfs_posix_locals_dict, vfs_posix_locals_dict_table);
 
 STATIC const mp_vfs_proto_t vfs_posix_proto = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_vfs)
     .import_stat = mp_vfs_posix_import_stat,
 };
 
-const mp_obj_type_t mp_type_vfs_posix = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    mp_type_vfs_posix,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_VfsPosix,
-    .name = MP_QSTR_VfsPosix,
+    MP_TYPE_FLAG_NONE,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_locals_dict,
+    make_new, vfs_posix_make_new,
-    .make_new = vfs_posix_make_new,
+    protocol, &vfs_posix_proto,
-    MP_TYPE_EXTENDED_FIELDS(
+    locals_dict, &vfs_posix_locals_dict
-        .protocol = &vfs_posix_proto,
+    );
-        ),
-};
 
 #endif // MICROPY_VFS_POSIX

extmod/vfs_posix_file.c

@@ -29,9 +29,8 @@
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "extmod/vfs_posix.h"
-#include "supervisor/shared/translate/translate.h"
 
-#if (defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX) || (defined(MICROPY_VFS_POSIX_FILE) && MICROPY_VFS_POSIX_FILE)
+#if MICROPY_VFS_POSIX
 
 #include <fcntl.h>
 #include <unistd.h>
@@ -47,7 +46,7 @@ typedef struct _mp_obj_vfs_posix_file_t {
     int fd;
 } mp_obj_vfs_posix_file_t;
 
-#ifdef MICROPY_CPYTHON_COMPAT
+#if MICROPY_CPYTHON_COMPAT
 STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
     if (o->fd < 0) {
         mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
@@ -60,11 +59,11 @@ STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
 STATIC void vfs_posix_file_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_vfs_posix_file_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_printf(print, "<io.%q %d>", mp_obj_get_type_qstr(self_in), self->fd);
+    mp_printf(print, "<io.%s %d>", mp_obj_get_type_str(self_in), self->fd);
 }
 
 mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in) {
-    mp_obj_vfs_posix_file_t *o = m_new_obj(mp_obj_vfs_posix_file_t);
+    mp_obj_vfs_posix_file_t *o = m_new_obj_with_finaliser(mp_obj_vfs_posix_file_t);
     const char *mode_s = mp_obj_str_get_str(mode_in);
 
     int mode_rw = 0, mode_x = 0;
@@ -84,15 +83,12 @@ mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_
             case '+':
                 mode_rw = O_RDWR;
                 break;
-                #if MICROPY_PY_IO_FILEIO
-            // If we don't have io.FileIO, then files are in text mode implicitly
             case 'b':
                 type = &mp_type_vfs_posix_fileio;
                 break;
             case 't':
                 type = &mp_type_vfs_posix_textio;
                 break;
-                #endif
         }
     }
 
@@ -112,17 +108,6 @@ mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_
     return MP_OBJ_FROM_PTR(o);
 }
 
-STATIC mp_obj_t vfs_posix_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_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
-        { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
-    };
-
-    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_posix_file_open(type, arg_vals[0].u_obj, arg_vals[1].u_obj);
-}
-
 STATIC mp_obj_t vfs_posix_file_fileno(mp_obj_t self_in) {
     mp_obj_vfs_posix_file_t *self = MP_OBJ_TO_PTR(self_in);
     check_fd_is_open(self);
@@ -150,6 +135,12 @@ STATIC mp_uint_t vfs_posix_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, i
 STATIC mp_uint_t vfs_posix_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
     mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
+    #if MICROPY_PY_OS_DUPTERM
+    if (o->fd <= STDERR_FILENO) {
+        mp_hal_stdout_tx_strn(buf, size);
+        return size;
+    }
+    #endif
     ssize_t r;
     MP_HAL_RETRY_SYSCALL(r, write(o->fd, buf, size), {
         *errcode = err;
@@ -194,12 +185,12 @@ STATIC mp_uint_t vfs_posix_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_
             return 0;
         }
         case MP_STREAM_CLOSE:
-            MP_THREAD_GIL_EXIT();
+            if (o->fd >= 0) {
-            close(o->fd);
+                MP_THREAD_GIL_EXIT();
-            MP_THREAD_GIL_ENTER();
+                close(o->fd);
-            #ifdef MICROPY_CPYTHON_COMPAT
+                MP_THREAD_GIL_ENTER();
+            }
             o->fd = -1;
-            #endif
             return 0;
         case MP_STREAM_GET_FILENO:
             return o->fd;
@@ -246,59 +237,46 @@ STATIC const mp_rom_map_elem_t vfs_posix_rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
     { 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___del__), 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_posix_file___exit___obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(vfs_posix_rawfile_locals_dict, vfs_posix_rawfile_locals_dict_table);
 
-#if MICROPY_PY_IO_FILEIO
 STATIC const mp_stream_p_t vfs_posix_fileio_stream_p = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
     .read = vfs_posix_file_read,
     .write = vfs_posix_file_write,
     .ioctl = vfs_posix_file_ioctl,
 };
 
-const mp_obj_type_t mp_type_vfs_posix_fileio = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    mp_type_vfs_posix_fileio,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_FileIO,
-    .name = MP_QSTR_FileIO,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
-    .print = vfs_posix_file_print,
+    print, vfs_posix_file_print,
-    .make_new = vfs_posix_file_make_new,
+    protocol, &vfs_posix_fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
+    locals_dict, &vfs_posix_rawfile_locals_dict
-    MP_TYPE_EXTENDED_FIELDS(
+    );
-        .getiter = mp_identity_getiter,
-        .iternext = mp_stream_unbuffered_iter,
-        .protocol = &vfs_posix_fileio_stream_p,
-        ),
-};
-#endif
 
 STATIC const mp_stream_p_t vfs_posix_textio_stream_p = {
-    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
     .read = vfs_posix_file_read,
     .write = vfs_posix_file_write,
     .ioctl = vfs_posix_file_ioctl,
     .is_text = true,
 };
 
-const mp_obj_type_t mp_type_vfs_posix_textio = {
+MP_DEFINE_CONST_OBJ_TYPE(
-    { &mp_type_type },
+    mp_type_vfs_posix_textio,
-    .flags = MP_TYPE_FLAG_EXTENDED,
+    MP_QSTR_TextIOWrapper,
-    .name = MP_QSTR_TextIOWrapper,
+    MP_TYPE_FLAG_ITER_IS_STREAM,
-    .print = vfs_posix_file_print,
+    print, vfs_posix_file_print,
-    .make_new = vfs_posix_file_make_new,
+    protocol, &vfs_posix_textio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
+    locals_dict, &vfs_posix_rawfile_locals_dict
-    MP_TYPE_EXTENDED_FIELDS(
+    );
-        .getiter = mp_identity_getiter,
-        .iternext = mp_stream_unbuffered_iter,
-        .protocol = &vfs_posix_textio_stream_p,
-        ),
-};
 
-const mp_obj_vfs_posix_file_t mp_sys_stdin_obj = {{&mp_type_textio}, STDIN_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stdin_obj = {{&mp_type_vfs_posix_textio}, STDIN_FILENO};
-const mp_obj_vfs_posix_file_t mp_sys_stdout_obj = {{&mp_type_textio}, STDOUT_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stdout_obj = {{&mp_type_vfs_posix_textio}, STDOUT_FILENO};
-const mp_obj_vfs_posix_file_t mp_sys_stderr_obj = {{&mp_type_textio}, STDERR_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stderr_obj = {{&mp_type_vfs_posix_textio}, STDERR_FILENO};
 
-#endif // MICROPY_VFS_POSIX || MICROPY_VFS_POSIX_FILE
+#endif // MICROPY_VFS_POSIX

extmod/virtpin.c

@@ -25,16 +25,15 @@
  */
 
 #include "extmod/virtpin.h"
-#include "py/proto.h"
 
 int mp_virtual_pin_read(mp_obj_t pin) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
-    const mp_pin_p_t *pin_p = mp_proto_get(MP_QSTR_protocol_pin, s);
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     return pin_p->ioctl(pin, MP_PIN_READ, 0, NULL);
 }
 
 void mp_virtual_pin_write(mp_obj_t pin, int value) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
-    const mp_pin_p_t *pin_p = mp_proto_get(MP_QSTR_protocol_pin, s);
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     pin_p->ioctl(pin, MP_PIN_WRITE, value, NULL);
 }

lib/cyw43-driver

@@ -0,0 +1 @@
+Subproject commit 36144f94bee69ad5e7b46fef06ce0c2405bafee5

lib/libm/thumb_vfp_sqrtf.c

@@ -3,7 +3,7 @@
 #include <math.h>
 
 float sqrtf(float x) {
-    asm volatile (
+    __asm__ volatile (
             "vsqrt.f32  %[r], %[x]\n"
             : [r] "=t" (x)
             : [x] "t"  (x));

lib/libm_dbl/thumb_vfp_sqrt.c

@@ -2,7 +2,7 @@
 
 double sqrt(double x) {
     double ret;
-    asm volatile (
+    __asm__ volatile (
             "vsqrt.f64  %P0, %P1\n"
             : "=w" (ret)
             : "w"  (x));

lib/mbedtls

@@ -1 +0,0 @@
-Subproject commit 1bc2c9cb8b8fe4659bd94b8ebba5a4c02029b7fa

lib/mbedtls_errors/README.md

@@ -1,42 +0,0 @@
-MBEDTLS Error Strings for MicroPython
-=====================================
-
-This directory contains source code and tools to rework the Mbedtls error strings for
-micropython to use less space. In short, instead of storing and printing something like
-"SSL - Our own certificate(s) is/are too large to send in an SSL message" it prints
-the name of the error #define, which would be "MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE" in
-this case, and only stores `SSL_CERTIFICATE_TOO_LARGE` in flash. The exact Mbedtls error
-defines are used because they're easy to search for to find more detailed information.
-
-Mbedtls defines a specific format for error value #defines and
-includes a Perl script to gather all `MBEDTLS_ERR` defines from includes files together with
-english error text. From that the Perl script generates `mbedtls_strerror()`. The files in this
-directory modify this process to produce a more space efficient error lookup table with
-shorter error strings.
-
-The files are as follows:
-- `generate_errors.diff` - diff for original mbedtls perl script
-- `error.fmt` - modified code template for MicroPython
-- `mp_mbedtls_errors.c` - source file with `mbedtls_strerror` this is built using the include
-  files in `../mbedtls`
-- `do-mp.sh` - shell script to produce `mp_mbedtls_errors.c`
-- `tester.c` - simple C main to test `mp_mbedtls_errors.c` locally on a dev box
-- `do-test.sh` - shell script to produce `mp_mbedtls_errors.c` and compile the `tester` app
-- `do-esp32.sh` - shell script to produce `esp32_mbedtls_errors.c` -- see below
-
-In order not to store multiple copies of `mbedtls_errors.c`
-([https://github.com/micropython/micropython/pull/5819#discussion_r445528006](see))
-it is assumed that all ports use the same version of mbedtls with the same error #defines.
-This is true as of MP v1.13, and ESP-IDF versions 3.3.2 and 4.0.1. If anything changes in the
-future the `do-esp32.sh` script can be used to generate an esp32-specific version.
-
-### How-to
-
-- To build MicroPython all that is needed is to include the `mp_mbedtls_errors.c` into the build
-  (the Makefiles do this automatically). Note that Perl is not needed for routine MicroPython
-  builds.
-- When a new version of Mbedtls is pulled-in the `do-mp.sh` script should be run to
-  re-generate `mp_mbedtls_errors.c`.
-- The `tester` app should be run if changes to the string handling in `error.fmt` are made:
-  it tests that there is not an off-by-one error in the string copying/appending, etc.
-- To include `mbedtls_strerror` error strings define `MBEDTLS_ERROR_C` in the build.

lib/mbedtls_errors/do-esp32.sh

@@ -1,7 +0,0 @@
-#! /bin/bash -e
-# Generate esp32_mbedtls_errors.c for use in the Esp32 port, with the ESP-IDF version of mbedtls
-# The IDF_PATH env var must be set to the top-level dir of ESPIDF
-echo "IDF_PATH=$IDF_PATH"
-MBEDTLS=$IDF_PATH/components/mbedtls/mbedtls
-patch -o esp32_generate_errors.pl $MBEDTLS/scripts/generate_errors.pl <generate_errors.diff
-perl ./esp32_generate_errors.pl $MBEDTLS/include/mbedtls . esp32_mbedtls_errors.c

lib/mbedtls_errors/do-mp.sh

@@ -1,4 +0,0 @@
-#! /bin/bash -e
-# Generate mp_mbedtls_errors.c for inclusion in ports that use $MPY/lib/mbedtls
-patch -o mp_generate_errors.pl ../mbedtls/scripts/generate_errors.pl <generate_errors.diff
-perl ./mp_generate_errors.pl ../mbedtls/include/mbedtls . mp_mbedtls_errors.c

lib/mbedtls_errors/do-test.sh

@@ -1,4 +0,0 @@
-#! /bin/bash -e
-# Generate mp_mbedtls_errors.c and build the tester app
-./do-mp.sh
-cc -o tester -I../mbedtls/include/ mp_mbedtls_errors.c tester.c

lib/mbedtls_errors/error.fmt

@@ -1,165 +0,0 @@
-/*
- *  Error message information
- *
- *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may
- *  not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *  This file is part of mbed TLS (https://tls.mbed.org)
- */
-
-#if !defined(MBEDTLS_CONFIG_FILE)
-#include "mbedtls/config.h"
-#else
-#include MBEDTLS_CONFIG_FILE
-#endif
-
-#if defined(MBEDTLS_ERROR_C) || defined(MBEDTLS_ERROR_STRERROR_DUMMY)
-#include "mbedtls/error.h"
-#include <string.h>
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#define mbedtls_snprintf snprintf
-#define mbedtls_time_t   time_t
-#endif
-
-#if defined(MBEDTLS_ERROR_C)
-
-#include <stdio.h>
-
-HEADER_INCLUDED
-
-// Error code table type
-struct ssl_errs {
-    int16_t errnum;
-    const char *errstr;
-};
-
-// Table of high level error codes
-static const struct ssl_errs mbedtls_high_level_error_tab[] = {
-// BEGIN generated code
-HIGH_LEVEL_CODE_CHECKS
-// END generated code
-};
-
-static const struct ssl_errs mbedtls_low_level_error_tab[] = {
-// Low level error codes
-//
-// BEGIN generated code
-LOW_LEVEL_CODE_CHECKS
-// END generated code
-};
-
-static const char *mbedtls_err_prefix = "MBEDTLS_ERR_";
-#define MBEDTLS_ERR_PREFIX_LEN ( sizeof("MBEDTLS_ERR_")-1 )
-
-// copy error text into buffer, ensure null termination, return strlen of result
-static size_t mbedtls_err_to_str(int err, const struct ssl_errs tab[], int tab_len, char *buf, size_t buflen) {
-    if (buflen == 0) return 0;
-
-    // prefix for all error names
-    strncpy(buf, mbedtls_err_prefix, buflen);
-    if (buflen <= MBEDTLS_ERR_PREFIX_LEN+1) {
-        buf[buflen-1] = 0;
-        return buflen-1;
-    }
-
-    // append error name from table
-    for (int i = 0; i < tab_len; i++) {
-        if (tab[i].errnum == err) {
-            strncpy(buf+MBEDTLS_ERR_PREFIX_LEN, tab[i].errstr, buflen-MBEDTLS_ERR_PREFIX_LEN);
-            buf[buflen-1] = 0;
-            return strlen(buf);
-        }
-    }
-
-    mbedtls_snprintf(buf+MBEDTLS_ERR_PREFIX_LEN, buflen-MBEDTLS_ERR_PREFIX_LEN, "UNKNOWN (0x%04X)",
-            err);
-    return strlen(buf);
-}
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-void mbedtls_strerror(int ret, char *buf, size_t buflen) {
-    int use_ret;
-
-    if (buflen == 0) return;
-
-    buf[buflen-1] = 0;
-
-    if (ret < 0) ret = -ret;
-
-    //
-    // High-level error codes
-    //
-    uint8_t got_hl = (ret & 0xFF80) != 0;
-    if (got_hl) {
-        use_ret = ret & 0xFF80;
-
-        // special case
-#if defined(MBEDTLS_SSL_TLS_C)
-        if (use_ret == -(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE)) {
-            strncpy(buf, "MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE", buflen);
-            buf[buflen-1] = 0;
-            return;
-        }
-#endif
-
-        size_t len = mbedtls_err_to_str(use_ret, mbedtls_high_level_error_tab,
-                ARRAY_SIZE(mbedtls_high_level_error_tab), buf, buflen);
-
-        buf += len;
-        buflen -= len;
-        if (buflen == 0) return;
-    }
-
-    //
-    // Low-level error codes
-    //
-    use_ret = ret & ~0xFF80;
-
-    if (use_ret == 0) return;
-
-    // If high level code is present, make a concatenation between both error strings.
-    if (got_hl) {
-        if (buflen < 2) return;
-        *buf++ = '+';
-        buflen--;
-    }
-
-    mbedtls_err_to_str(use_ret, mbedtls_low_level_error_tab,
-            ARRAY_SIZE(mbedtls_low_level_error_tab), buf, buflen);
-}
-
-#else /* MBEDTLS_ERROR_C */
-
-#if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
-
-/*
- * Provide an non-function in case MBEDTLS_ERROR_C is not defined
- */
-void mbedtls_strerror( int ret, char *buf, size_t buflen )
-{
-    ((void) ret);
-
-    if( buflen > 0 )
-        buf[0] = '\0';
-}
-
-#endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
-
-#endif /* MBEDTLS_ERROR_C */

lib/mbedtls_errors/generate_errors.diff

@@ -1,22 +0,0 @@
---- generate_errors_orig.pl	2020-06-20 08:40:38.819060379 -0700
-+++ generate_errors.pl	2020-06-20 08:47:26.511163591 -0700
-@@ -162,16 +162,12 @@
- 
-     if ($error_name eq "MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE")
-     {
--        ${$code_check} .= "${white_space}if( use_ret == -($error_name) )\n".
--                          "${white_space}\{\n".
--                          "${white_space}    mbedtls_snprintf( buf, buflen, \"$module_name - $description\" );\n".
--                          "${white_space}    return;\n".
--                          "${white_space}}\n"
-+        # no-op, this case is hard-coded in error.fmt
-     }
-     else
-     {
--        ${$code_check} .= "${white_space}if( use_ret == -($error_name) )\n".
--                          "${white_space}    mbedtls_snprintf( buf, buflen, \"$module_name - $description\" );\n"
-+         my $error_text = $error_name =~ s/^MBEDTLS_ERR_//r;
-+         ${$code_check} .= "${white_space}{ -($error_name), \"$error_text\" },\n"
-     }
- };
- 

lib/mbedtls_errors/mp_mbedtls_errors.c

@@ -1,705 +0,0 @@
-/*
- *  Error message information
- *
- *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may
- *  not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *  This file is part of mbed TLS (https://tls.mbed.org)
- */
-
-#if !defined(MBEDTLS_CONFIG_FILE)
-#include "mbedtls/config.h"
-#else
-#include MBEDTLS_CONFIG_FILE
-#endif
-
-#if defined(MBEDTLS_ERROR_C) || defined(MBEDTLS_ERROR_STRERROR_DUMMY)
-#include "mbedtls/error.h"
-#include <string.h>
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#else
-#define mbedtls_snprintf snprintf
-#define mbedtls_time_t   time_t
-#endif
-
-#if defined(MBEDTLS_ERROR_C)
-
-#include <stdio.h>
-
-#if defined(MBEDTLS_AES_C)
-#include "mbedtls/aes.h"
-#endif
-
-#if defined(MBEDTLS_ARC4_C)
-#include "mbedtls/arc4.h"
-#endif
-
-#if defined(MBEDTLS_ARIA_C)
-#include "mbedtls/aria.h"
-#endif
-
-#if defined(MBEDTLS_BASE64_C)
-#include "mbedtls/base64.h"
-#endif
-
-#if defined(MBEDTLS_BIGNUM_C)
-#include "mbedtls/bignum.h"
-#endif
-
-#if defined(MBEDTLS_BLOWFISH_C)
-#include "mbedtls/blowfish.h"
-#endif
-
-#if defined(MBEDTLS_CAMELLIA_C)
-#include "mbedtls/camellia.h"
-#endif
-
-#if defined(MBEDTLS_CCM_C)
-#include "mbedtls/ccm.h"
-#endif
-
-#if defined(MBEDTLS_CHACHA20_C)
-#include "mbedtls/chacha20.h"
-#endif
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-#include "mbedtls/chachapoly.h"
-#endif
-
-#if defined(MBEDTLS_CIPHER_C)
-#include "mbedtls/cipher.h"
-#endif
-
-#if defined(MBEDTLS_CMAC_C)
-#include "mbedtls/cmac.h"
-#endif
-
-#if defined(MBEDTLS_CTR_DRBG_C)
-#include "mbedtls/ctr_drbg.h"
-#endif
-
-#if defined(MBEDTLS_DES_C)
-#include "mbedtls/des.h"
-#endif
-
-#if defined(MBEDTLS_DHM_C)
-#include "mbedtls/dhm.h"
-#endif
-
-#if defined(MBEDTLS_ECP_C)
-#include "mbedtls/ecp.h"
-#endif
-
-#if defined(MBEDTLS_ENTROPY_C)
-#include "mbedtls/entropy.h"
-#endif
-
-#if defined(MBEDTLS_GCM_C)
-#include "mbedtls/gcm.h"
-#endif
-
-#if defined(MBEDTLS_HKDF_C)
-#include "mbedtls/hkdf.h"
-#endif
-
-#if defined(MBEDTLS_HMAC_DRBG_C)
-#include "mbedtls/hmac_drbg.h"
-#endif
-
-#if defined(MBEDTLS_MD_C)
-#include "mbedtls/md.h"
-#endif
-
-#if defined(MBEDTLS_MD2_C)
-#include "mbedtls/md2.h"
-#endif
-
-#if defined(MBEDTLS_MD4_C)
-#include "mbedtls/md4.h"
-#endif
-
-#if defined(MBEDTLS_MD5_C)
-#include "mbedtls/md5.h"
-#endif
-
-#if defined(MBEDTLS_NET_C)
-#include "mbedtls/net_sockets.h"
-#endif
-
-#if defined(MBEDTLS_OID_C)
-#include "mbedtls/oid.h"
-#endif
-
-#if defined(MBEDTLS_PADLOCK_C)
-#include "mbedtls/padlock.h"
-#endif
-
-#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
-#include "mbedtls/pem.h"
-#endif
-
-#if defined(MBEDTLS_PK_C)
-#include "mbedtls/pk.h"
-#endif
-
-#if defined(MBEDTLS_PKCS12_C)
-#include "mbedtls/pkcs12.h"
-#endif
-
-#if defined(MBEDTLS_PKCS5_C)
-#include "mbedtls/pkcs5.h"
-#endif
-
-#if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
-#endif
-
-#if defined(MBEDTLS_POLY1305_C)
-#include "mbedtls/poly1305.h"
-#endif
-
-#if defined(MBEDTLS_RIPEMD160_C)
-#include "mbedtls/ripemd160.h"
-#endif
-
-#if defined(MBEDTLS_RSA_C)
-#include "mbedtls/rsa.h"
-#endif
-
-#if defined(MBEDTLS_SHA1_C)
-#include "mbedtls/sha1.h"
-#endif
-
-#if defined(MBEDTLS_SHA256_C)
-#include "mbedtls/sha256.h"
-#endif
-
-#if defined(MBEDTLS_SHA512_C)
-#include "mbedtls/sha512.h"
-#endif
-
-#if defined(MBEDTLS_SSL_TLS_C)
-#include "mbedtls/ssl.h"
-#endif
-
-#if defined(MBEDTLS_THREADING_C)
-#include "mbedtls/threading.h"
-#endif
-
-#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
-#include "mbedtls/x509.h"
-#endif
-
-#if defined(MBEDTLS_XTEA_C)
-#include "mbedtls/xtea.h"
-#endif
-
-
-// Error code table type
-struct ssl_errs {
-    int16_t errnum;
-    const char *errstr;
-};
-
-// Table of high level error codes
-static const struct ssl_errs mbedtls_high_level_error_tab[] = {
-// BEGIN generated code
-#if defined(MBEDTLS_CIPHER_C)
-        { -(MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE), "CIPHER_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA), "CIPHER_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_CIPHER_ALLOC_FAILED), "CIPHER_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_CIPHER_INVALID_PADDING), "CIPHER_INVALID_PADDING" },
-        { -(MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED), "CIPHER_FULL_BLOCK_EXPECTED" },
-        { -(MBEDTLS_ERR_CIPHER_AUTH_FAILED), "CIPHER_AUTH_FAILED" },
-        { -(MBEDTLS_ERR_CIPHER_INVALID_CONTEXT), "CIPHER_INVALID_CONTEXT" },
-        { -(MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED), "CIPHER_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_CIPHER_C */
-
-#if defined(MBEDTLS_DHM_C)
-        { -(MBEDTLS_ERR_DHM_BAD_INPUT_DATA), "DHM_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_DHM_READ_PARAMS_FAILED), "DHM_READ_PARAMS_FAILED" },
-        { -(MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED), "DHM_MAKE_PARAMS_FAILED" },
-        { -(MBEDTLS_ERR_DHM_READ_PUBLIC_FAILED), "DHM_READ_PUBLIC_FAILED" },
-        { -(MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED), "DHM_MAKE_PUBLIC_FAILED" },
-        { -(MBEDTLS_ERR_DHM_CALC_SECRET_FAILED), "DHM_CALC_SECRET_FAILED" },
-        { -(MBEDTLS_ERR_DHM_INVALID_FORMAT), "DHM_INVALID_FORMAT" },
-        { -(MBEDTLS_ERR_DHM_ALLOC_FAILED), "DHM_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_DHM_FILE_IO_ERROR), "DHM_FILE_IO_ERROR" },
-        { -(MBEDTLS_ERR_DHM_HW_ACCEL_FAILED), "DHM_HW_ACCEL_FAILED" },
-        { -(MBEDTLS_ERR_DHM_SET_GROUP_FAILED), "DHM_SET_GROUP_FAILED" },
-#endif /* MBEDTLS_DHM_C */
-
-#if defined(MBEDTLS_ECP_C)
-        { -(MBEDTLS_ERR_ECP_BAD_INPUT_DATA), "ECP_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL), "ECP_BUFFER_TOO_SMALL" },
-        { -(MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE), "ECP_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_ECP_VERIFY_FAILED), "ECP_VERIFY_FAILED" },
-        { -(MBEDTLS_ERR_ECP_ALLOC_FAILED), "ECP_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_ECP_RANDOM_FAILED), "ECP_RANDOM_FAILED" },
-        { -(MBEDTLS_ERR_ECP_INVALID_KEY), "ECP_INVALID_KEY" },
-        { -(MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH), "ECP_SIG_LEN_MISMATCH" },
-        { -(MBEDTLS_ERR_ECP_HW_ACCEL_FAILED), "ECP_HW_ACCEL_FAILED" },
-        { -(MBEDTLS_ERR_ECP_IN_PROGRESS), "ECP_IN_PROGRESS" },
-#endif /* MBEDTLS_ECP_C */
-
-#if defined(MBEDTLS_MD_C)
-        { -(MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE), "MD_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_MD_BAD_INPUT_DATA), "MD_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_MD_ALLOC_FAILED), "MD_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_MD_FILE_IO_ERROR), "MD_FILE_IO_ERROR" },
-        { -(MBEDTLS_ERR_MD_HW_ACCEL_FAILED), "MD_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_MD_C */
-
-#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
-        { -(MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT), "PEM_NO_HEADER_FOOTER_PRESENT" },
-        { -(MBEDTLS_ERR_PEM_INVALID_DATA), "PEM_INVALID_DATA" },
-        { -(MBEDTLS_ERR_PEM_ALLOC_FAILED), "PEM_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_PEM_INVALID_ENC_IV), "PEM_INVALID_ENC_IV" },
-        { -(MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG), "PEM_UNKNOWN_ENC_ALG" },
-        { -(MBEDTLS_ERR_PEM_PASSWORD_REQUIRED), "PEM_PASSWORD_REQUIRED" },
-        { -(MBEDTLS_ERR_PEM_PASSWORD_MISMATCH), "PEM_PASSWORD_MISMATCH" },
-        { -(MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE), "PEM_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_PEM_BAD_INPUT_DATA), "PEM_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_PEM_PARSE_C || MBEDTLS_PEM_WRITE_C */
-
-#if defined(MBEDTLS_PK_C)
-        { -(MBEDTLS_ERR_PK_ALLOC_FAILED), "PK_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_PK_TYPE_MISMATCH), "PK_TYPE_MISMATCH" },
-        { -(MBEDTLS_ERR_PK_BAD_INPUT_DATA), "PK_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_PK_FILE_IO_ERROR), "PK_FILE_IO_ERROR" },
-        { -(MBEDTLS_ERR_PK_KEY_INVALID_VERSION), "PK_KEY_INVALID_VERSION" },
-        { -(MBEDTLS_ERR_PK_KEY_INVALID_FORMAT), "PK_KEY_INVALID_FORMAT" },
-        { -(MBEDTLS_ERR_PK_UNKNOWN_PK_ALG), "PK_UNKNOWN_PK_ALG" },
-        { -(MBEDTLS_ERR_PK_PASSWORD_REQUIRED), "PK_PASSWORD_REQUIRED" },
-        { -(MBEDTLS_ERR_PK_PASSWORD_MISMATCH), "PK_PASSWORD_MISMATCH" },
-        { -(MBEDTLS_ERR_PK_INVALID_PUBKEY), "PK_INVALID_PUBKEY" },
-        { -(MBEDTLS_ERR_PK_INVALID_ALG), "PK_INVALID_ALG" },
-        { -(MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE), "PK_UNKNOWN_NAMED_CURVE" },
-        { -(MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE), "PK_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_PK_SIG_LEN_MISMATCH), "PK_SIG_LEN_MISMATCH" },
-        { -(MBEDTLS_ERR_PK_HW_ACCEL_FAILED), "PK_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_PK_C */
-
-#if defined(MBEDTLS_PKCS12_C)
-        { -(MBEDTLS_ERR_PKCS12_BAD_INPUT_DATA), "PKCS12_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE), "PKCS12_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT), "PKCS12_PBE_INVALID_FORMAT" },
-        { -(MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH), "PKCS12_PASSWORD_MISMATCH" },
-#endif /* MBEDTLS_PKCS12_C */
-
-#if defined(MBEDTLS_PKCS5_C)
-        { -(MBEDTLS_ERR_PKCS5_BAD_INPUT_DATA), "PKCS5_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_PKCS5_INVALID_FORMAT), "PKCS5_INVALID_FORMAT" },
-        { -(MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE), "PKCS5_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH), "PKCS5_PASSWORD_MISMATCH" },
-#endif /* MBEDTLS_PKCS5_C */
-
-#if defined(MBEDTLS_RSA_C)
-        { -(MBEDTLS_ERR_RSA_BAD_INPUT_DATA), "RSA_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_RSA_INVALID_PADDING), "RSA_INVALID_PADDING" },
-        { -(MBEDTLS_ERR_RSA_KEY_GEN_FAILED), "RSA_KEY_GEN_FAILED" },
-        { -(MBEDTLS_ERR_RSA_KEY_CHECK_FAILED), "RSA_KEY_CHECK_FAILED" },
-        { -(MBEDTLS_ERR_RSA_PUBLIC_FAILED), "RSA_PUBLIC_FAILED" },
-        { -(MBEDTLS_ERR_RSA_PRIVATE_FAILED), "RSA_PRIVATE_FAILED" },
-        { -(MBEDTLS_ERR_RSA_VERIFY_FAILED), "RSA_VERIFY_FAILED" },
-        { -(MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE), "RSA_OUTPUT_TOO_LARGE" },
-        { -(MBEDTLS_ERR_RSA_RNG_FAILED), "RSA_RNG_FAILED" },
-        { -(MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION), "RSA_UNSUPPORTED_OPERATION" },
-        { -(MBEDTLS_ERR_RSA_HW_ACCEL_FAILED), "RSA_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_RSA_C */
-
-#if defined(MBEDTLS_SSL_TLS_C)
-        { -(MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE), "SSL_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_SSL_BAD_INPUT_DATA), "SSL_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_SSL_INVALID_MAC), "SSL_INVALID_MAC" },
-        { -(MBEDTLS_ERR_SSL_INVALID_RECORD), "SSL_INVALID_RECORD" },
-        { -(MBEDTLS_ERR_SSL_CONN_EOF), "SSL_CONN_EOF" },
-        { -(MBEDTLS_ERR_SSL_UNKNOWN_CIPHER), "SSL_UNKNOWN_CIPHER" },
-        { -(MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN), "SSL_NO_CIPHER_CHOSEN" },
-        { -(MBEDTLS_ERR_SSL_NO_RNG), "SSL_NO_RNG" },
-        { -(MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE), "SSL_NO_CLIENT_CERTIFICATE" },
-        { -(MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE), "SSL_CERTIFICATE_TOO_LARGE" },
-        { -(MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED), "SSL_CERTIFICATE_REQUIRED" },
-        { -(MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED), "SSL_PRIVATE_KEY_REQUIRED" },
-        { -(MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED), "SSL_CA_CHAIN_REQUIRED" },
-        { -(MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE), "SSL_UNEXPECTED_MESSAGE" },
-        { -(MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED), "SSL_PEER_VERIFY_FAILED" },
-        { -(MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY), "SSL_PEER_CLOSE_NOTIFY" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO), "SSL_BAD_HS_CLIENT_HELLO" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO), "SSL_BAD_HS_SERVER_HELLO" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE), "SSL_BAD_HS_CERTIFICATE" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST), "SSL_BAD_HS_CERTIFICATE_REQUEST" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE), "SSL_BAD_HS_SERVER_KEY_EXCHANGE" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE), "SSL_BAD_HS_SERVER_HELLO_DONE" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE), "SSL_BAD_HS_CLIENT_KEY_EXCHANGE" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP), "SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS), "SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY), "SSL_BAD_HS_CERTIFICATE_VERIFY" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC), "SSL_BAD_HS_CHANGE_CIPHER_SPEC" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_FINISHED), "SSL_BAD_HS_FINISHED" },
-        { -(MBEDTLS_ERR_SSL_ALLOC_FAILED), "SSL_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_SSL_HW_ACCEL_FAILED), "SSL_HW_ACCEL_FAILED" },
-        { -(MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH), "SSL_HW_ACCEL_FALLTHROUGH" },
-        { -(MBEDTLS_ERR_SSL_COMPRESSION_FAILED), "SSL_COMPRESSION_FAILED" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION), "SSL_BAD_HS_PROTOCOL_VERSION" },
-        { -(MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET), "SSL_BAD_HS_NEW_SESSION_TICKET" },
-        { -(MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED), "SSL_SESSION_TICKET_EXPIRED" },
-        { -(MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH), "SSL_PK_TYPE_MISMATCH" },
-        { -(MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY), "SSL_UNKNOWN_IDENTITY" },
-        { -(MBEDTLS_ERR_SSL_INTERNAL_ERROR), "SSL_INTERNAL_ERROR" },
-        { -(MBEDTLS_ERR_SSL_COUNTER_WRAPPING), "SSL_COUNTER_WRAPPING" },
-        { -(MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO), "SSL_WAITING_SERVER_HELLO_RENEGO" },
-        { -(MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED), "SSL_HELLO_VERIFY_REQUIRED" },
-        { -(MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL), "SSL_BUFFER_TOO_SMALL" },
-        { -(MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE), "SSL_NO_USABLE_CIPHERSUITE" },
-        { -(MBEDTLS_ERR_SSL_WANT_READ), "SSL_WANT_READ" },
-        { -(MBEDTLS_ERR_SSL_WANT_WRITE), "SSL_WANT_WRITE" },
-        { -(MBEDTLS_ERR_SSL_TIMEOUT), "SSL_TIMEOUT" },
-        { -(MBEDTLS_ERR_SSL_CLIENT_RECONNECT), "SSL_CLIENT_RECONNECT" },
-        { -(MBEDTLS_ERR_SSL_UNEXPECTED_RECORD), "SSL_UNEXPECTED_RECORD" },
-        { -(MBEDTLS_ERR_SSL_NON_FATAL), "SSL_NON_FATAL" },
-        { -(MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH), "SSL_INVALID_VERIFY_HASH" },
-        { -(MBEDTLS_ERR_SSL_CONTINUE_PROCESSING), "SSL_CONTINUE_PROCESSING" },
-        { -(MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS), "SSL_ASYNC_IN_PROGRESS" },
-        { -(MBEDTLS_ERR_SSL_EARLY_MESSAGE), "SSL_EARLY_MESSAGE" },
-        { -(MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS), "SSL_CRYPTO_IN_PROGRESS" },
-#endif /* MBEDTLS_SSL_TLS_C */
-
-#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
-        { -(MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE), "X509_FEATURE_UNAVAILABLE" },
-        { -(MBEDTLS_ERR_X509_UNKNOWN_OID), "X509_UNKNOWN_OID" },
-        { -(MBEDTLS_ERR_X509_INVALID_FORMAT), "X509_INVALID_FORMAT" },
-        { -(MBEDTLS_ERR_X509_INVALID_VERSION), "X509_INVALID_VERSION" },
-        { -(MBEDTLS_ERR_X509_INVALID_SERIAL), "X509_INVALID_SERIAL" },
-        { -(MBEDTLS_ERR_X509_INVALID_ALG), "X509_INVALID_ALG" },
-        { -(MBEDTLS_ERR_X509_INVALID_NAME), "X509_INVALID_NAME" },
-        { -(MBEDTLS_ERR_X509_INVALID_DATE), "X509_INVALID_DATE" },
-        { -(MBEDTLS_ERR_X509_INVALID_SIGNATURE), "X509_INVALID_SIGNATURE" },
-        { -(MBEDTLS_ERR_X509_INVALID_EXTENSIONS), "X509_INVALID_EXTENSIONS" },
-        { -(MBEDTLS_ERR_X509_UNKNOWN_VERSION), "X509_UNKNOWN_VERSION" },
-        { -(MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG), "X509_UNKNOWN_SIG_ALG" },
-        { -(MBEDTLS_ERR_X509_SIG_MISMATCH), "X509_SIG_MISMATCH" },
-        { -(MBEDTLS_ERR_X509_CERT_VERIFY_FAILED), "X509_CERT_VERIFY_FAILED" },
-        { -(MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT), "X509_CERT_UNKNOWN_FORMAT" },
-        { -(MBEDTLS_ERR_X509_BAD_INPUT_DATA), "X509_BAD_INPUT_DATA" },
-        { -(MBEDTLS_ERR_X509_ALLOC_FAILED), "X509_ALLOC_FAILED" },
-        { -(MBEDTLS_ERR_X509_FILE_IO_ERROR), "X509_FILE_IO_ERROR" },
-        { -(MBEDTLS_ERR_X509_BUFFER_TOO_SMALL), "X509_BUFFER_TOO_SMALL" },
-        { -(MBEDTLS_ERR_X509_FATAL_ERROR), "X509_FATAL_ERROR" },
-#endif /* MBEDTLS_X509_USE_C || MBEDTLS_X509_CREATE_C */
-// END generated code
-};
-
-static const struct ssl_errs mbedtls_low_level_error_tab[] = {
-// Low level error codes
-//
-// BEGIN generated code
-#if defined(MBEDTLS_AES_C)
-    { -(MBEDTLS_ERR_AES_INVALID_KEY_LENGTH), "AES_INVALID_KEY_LENGTH" },
-    { -(MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH), "AES_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_AES_BAD_INPUT_DATA), "AES_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE), "AES_FEATURE_UNAVAILABLE" },
-    { -(MBEDTLS_ERR_AES_HW_ACCEL_FAILED), "AES_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_AES_C */
-
-#if defined(MBEDTLS_ARC4_C)
-    { -(MBEDTLS_ERR_ARC4_HW_ACCEL_FAILED), "ARC4_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_ARC4_C */
-
-#if defined(MBEDTLS_ARIA_C)
-    { -(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA), "ARIA_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_ARIA_INVALID_INPUT_LENGTH), "ARIA_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_ARIA_FEATURE_UNAVAILABLE), "ARIA_FEATURE_UNAVAILABLE" },
-    { -(MBEDTLS_ERR_ARIA_HW_ACCEL_FAILED), "ARIA_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_ARIA_C */
-
-#if defined(MBEDTLS_ASN1_PARSE_C)
-    { -(MBEDTLS_ERR_ASN1_OUT_OF_DATA), "ASN1_OUT_OF_DATA" },
-    { -(MBEDTLS_ERR_ASN1_UNEXPECTED_TAG), "ASN1_UNEXPECTED_TAG" },
-    { -(MBEDTLS_ERR_ASN1_INVALID_LENGTH), "ASN1_INVALID_LENGTH" },
-    { -(MBEDTLS_ERR_ASN1_LENGTH_MISMATCH), "ASN1_LENGTH_MISMATCH" },
-    { -(MBEDTLS_ERR_ASN1_INVALID_DATA), "ASN1_INVALID_DATA" },
-    { -(MBEDTLS_ERR_ASN1_ALLOC_FAILED), "ASN1_ALLOC_FAILED" },
-    { -(MBEDTLS_ERR_ASN1_BUF_TOO_SMALL), "ASN1_BUF_TOO_SMALL" },
-#endif /* MBEDTLS_ASN1_PARSE_C */
-
-#if defined(MBEDTLS_BASE64_C)
-    { -(MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL), "BASE64_BUFFER_TOO_SMALL" },
-    { -(MBEDTLS_ERR_BASE64_INVALID_CHARACTER), "BASE64_INVALID_CHARACTER" },
-#endif /* MBEDTLS_BASE64_C */
-
-#if defined(MBEDTLS_BIGNUM_C)
-    { -(MBEDTLS_ERR_MPI_FILE_IO_ERROR), "MPI_FILE_IO_ERROR" },
-    { -(MBEDTLS_ERR_MPI_BAD_INPUT_DATA), "MPI_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_MPI_INVALID_CHARACTER), "MPI_INVALID_CHARACTER" },
-    { -(MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL), "MPI_BUFFER_TOO_SMALL" },
-    { -(MBEDTLS_ERR_MPI_NEGATIVE_VALUE), "MPI_NEGATIVE_VALUE" },
-    { -(MBEDTLS_ERR_MPI_DIVISION_BY_ZERO), "MPI_DIVISION_BY_ZERO" },
-    { -(MBEDTLS_ERR_MPI_NOT_ACCEPTABLE), "MPI_NOT_ACCEPTABLE" },
-    { -(MBEDTLS_ERR_MPI_ALLOC_FAILED), "MPI_ALLOC_FAILED" },
-#endif /* MBEDTLS_BIGNUM_C */
-
-#if defined(MBEDTLS_BLOWFISH_C)
-    { -(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA), "BLOWFISH_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_BLOWFISH_INVALID_INPUT_LENGTH), "BLOWFISH_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_BLOWFISH_HW_ACCEL_FAILED), "BLOWFISH_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_BLOWFISH_C */
-
-#if defined(MBEDTLS_CAMELLIA_C)
-    { -(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA), "CAMELLIA_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH), "CAMELLIA_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_CAMELLIA_HW_ACCEL_FAILED), "CAMELLIA_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_CAMELLIA_C */
-
-#if defined(MBEDTLS_CCM_C)
-    { -(MBEDTLS_ERR_CCM_BAD_INPUT), "CCM_BAD_INPUT" },
-    { -(MBEDTLS_ERR_CCM_AUTH_FAILED), "CCM_AUTH_FAILED" },
-    { -(MBEDTLS_ERR_CCM_HW_ACCEL_FAILED), "CCM_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_CCM_C */
-
-#if defined(MBEDTLS_CHACHA20_C)
-    { -(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA), "CHACHA20_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_CHACHA20_FEATURE_UNAVAILABLE), "CHACHA20_FEATURE_UNAVAILABLE" },
-    { -(MBEDTLS_ERR_CHACHA20_HW_ACCEL_FAILED), "CHACHA20_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_CHACHA20_C */
-
-#if defined(MBEDTLS_CHACHAPOLY_C)
-    { -(MBEDTLS_ERR_CHACHAPOLY_BAD_STATE), "CHACHAPOLY_BAD_STATE" },
-    { -(MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED), "CHACHAPOLY_AUTH_FAILED" },
-#endif /* MBEDTLS_CHACHAPOLY_C */
-
-#if defined(MBEDTLS_CMAC_C)
-    { -(MBEDTLS_ERR_CMAC_HW_ACCEL_FAILED), "CMAC_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_CMAC_C */
-
-#if defined(MBEDTLS_CTR_DRBG_C)
-    { -(MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED), "CTR_DRBG_ENTROPY_SOURCE_FAILED" },
-    { -(MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG), "CTR_DRBG_REQUEST_TOO_BIG" },
-    { -(MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG), "CTR_DRBG_INPUT_TOO_BIG" },
-    { -(MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR), "CTR_DRBG_FILE_IO_ERROR" },
-#endif /* MBEDTLS_CTR_DRBG_C */
-
-#if defined(MBEDTLS_DES_C)
-    { -(MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH), "DES_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_DES_HW_ACCEL_FAILED), "DES_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_DES_C */
-
-#if defined(MBEDTLS_ENTROPY_C)
-    { -(MBEDTLS_ERR_ENTROPY_SOURCE_FAILED), "ENTROPY_SOURCE_FAILED" },
-    { -(MBEDTLS_ERR_ENTROPY_MAX_SOURCES), "ENTROPY_MAX_SOURCES" },
-    { -(MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED), "ENTROPY_NO_SOURCES_DEFINED" },
-    { -(MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE), "ENTROPY_NO_STRONG_SOURCE" },
-    { -(MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR), "ENTROPY_FILE_IO_ERROR" },
-#endif /* MBEDTLS_ENTROPY_C */
-
-#if defined(MBEDTLS_GCM_C)
-    { -(MBEDTLS_ERR_GCM_AUTH_FAILED), "GCM_AUTH_FAILED" },
-    { -(MBEDTLS_ERR_GCM_HW_ACCEL_FAILED), "GCM_HW_ACCEL_FAILED" },
-    { -(MBEDTLS_ERR_GCM_BAD_INPUT), "GCM_BAD_INPUT" },
-#endif /* MBEDTLS_GCM_C */
-
-#if defined(MBEDTLS_HKDF_C)
-    { -(MBEDTLS_ERR_HKDF_BAD_INPUT_DATA), "HKDF_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_HKDF_C */
-
-#if defined(MBEDTLS_HMAC_DRBG_C)
-    { -(MBEDTLS_ERR_HMAC_DRBG_REQUEST_TOO_BIG), "HMAC_DRBG_REQUEST_TOO_BIG" },
-    { -(MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG), "HMAC_DRBG_INPUT_TOO_BIG" },
-    { -(MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR), "HMAC_DRBG_FILE_IO_ERROR" },
-    { -(MBEDTLS_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED), "HMAC_DRBG_ENTROPY_SOURCE_FAILED" },
-#endif /* MBEDTLS_HMAC_DRBG_C */
-
-#if defined(MBEDTLS_MD2_C)
-    { -(MBEDTLS_ERR_MD2_HW_ACCEL_FAILED), "MD2_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_MD2_C */
-
-#if defined(MBEDTLS_MD4_C)
-    { -(MBEDTLS_ERR_MD4_HW_ACCEL_FAILED), "MD4_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_MD4_C */
-
-#if defined(MBEDTLS_MD5_C)
-    { -(MBEDTLS_ERR_MD5_HW_ACCEL_FAILED), "MD5_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_MD5_C */
-
-#if defined(MBEDTLS_NET_C)
-    { -(MBEDTLS_ERR_NET_SOCKET_FAILED), "NET_SOCKET_FAILED" },
-    { -(MBEDTLS_ERR_NET_CONNECT_FAILED), "NET_CONNECT_FAILED" },
-    { -(MBEDTLS_ERR_NET_BIND_FAILED), "NET_BIND_FAILED" },
-    { -(MBEDTLS_ERR_NET_LISTEN_FAILED), "NET_LISTEN_FAILED" },
-    { -(MBEDTLS_ERR_NET_ACCEPT_FAILED), "NET_ACCEPT_FAILED" },
-    { -(MBEDTLS_ERR_NET_RECV_FAILED), "NET_RECV_FAILED" },
-    { -(MBEDTLS_ERR_NET_SEND_FAILED), "NET_SEND_FAILED" },
-    { -(MBEDTLS_ERR_NET_CONN_RESET), "NET_CONN_RESET" },
-    { -(MBEDTLS_ERR_NET_UNKNOWN_HOST), "NET_UNKNOWN_HOST" },
-    { -(MBEDTLS_ERR_NET_BUFFER_TOO_SMALL), "NET_BUFFER_TOO_SMALL" },
-    { -(MBEDTLS_ERR_NET_INVALID_CONTEXT), "NET_INVALID_CONTEXT" },
-    { -(MBEDTLS_ERR_NET_POLL_FAILED), "NET_POLL_FAILED" },
-    { -(MBEDTLS_ERR_NET_BAD_INPUT_DATA), "NET_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_NET_C */
-
-#if defined(MBEDTLS_OID_C)
-    { -(MBEDTLS_ERR_OID_NOT_FOUND), "OID_NOT_FOUND" },
-    { -(MBEDTLS_ERR_OID_BUF_TOO_SMALL), "OID_BUF_TOO_SMALL" },
-#endif /* MBEDTLS_OID_C */
-
-#if defined(MBEDTLS_PADLOCK_C)
-    { -(MBEDTLS_ERR_PADLOCK_DATA_MISALIGNED), "PADLOCK_DATA_MISALIGNED" },
-#endif /* MBEDTLS_PADLOCK_C */
-
-#if defined(MBEDTLS_PLATFORM_C)
-    { -(MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED), "PLATFORM_HW_ACCEL_FAILED" },
-    { -(MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED), "PLATFORM_FEATURE_UNSUPPORTED" },
-#endif /* MBEDTLS_PLATFORM_C */
-
-#if defined(MBEDTLS_POLY1305_C)
-    { -(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA), "POLY1305_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_POLY1305_FEATURE_UNAVAILABLE), "POLY1305_FEATURE_UNAVAILABLE" },
-    { -(MBEDTLS_ERR_POLY1305_HW_ACCEL_FAILED), "POLY1305_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_POLY1305_C */
-
-#if defined(MBEDTLS_RIPEMD160_C)
-    { -(MBEDTLS_ERR_RIPEMD160_HW_ACCEL_FAILED), "RIPEMD160_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_RIPEMD160_C */
-
-#if defined(MBEDTLS_SHA1_C)
-    { -(MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED), "SHA1_HW_ACCEL_FAILED" },
-    { -(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA), "SHA1_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_SHA1_C */
-
-#if defined(MBEDTLS_SHA256_C)
-    { -(MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED), "SHA256_HW_ACCEL_FAILED" },
-    { -(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA), "SHA256_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_SHA256_C */
-
-#if defined(MBEDTLS_SHA512_C)
-    { -(MBEDTLS_ERR_SHA512_HW_ACCEL_FAILED), "SHA512_HW_ACCEL_FAILED" },
-    { -(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA), "SHA512_BAD_INPUT_DATA" },
-#endif /* MBEDTLS_SHA512_C */
-
-#if defined(MBEDTLS_THREADING_C)
-    { -(MBEDTLS_ERR_THREADING_FEATURE_UNAVAILABLE), "THREADING_FEATURE_UNAVAILABLE" },
-    { -(MBEDTLS_ERR_THREADING_BAD_INPUT_DATA), "THREADING_BAD_INPUT_DATA" },
-    { -(MBEDTLS_ERR_THREADING_MUTEX_ERROR), "THREADING_MUTEX_ERROR" },
-#endif /* MBEDTLS_THREADING_C */
-
-#if defined(MBEDTLS_XTEA_C)
-    { -(MBEDTLS_ERR_XTEA_INVALID_INPUT_LENGTH), "XTEA_INVALID_INPUT_LENGTH" },
-    { -(MBEDTLS_ERR_XTEA_HW_ACCEL_FAILED), "XTEA_HW_ACCEL_FAILED" },
-#endif /* MBEDTLS_XTEA_C */
-// END generated code
-};
-
-static const char *mbedtls_err_prefix = "MBEDTLS_ERR_";
-#define MBEDTLS_ERR_PREFIX_LEN ( sizeof("MBEDTLS_ERR_")-1 )
-
-// copy error text into buffer, ensure null termination, return strlen of result
-static size_t mbedtls_err_to_str(int err, const struct ssl_errs tab[], int tab_len, char *buf, size_t buflen) {
-    if (buflen == 0) return 0;
-
-    // prefix for all error names
-    strncpy(buf, mbedtls_err_prefix, buflen);
-    if (buflen <= MBEDTLS_ERR_PREFIX_LEN+1) {
-        buf[buflen-1] = 0;
-        return buflen-1;
-    }
-
-    // append error name from table
-    for (int i = 0; i < tab_len; i++) {
-        if (tab[i].errnum == err) {
-            strncpy(buf+MBEDTLS_ERR_PREFIX_LEN, tab[i].errstr, buflen-MBEDTLS_ERR_PREFIX_LEN);
-            buf[buflen-1] = 0;
-            return strlen(buf);
-        }
-    }
-
-    mbedtls_snprintf(buf+MBEDTLS_ERR_PREFIX_LEN, buflen-MBEDTLS_ERR_PREFIX_LEN, "UNKNOWN (0x%04X)",
-            err);
-    return strlen(buf);
-}
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-void mbedtls_strerror(int ret, char *buf, size_t buflen) {
-    int use_ret;
-
-    if (buflen == 0) return;
-
-    buf[buflen-1] = 0;
-
-    if (ret < 0) ret = -ret;
-
-    //
-    // High-level error codes
-    //
-    uint8_t got_hl = (ret & 0xFF80) != 0;
-    if (got_hl) {
-        use_ret = ret & 0xFF80;
-
-        // special case
-#if defined(MBEDTLS_SSL_TLS_C)
-        if (use_ret == -(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE)) {
-            strncpy(buf, "MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE", buflen);
-            buf[buflen-1] = 0;
-            return;
-        }
-#endif
-
-        size_t len = mbedtls_err_to_str(use_ret, mbedtls_high_level_error_tab,
-                ARRAY_SIZE(mbedtls_high_level_error_tab), buf, buflen);
-
-        buf += len;
-        buflen -= len;
-        if (buflen == 0) return;
-    }
-
-    //
-    // Low-level error codes
-    //
-    use_ret = ret & ~0xFF80;
-
-    if (use_ret == 0) return;
-
-    // If high level code is present, make a concatenation between both error strings.
-    if (got_hl) {
-        if (buflen < 2) return;
-        *buf++ = '+';
-        buflen--;
-    }
-
-    mbedtls_err_to_str(use_ret, mbedtls_low_level_error_tab,
-            ARRAY_SIZE(mbedtls_low_level_error_tab), buf, buflen);
-}
-
-#else /* MBEDTLS_ERROR_C */
-
-#if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
-
-/*
- * Provide an non-function in case MBEDTLS_ERROR_C is not defined
- */
-void mbedtls_strerror( int ret, char *buf, size_t buflen )
-{
-    ((void) ret);
-
-    if( buflen > 0 )
-        buf[0] = '\0';
-}
-
-#endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
-
-#endif /* MBEDTLS_ERROR_C */

lib/mbedtls_errors/tester.c

@@ -1,58 +0,0 @@
-#include "mbedtls/error.h"
-#include <string.h>
-#include <stdio.h>
-
-// test_code checks that the provided code results in the provided error string for any size
-// buffer. It calls mbedtls_strerror() to fill a buffer that is from 1 to 100 bytes in length
-// and then checks that the buffer contents is OK and that a few guard bytes before and after
-// the buffer were not overwritten.
-int test_code(int code, char *str) {
-    char buf[100];
-    int ok = 1;
-    int res;
-
-    // test zero-length buffer
-    memset(buf, -3, 100);
-    mbedtls_strerror(code, buf + 4, 0);
-    for (int i = 0; i < 10; i++) {
-        if (buf[i] != -3) {
-            printf("Error: guard overwritten buflen=0 i=%d buf[i]=%d\n", i, buf[i]);
-            ok = 0;
-        }
-    }
-
-    // test
-    for (size_t buflen = 1; buflen < 90; buflen++) {
-        memset(buf, -3, 100);
-        mbedtls_strerror(code, buf + 4, buflen);
-        for (int i = 0; i < 4; i++) {
-            if (buf[i] != -3) {
-                printf("Error: pre-guard overwritten buflen=%d i=%d buf[i]=%d\n", buflen, i, buf[i]);
-                ok = 0;
-            }
-        }
-        for (int i = 4 + buflen; i < 100; i++) {
-            if (buf[i] != -3) {
-                printf("Error: post-guard overwritten buflen=%d i=%d buf[i]=%d\n", buflen, i, buf[i]);
-                ok = 0;
-            }
-        }
-        char exp[100];
-        strncpy(exp, str, buflen);
-        exp[buflen - 1] = 0;
-        if (strcmp(buf + 4, exp) != 0) {
-            printf("Error: expected %s, got %s\n", exp, buf);
-            ok = 0;
-        }
-    }
-
-    printf("Test %x -> %s is %s\n", code, str, ok?"OK":"*** BAD ***");
-}
-
-int main() {
-    test_code(0x7200, "MBEDTLS_ERR_SSL_INVALID_RECORD");
-    test_code(0x7780, "MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE");
-    test_code(0x0074, "MBEDTLS_ERR_SHA256_BAD_INPUT_DATA");
-    test_code(0x6600 | 0x0074, "MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH+MBEDTLS_ERR_SHA256_BAD_INPUT_DATA");
-    test_code(103, "MBEDTLS_ERR_UNKNOWN (0x0067)");
-}

lib/re1.5/charclass.c

@@ -6,7 +6,15 @@ int _re1_5_classmatch(const char *pc, const char *sp)
     int is_positive = (pc[-1] == Class);
     int cnt = *pc++;
     while (cnt--) {
-        if (*sp >= *pc && *sp <= pc[1]) return is_positive;
+        if (*pc == RE15_CLASS_NAMED_CLASS_INDICATOR) {
+            if (_re1_5_namedclassmatch(pc + 1, sp)) {
+                return is_positive;
+            }
+        } else {
+            if (*sp >= *pc && *sp <= pc[1]) {
+                return is_positive;
+            }
+        }
         pc += 2;
     }
     return !is_positive;

lib/re1.5/compilecode.c

@@ -4,6 +4,9 @@
 
 #include "re1.5.h"
 
+// Matches: DSWdsw
+#define MATCH_NAMED_CLASS_CHAR(c) (((c) | 0x20) == 'd' || ((c) | 0x24) == 'w')
+
 #define INSERT_CODE(at, num, pc) \
     ((code ? memmove(code + at + num, code + at, pc - at) : 0), pc += num)
 #define REL(at, to) (to - at - 2)
@@ -11,28 +14,6 @@
 #define EMIT_CHECKED(at, byte) (_emit_checked(at, code, byte, &err))
 #define PC (prog->bytelen)
 
-static char unescape(char c) {
-    switch (c) {
-        case 'a':
-            return '\a';
-        case 'b':
-            return '\b';
-        case 'f':
-            return '\f';
-        case 'n':
-            return '\n';
-        case 'r':
-            return '\r';
-        case 't':
-            return '\t';
-        case 'v':
-            return '\v';
-        default:
-            return c;
-    }
-}
-
-
 static void _emit_checked(int at, char *code, int val, bool *err) {
     *err |= val != (int8_t)val;
     if (code) {
@@ -53,16 +34,14 @@ static const char *_compilecode(const char *re, ByteProg *prog, int sizecode)
         case '\\':
             re++;
             if (!*re) return NULL; // Trailing backslash
-            term = PC;
+            if (MATCH_NAMED_CLASS_CHAR(*re)) {
-            if ((*re | 0x20) == 'd' || (*re | 0x20) == 's' || (*re | 0x20) == 'w') {
+                term = PC;
                 EMIT(PC++, NamedClass);
                 EMIT(PC++, *re);
-            } else {
+                prog->len++;
-                EMIT(PC++, Char);
+                break;
-                EMIT(PC++, unescape(*re));
             }
-            prog->len++;
+            MP_FALLTHROUGH
-            break;
         default:
             term = PC;
             EMIT(PC++, Char);
@@ -87,27 +66,25 @@ static const char *_compilecode(const char *re, ByteProg *prog, int sizecode)
             PC++; // Skip # of pair byte
             prog->len++;
             for (cnt = 0; *re != ']'; re++, cnt++) {
-                if (!*re) return NULL;
+                char c = *re;
-                const char *b = re;
+                if (c == '\\') {
-                if (*re == '\\') {
+                    ++re;
-                    re += 1;
+                    c = *re;
-                    if (!*re) return NULL; // Trailing backslash
+                    if (MATCH_NAMED_CLASS_CHAR(c)) {
-                    EMIT(PC++, unescape(*re));
+                        c = RE15_CLASS_NAMED_CLASS_INDICATOR;
-                } else {
+                        goto emit_char_pair;
-                    EMIT(PC++, *re);
+                    else {
+                        // CIRCUITPY TODO: handle unescape here again PR #1544
+                    }
                 }
+                if (!c) return NULL;
                 if (re[1] == '-' && re[2] != ']') {
                     re += 2;
-                } else {
-                    re = b;
-                }
-                if (*re == '\\') {
-                    re += 1;
-                    if (!*re) return NULL; // Trailing backslash
-                    EMIT(PC++, unescape(*re));
-                } else {
-                    EMIT(PC++, *re);
                 }
+            emit_char_pair:
+                EMIT(PC++, c);
+                EMIT(PC++, *re);
+                // CIRCUITPY TODO handle unescape here again PR #1544
             }
             EMIT_CHECKED(term + 1, cnt);
             break;
@@ -255,6 +232,7 @@ int re1_5_compilecode(ByteProg *prog, const char *re)
     return 0;
 }
 
+// CIRCUITPY debug as main program
 #if defined(DEBUG_COMPILECODE)
 #include <assert.h>
 void re1_5_fatal(char *x) {

lib/re1.5/re1.5.h

@@ -140,6 +140,7 @@ struct Subject {
 
 #define NON_ANCHORED_PREFIX 5
 #define HANDLE_ANCHORED(bytecode, is_anchored) ((is_anchored) ? (bytecode) + NON_ANCHORED_PREFIX : (bytecode))
+#define RE15_CLASS_NAMED_CLASS_INDICATOR 0
 
 int re1_5_backtrack(ByteProg*, Subject*, const char**, int, int);
 int re1_5_pikevm(ByteProg*, Subject*, const char**, int, int);

main.c

@@ -58,7 +58,6 @@
 #include "supervisor/shared/status_leds.h"
 #include "supervisor/shared/tick.h"
 #include "supervisor/shared/traceback.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/shared/workflow.h"
 #include "supervisor/usb.h"
 #include "supervisor/workflow.h"

mpy-cross/.gitignore

@@ -1,11 +0,0 @@
-# SPDX-FileCopyrightText: 2014 MicroPython & CircuitPython contributors (https://github.com/adafruit/circuitpython/graphs/contributors)
-#
-# SPDX-License-Identifier: MIT
-
-/build-*
-/mpy-cross
-/mpy-cross.static
-/mpy-cross.static.exe
-/mpy-cross.static-raspbian
-/mpy-cross.fuzz
-/pitools

mpy-cross/Makefile

@@ -1,24 +1,62 @@
-# SPDX-FileCopyrightText: 2014 MicroPython & CircuitPython contributors (https://github.com/adafruit/circuitpython/graphs/contributors)
+include ../py/mkenv.mk
-#
-# SPDX-License-Identifier: MIT
 
-# The following is a temporary hack to forefully undefine vars that might have
+# define main target
-# be defined by a calling Makefile (from recursive make).
+PROG = mpy-cross
-# TODO: Find a better way to be able to call this Makefile recursively.
+
-ifneq ($(findstring undefine,$(.FEATURES)),)
+# qstr definitions (must come before including py.mk)
-override undefine COPT
+QSTR_DEFS = qstrdefsport.h
-override undefine CFLAGS_EXTRA
+
-override undefine LDFLAGS_EXTRA
+# OS name, for simple autoconfig
-override undefine MICROPY_FORCE_32BIT
+UNAME_S := $(shell uname -s)
-override undefine CROSS_COMPILE
+
-override undefine FROZEN_DIR
+# include py core make definitions
-override undefine FROZEN_MPY_DIR
+include $(TOP)/py/py.mk
-override undefine USER_C_MODULES
+
-override undefine SRC_MOD
+INC += -I.
-override undefine BUILD
+INC += -I$(BUILD)
-override undefine PROG
+INC += -I$(TOP)
+
+# compiler settings
+CWARN = -Wall -Werror
+CWARN += -Wextra -Wno-unused-parameter -Wpointer-arith
+CFLAGS += $(INC) $(CWARN) -std=gnu99 $(COPT) $(CFLAGS_EXTRA)
+CFLAGS += -fdata-sections -ffunction-sections -fno-asynchronous-unwind-tables
+
+# Debugging/Optimization
+ifdef DEBUG
+CFLAGS += -g
+COPT = -O0
+else
+COPT = -Os #-DNDEBUG
 endif
 
-include mpy-cross.mk
+# On OSX, 'gcc' is a symlink to clang unless a real gcc is installed.
-CFLAGS += -g
+# The unix port of MicroPython on OSX must be compiled with clang,
-STRIP = :
+# while cross-compile ports require gcc, so we test here for OSX and
+# if necessary override the value of 'CC' set in py/mkenv.mk
+ifeq ($(UNAME_S),Darwin)
+CC = clang
+# Use clang syntax for map file
+LDFLAGS_ARCH = -Wl,-map,$@.map -Wl,-dead_strip
+else
+# Use gcc syntax for map file
+LDFLAGS_ARCH = -Wl,-Map=$@.map,--cref -Wl,--gc-sections
+endif
+LDFLAGS += $(LDFLAGS_MOD) $(LDFLAGS_ARCH) -lm $(LDFLAGS_EXTRA)
+
+# source files
+SRC_C = \
+	main.c \
+	gccollect.c \
+	shared/runtime/gchelper_generic.c \
+
+# Add fmode when compiling with mingw gcc
+COMPILER_TARGET := $(shell $(CC) -dumpmachine)
+ifneq (,$(findstring mingw,$(COMPILER_TARGET)))
+	SRC_C += ports/windows/fmode.c
+endif
+
+OBJ = $(PY_CORE_O)
+OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
+
+include $(TOP)/py/mkrules.mk

mpy-cross/main.c

@@ -73,8 +73,9 @@ STATIC int compile_and_save(const char *file, const char *output_file, const cha
         #endif
 
         mp_parse_tree_t parse_tree = mp_parse(lex, MP_PARSE_FILE_INPUT);
-        mp_module_context_t *ctx = m_new_obj(mp_module_context_t);
+        mp_compiled_module_t cm;
-        mp_compiled_module_t cm = mp_compile_to_raw_code(&parse_tree, source_name, false, ctx);
+        cm.context = m_new_obj(mp_module_context_t);
+        mp_compile_to_raw_code(&parse_tree, source_name, false, &cm);
 
         vstr_t vstr;
         vstr_init(&vstr, 16);
@@ -181,6 +182,15 @@ STATIC void pre_process_options(int argc, char **argv) {
     }
 }
 
+STATIC char *backslash_to_forwardslash(char *path) {
+    for (char *p = path; p != NULL && *p != '\0'; ++p) {
+        if (*p == '\\') {
+            *p = '/';
+        }
+    }
+    return path;
+}
+
 MP_NOINLINE int main_(int argc, char **argv) {
     mp_stack_set_limit(40000 * (sizeof(void *) / 4));
 
@@ -203,19 +213,9 @@ MP_NOINLINE int main_(int argc, char **argv) {
 
     // set default compiler configuration
     mp_dynamic_compiler.small_int_bits = 31;
-    #if defined(__i386__)
+    // don't support native emitter unless -march is specified
-    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X86;
-    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_X86;
-    #elif defined(__x86_64__)
-    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X64;
-    mp_dynamic_compiler.nlr_buf_num_regs = MAX(MICROPY_NLR_NUM_REGS_X64, MICROPY_NLR_NUM_REGS_X64_WIN);
-    #elif defined(__arm__) && !defined(__thumb2__)
-    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV6;
-    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
-    #else
     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_NONE;
     mp_dynamic_compiler.nlr_buf_num_regs = 0;
-    #endif
 
     const char *input_file = NULL;
     const char *output_file = NULL;
@@ -228,7 +228,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 a += 1;
             } else if (strcmp(argv[a], "--version") == 0) {
                 printf("CircuitPython " MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE
-                    "; mpy-cross emitting mpy v" MP_STRINGIFY(MPY_VERSION) "-CircuitPython\n");
+                    "; mpy-cross emitting mpy v" MP_STRINGIFY(MPY_VERSION) "." MP_STRINGIFY(MPY_SUB_VERSION) "\n");
                 return 0;
             } else if (strcmp(argv[a], "-v") == 0) {
                 mp_verbose_flag++;
@@ -251,7 +251,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                     exit(usage(argv));
                 }
                 a += 1;
-                source_file = argv[a];
+                source_file = backslash_to_forwardslash(argv[a]);
             } else if (strncmp(argv[a], "-msmall-int-bits=", sizeof("-msmall-int-bits=") - 1) == 0) {
                 char *end;
                 mp_dynamic_compiler.small_int_bits =
@@ -292,6 +292,20 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 } else if (strcmp(arch, "xtensawin") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_XTENSAWIN;
                     mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_XTENSAWIN;
+                } else if (strcmp(arch, "host") == 0) {
+                    #if defined(__i386__) || defined(_M_IX86)
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X86;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_X86;
+                    #elif defined(__x86_64__) || defined(_M_X64)
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X64;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MAX(MICROPY_NLR_NUM_REGS_X64, MICROPY_NLR_NUM_REGS_X64_WIN);
+                    #elif defined(__arm__) && !defined(__thumb2__)
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV6;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
+                    #else
+                    mp_printf(&mp_stderr_print, "unable to determine host architecture for -march=host\n");
+                    exit(1);
+                    #endif
                 } else {
                     return usage(argv);
                 }
@@ -303,7 +317,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 mp_printf(&mp_stderr_print, "multiple input files\n");
                 exit(1);
             }
-            input_file = argv[a];
+            input_file = backslash_to_forwardslash(argv[a]);
         }
     }
 
@@ -339,7 +353,3 @@ void nlr_jump_fail(void *val) {
     fprintf(stderr, "FATAL: uncaught NLR %p\n", val);
     exit(1);
 }
-
-void serial_write(const char *text) {
-    printf("%s", text);
-}

mpy-cross/mpconfigport.h

@@ -166,7 +166,7 @@ typedef long mp_off_t;
 #define MP_PLAT_PRINT_STRN(str, len) (void)0
 
 // We need to provide a declaration/definition of alloca()
-#ifdef __FreeBSD__
+#if defined(__FreeBSD__) || defined(__NetBSD__)
 #include <stdlib.h>
 #elif defined(_WIN32)
 #include <malloc.h>
@@ -182,6 +182,7 @@ typedef long mp_off_t;
 #define MP_ENDIANNESS_LITTLE        (1)
 #define NORETURN                    __declspec(noreturn)
 #define MP_NOINLINE                 __declspec(noinline)
+#define MP_ALWAYSINLINE             __forceinline
 #define MP_LIKELY(x)                (x)
 #define MP_UNLIKELY(x)              (x)
 #define MICROPY_PORT_CONSTANTS      { MP_ROM_QSTR(MP_QSTR_dummy), MP_ROM_PTR(NULL) }

mpy-cross/mpy-cross.vcxproj

@@ -24,7 +24,6 @@
     <PyBuildingMpyCross>True</PyBuildingMpyCross>
     <PyBuildDir>$(MSBuildThisFileDirectory)build\</PyBuildDir>
     <PyIncDirs>$(MSBuildThisFileDirectory)</PyIncDirs>
-    <PyTargetDir>$(MSBuildThisFileDirectory)</PyTargetDir>
     <PyMsvcDir>$(MSBuildThisFileDirectory)..\ports\windows\msvc\</PyMsvcDir>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

mpy-cross/mpy_cross/__init__.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2022 Andrew Leech
+# Copyright (c) 2022 Jim Mussared
+#
+# 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.
+
+from __future__ import print_function
+import os
+import re
+import stat
+import subprocess
+
+NATIVE_ARCHS = {
+    "NATIVE_ARCH_NONE": "",
+    "NATIVE_ARCH_X86": "x86",
+    "NATIVE_ARCH_X64": "x64",
+    "NATIVE_ARCH_ARMV6": "armv6",
+    "NATIVE_ARCH_ARMV6M": "armv6m",
+    "NATIVE_ARCH_ARMV7M": "armv7m",
+    "NATIVE_ARCH_ARMV7EM": "armv7em",
+    "NATIVE_ARCH_ARMV7EMSP": "armv7emsp",
+    "NATIVE_ARCH_ARMV7EMDP": "armv7emdp",
+    "NATIVE_ARCH_XTENSA": "xtensa",
+    "NATIVE_ARCH_XTENSAWIN": "xtensawin",
+}
+
+globals().update(NATIVE_ARCHS)
+
+__all__ = ["version", "compile", "run", "CrossCompileError"] + list(NATIVE_ARCHS.keys())
+
+
+class CrossCompileError(Exception):
+    pass
+
+
+_VERSION_RE = re.compile("mpy-cross emitting mpy v([0-9]+)(?:.([0-9]+))?")
+
+
+def _find_mpy_cross_binary(mpy_cross):
+    if mpy_cross:
+        return mpy_cross
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), "../build/mpy-cross"))
+
+
+def mpy_version(mpy_cross=None):
+    """
+    Get the version and sub-version of the .mpy file format generated by this version of mpy-cross.
+
+    Returns: A tuple of `(mpy_version, mpy_sub_version)`
+    Optional keyword arguments:
+     - mpy_cross: Specific mpy-cross binary to use
+    """
+    version_info = run(["--version"], mpy_cross=mpy_cross)
+    match = re.search(_VERSION_RE, version_info)
+    mpy_version, mpy_sub_version = int(match.group(1)), int(match.group(2) or "0")
+    return (
+        mpy_version,
+        mpy_sub_version,
+    )
+
+
+def compile(src, dest=None, src_path=None, opt=None, march=None, mpy_cross=None, extra_args=None):
+    """
+    Compile the specified .py file with mpy-cross.
+
+    Returns: Standard output from mpy-cross as a string.
+
+    Required arguments:
+     - src:        The path to the .py file
+
+    Optional keyword arguments:
+     - dest:       The output .mpy file. Defaults to `src` (with .mpy extension)
+     - src_path:   The path to embed in the .mpy file (defaults to `src`)
+     - opt:        Optimisation level (0-3, default 0)
+     - march:      One of the `NATIVE_ARCH_*` constants (defaults to NATIVE_ARCH_NONE)
+     - mpy_cross:  Specific mpy-cross binary to use
+     - extra_args: Additional arguments to pass to mpy-cross (e.g. `["-X", "emit=native"]`)
+    """
+    if not src:
+        raise ValueError("src is required")
+    if not os.path.exists(src):
+        raise CrossCompileError("Input .py file not found: {}.".format(src_py))
+
+    args = []
+
+    if src_path:
+        args += ["-s", src_path]
+
+    if dest:
+        args += ["-o", dest]
+
+    if march:
+        args += ["-march=" + march]
+
+    if opt is not None:
+        args += ["-O{}".format(opt)]
+
+    if extra_args:
+        args += extra_args
+
+    args += [src]
+
+    run(args, mpy_cross)
+
+
+def run(args, mpy_cross=None):
+    """
+    Run mpy-cross with the specified command line arguments.
+    Prefer to use `compile()` instead.
+
+    Returns: Standard output from mpy-cross as a string.
+
+    Optional keyword arguments:
+     - mpy_cross: Specific mpy-cross binary to use
+    """
+    mpy_cross = _find_mpy_cross_binary(mpy_cross)
+
+    if not os.path.exists(mpy_cross):
+        raise CrossCompileError("mpy-cross binary not found at {}.".format(mpy_cross))
+
+    try:
+        st = os.stat(mpy_cross)
+        os.chmod(mpy_cross, st.st_mode | stat.S_IEXEC)
+    except OSError:
+        pass
+
+    try:
+        return subprocess.check_output([mpy_cross] + args, stderr=subprocess.STDOUT).decode()
+    except subprocess.CalledProcessError as er:
+        raise CrossCompileError(er.output.decode())

mpy-cross/mpy_cross/__main__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2022 Andrew Leech
+# Copyright (c) 2022 Jim Mussared
+#
+# 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.
+
+from __future__ import print_function
+import argparse
+import sys
+
+from . import run, CrossCompileError
+
+try:
+    print(run(sys.argv[1:]))
+except CrossCompileError as er:
+    print(er.args[0], file=sys.stderr)
+    raise SystemExit(1)

ports/atmel-samd/common-hal/_pew/PewPew.c

@@ -35,7 +35,6 @@
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "shared-bindings/util.h"
 #include "samd/timers.h"
-#include "supervisor/shared/translate/translate.h"
 #include "timer_handler.h"
 
 

ports/atmel-samd/common-hal/analogio/AnalogIn.c

@@ -37,7 +37,6 @@
 #include "samd/adc.h"
 #include "shared-bindings/analogio/AnalogIn.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_adc_sync.h"

ports/atmel-samd/common-hal/analogio/AnalogOut.c

@@ -33,7 +33,6 @@
 #include "shared-bindings/analogio/AnalogOut.h"
 #include "shared-bindings/audioio/AudioOut.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_dac_sync.h"

ports/atmel-samd/common-hal/audiobusio/I2SOut.c

@@ -40,7 +40,6 @@
 #include "shared-bindings/audiobusio/I2SOut.h"
 #include "shared-bindings/audiocore/RawSample.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_gpio.h"

ports/atmel-samd/common-hal/audiobusio/PDMIn.c

@@ -37,7 +37,6 @@
 #include "shared-bindings/audiobusio/PDMIn.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_gpio.h"

ports/atmel-samd/common-hal/audioio/AudioOut.c

@@ -35,7 +35,6 @@
 #include "shared-bindings/audioio/AudioOut.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_gpio.h"

ports/atmel-samd/common-hal/busio/I2C.c

@@ -35,7 +35,6 @@
 #include "samd/sercom.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "common-hal/busio/__init__.h"
 

ports/atmel-samd/common-hal/busio/SPI.c

@@ -33,7 +33,6 @@
 #include "peripheral_clk_config.h"
 
 #include "supervisor/board.h"
-#include "supervisor/shared/translate/translate.h"
 #include "common-hal/busio/__init__.h"
 
 #include "hal/include/hal_gpio.h"

ports/atmel-samd/common-hal/busio/SPI.h

@@ -3,7 +3,11 @@
  *
  * The MIT License (MIT)
  *
+<<<<<<<< HEAD:ports/atmel-samd/common-hal/busio/SPI.h
  * Copyright (c) 2016 Scott Shawcroft
+========
+ * Copyright (c) 2022 Blake W. Felt & Angus Gratton
+>>>>>>>> v1.20.0:shared/tinyusb/mp_usbd.c
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,6 +28,7 @@
  * THE SOFTWARE.
  */
 
+<<<<<<<< HEAD:ports/atmel-samd/common-hal/busio/SPI.h
 #ifndef MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_SPI_H
 #define MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_SPI_H
 
@@ -43,3 +48,22 @@ typedef struct {
 } busio_spi_obj_t;
 
 #endif // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_SPI_H
+========
+#include <stdlib.h>
+
+#include "py/mpconfig.h"
+
+#if MICROPY_HW_ENABLE_USBDEV
+
+#ifndef NO_QSTR
+#include "tusb.h" // TinyUSB is not avaiable when running the string preprocessor
+#include "device/usbd.h"
+#include "device/usbd_pvt.h"
+#endif
+
+void usbd_task(void) {
+    tud_task_ext(0, false);
+}
+
+#endif
+>>>>>>>> v1.20.0:shared/tinyusb/mp_usbd.c

ports/atmel-samd/common-hal/busio/UART.c

@@ -35,7 +35,6 @@
 #include "py/mperrno.h"
 #include "py/runtime.h"
 #include "py/stream.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/shared/tick.h"
 
 #include "hpl_sercom_config.h"

ports/atmel-samd/common-hal/countio/Counter.c

@@ -7,7 +7,6 @@
 #include "eic_handler.h"
 #include "samd/external_interrupts.h"
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_countio_counter_construct(countio_counter_obj_t *self,
     const mcu_pin_obj_t *pin, countio_edge_t edge, digitalio_pull_t pull) {

ports/atmel-samd/common-hal/digitalio/DigitalInOut.c

@@ -34,7 +34,6 @@
 
 #include "common-hal/microcontroller/Pin.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
-#include "supervisor/shared/translate/translate.h"
 
 digitalinout_result_t common_hal_digitalio_digitalinout_construct(
     digitalio_digitalinout_obj_t *self, const mcu_pin_obj_t *pin) {

ports/atmel-samd/common-hal/frequencyio/FrequencyIn.c

@@ -48,7 +48,6 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/time/__init__.h"
 #include "supervisor/shared/tick.h"
-#include "supervisor/shared/translate/translate.h"
 
 #ifdef SAMD21
 #include "hpl/gclk/hpl_gclk_base.h"

ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h

@@ -3,7 +3,11 @@
  *
  * The MIT License (MIT)
  *
+<<<<<<<< HEAD:ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h
  * Copyright (c) 2018 Noralf Trønnes
+========
+ * Copyright (c) 2013, 2014 Damien P. George
+>>>>>>>> v1.20.0:ports/samd/pendsv.h
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +27,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#ifndef MICROPY_INCLUDED_SAMD_PENDSV_H
+#define MICROPY_INCLUDED_SAMD_PENDSV_H
 
+<<<<<<<< HEAD:ports/atmel-samd/common-hal/i2ctarget/I2CTarget.h
 #ifndef MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
 #define MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
 
@@ -43,3 +50,19 @@ typedef struct {
 } i2ctarget_i2c_target_obj_t;
 
 #endif // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_BUSIO_I2C_TARGET_H
+========
+enum {
+    PENDSV_DISPATCH_SOFT_TIMER,  // For later & for having at least one entry
+    MICROPY_BOARD_PENDSV_ENTRIES
+    PENDSV_DISPATCH_MAX
+};
+
+#define PENDSV_DISPATCH_NUM_SLOTS PENDSV_DISPATCH_MAX
+
+typedef void (*pendsv_dispatch_t)(void);
+
+void pendsv_init(void);
+void pendsv_schedule_dispatch(size_t slot, pendsv_dispatch_t f);
+
+#endif // MICROPY_INCLUDED_SAMD_PENDSV_H
+>>>>>>>> v1.20.0:ports/samd/pendsv.h

ports/atmel-samd/common-hal/microcontroller/Pin.c

@@ -27,7 +27,6 @@
 #include "py/runtime.h"
 
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "atmel_start_pins.h"
 #include "hal/include/hal_gpio.h"

ports/atmel-samd/common-hal/microcontroller/__init__.c

@@ -36,7 +36,6 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/microcontroller/Processor.h"
 #include "supervisor/shared/safe_mode.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_mcu_delay_us(uint32_t delay) {
     mp_hal_delay_us(delay);

ports/atmel-samd/common-hal/ps2io/Ps2.c

@@ -43,7 +43,6 @@
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/ps2io/Ps2.h"
 #include "supervisor/port.h"
-#include "supervisor/shared/translate/translate.h"
 
 #define STATE_IDLE 0
 #define STATE_RECV 1

ports/atmel-samd/common-hal/pulseio/PulseIn.c

@@ -44,7 +44,6 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/pulseio/PulseIn.h"
 #include "supervisor/shared/tick.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/port.h"
 
 // This timer is shared amongst all PulseIn objects as a higher resolution clock.

ports/atmel-samd/common-hal/pulseio/PulseOut.c

@@ -36,7 +36,6 @@
 #include "py/gc.h"
 #include "py/runtime.h"
 #include "shared-bindings/pulseio/PulseOut.h"
-#include "supervisor/shared/translate/translate.h"
 #include "timer_handler.h"
 
 // This timer is shared amongst all PulseOut objects under the assumption that

ports/atmel-samd/common-hal/pwmio/PWMOut.c

@@ -38,7 +38,6 @@
 #include "hal/utils/include/utils_repeat_macro.h"
 #include "samd/pins.h"
 #include "samd/timers.h"
-#include "supervisor/shared/translate/translate.h"
 
 #undef ENABLE
 

ports/atmel-samd/common-hal/rotaryio/IncrementalEncoder.c

@@ -33,7 +33,6 @@
 #include "eic_handler.h"
 #include "samd/external_interrupts.h"
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t *self,
     const mcu_pin_obj_t *pin_a, const mcu_pin_obj_t *pin_b) {

ports/atmel-samd/common-hal/rtc/RTC.c

@@ -37,7 +37,6 @@
 #include "shared-bindings/rtc/__init__.h"
 #include "shared-bindings/rtc/RTC.h"
 #include "supervisor/port.h"
-#include "supervisor/shared/translate/translate.h"
 
 // This is the time in seconds since 2000 that the RTC was started.
 // TODO: Change the offset to ticks so that it can be a subsecond adjustment.

ports/atmel-samd/common-hal/sdioio/SDCard.c

@@ -32,7 +32,6 @@
 #include "shared-bindings/sdioio/SDCard.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/microcontroller/__init__.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "genhdr/sdiodata.h"
 

ports/atmel-samd/common-hal/touchio/TouchIn.c

@@ -33,7 +33,6 @@
 #include "py/mphal.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/touchio/TouchIn.h"
-#include "supervisor/shared/translate/translate.h"
 
 // Native touchio only exists for SAMD21
 #ifdef SAMD21

ports/broadcom/common-hal/digitalio/DigitalInOut.c

@@ -32,7 +32,6 @@
 
 #include "common-hal/microcontroller/Pin.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "peripherals/broadcom/gpio.h"
 

ports/broadcom/common-hal/sdioio/SDCard.c

@@ -35,7 +35,6 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "supervisor/port.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "peripherals/broadcom/cpu.h"
 #include "peripherals/broadcom/defines.h"

ports/espressif/common-hal/analogio/AnalogIn.c

@@ -28,7 +28,6 @@
 #include "shared-bindings/analogio/AnalogIn.h"
 #include "py/mperrno.h"
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "components/driver/include/driver/adc_common.h"
 #include "components/esp_adc_cal/include/esp_adc_cal.h"

ports/espressif/common-hal/analogio/AnalogOut.c

@@ -33,7 +33,6 @@
 
 #include "shared-bindings/analogio/AnalogOut.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #if defined(CONFIG_IDF_TARGET_ESP32) || defined(CONFIG_IDF_TARGET_ESP32S2)
 #include "components/driver/include/driver/dac_common.h"

ports/espressif/common-hal/audiobusio/I2SOut.c

@@ -42,7 +42,6 @@
 #include "shared-bindings/audiobusio/I2SOut.h"
 #include "shared-bindings/audiocore/RawSample.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "driver/i2s.h"
 

ports/espressif/common-hal/busio/I2C.c

@@ -32,7 +32,6 @@
 
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
     const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda, uint32_t frequency, uint32_t timeout) {

ports/espressif/common-hal/busio/UART.c

@@ -38,7 +38,6 @@
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "supervisor/port.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/shared/tick.h"
 
 static uint8_t never_reset_uart_mask = 0;

ports/espressif/common-hal/countio/Counter.c

@@ -29,7 +29,6 @@
 #include "common-hal/microcontroller/Pin.h"
 
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_countio_counter_construct(countio_counter_obj_t *self,
     const mcu_pin_obj_t *pin, countio_edge_t edge, digitalio_pull_t pull) {

ports/espressif/common-hal/digitalio/DigitalInOut.c

@@ -26,7 +26,6 @@
 
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "components/driver/include/driver/gpio.h"
 

ports/espressif/common-hal/espidf/__init__.c

@@ -25,7 +25,6 @@
  */
 
 #include "bindings/espidf/__init__.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/memory.h"
 #include "py/runtime.h"
 

ports/espressif/common-hal/microcontroller/Processor.c

@@ -33,7 +33,6 @@
 #include "common-hal/microcontroller/Processor.h"
 #include "shared-bindings/microcontroller/Processor.h"
 #include "shared-bindings/microcontroller/ResetReason.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "esp_sleep.h"
 #include "esp_system.h"

ports/espressif/mphalport.h

@@ -38,4 +38,31 @@
 
 bool mp_hal_stdin_any(void);
 
+<<<<<<<< HEAD:ports/espressif/mphalport.h
 #endif // MICROPY_INCLUDED_ESPRESSIF_MPHAL_H
+========
+int mp_hal_get_interrupt_char(void);
+
+#if MICROPY_VFS_POSIX
+
+#include <errno.h>
+
+// This macro is used to implement PEP 475 to retry specified syscalls on EINTR
+#define MP_HAL_RETRY_SYSCALL(ret, syscall, raise) \
+    { \
+        for (;;) { \
+            ret = syscall; \
+            if (ret == -1) { \
+                int err = errno; \
+                if (err == EINTR) { \
+                    mp_handle_pending(true); \
+                    continue; \
+                } \
+                raise; \
+            } \
+            break; \
+        } \
+    }
+
+#endif
+>>>>>>>> v1.20.0:ports/webassembly/mphalport.h

ports/litex/boards/fomu/board.c

@@ -66,3 +66,4 @@ void board_init(void) {
     ledda_write(3, LEDDPWRG);   // Green
     ledda_write(98, LEDDPWRB);  // Blue
 }
+#endif // MICROPY_INCLUDED_MIMXRT_HAL_FLEXSPI_NOR_FLASH_H

ports/litex/common-hal/digitalio/DigitalInOut.c

@@ -27,7 +27,6 @@
 
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "py/runtime.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "csr.h"
 

ports/litex/common-hal/microcontroller/Processor.c

@@ -31,7 +31,6 @@
 #include "common-hal/microcontroller/Processor.h"
 #include "shared-bindings/microcontroller/Processor.h"
 #include "shared-bindings/microcontroller/ResetReason.h"
-#include "supervisor/shared/translate/translate.h"
 
 #include "csr.h"
 #include "generated/soc.h"

ports/mimxrt10xx/boards/imxrt1010_evk/board.c

@@ -3,8 +3,12 @@
  *
  * The MIT License (MIT)
  *
+<<<<<<<< HEAD:ports/mimxrt10xx/boards/imxrt1010_evk/board.c
  * Copyright (c) 2019 Scott Shawcroft for Adafruit Industries
  * Copyright (c) 2019 Artur Pacholec
+========
+ * Copyright (c) 2022 Damien P. George
+>>>>>>>> v1.20.0:ports/raspberrypi/pendsv.h
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,7 +28,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#ifndef MICROPY_INCLUDED_RP2_PENDSV_H
+#define MICROPY_INCLUDED_RP2_PENDSV_H
 
+<<<<<<<< HEAD:ports/mimxrt10xx/boards/imxrt1010_evk/board.c
 #include "supervisor/board.h"
 #include "shared-bindings/microcontroller/Pin.h"
 
@@ -45,3 +52,30 @@ const mcu_pin_obj_t *mimxrt10xx_reset_forbidden_pins[] = {
 };
 
 // Use the MP_WEAK supervisor/shared/board.c versions of routines not defined here.
+========
+#include <stddef.h>
+
+enum {
+    #if MICROPY_PY_LWIP
+    PENDSV_DISPATCH_LWIP,
+    #endif
+    #if MICROPY_PY_NETWORK_CYW43
+    PENDSV_DISPATCH_CYW43,
+    #endif
+    #if MICROPY_PY_NETWORK_WIZNET5K
+    PENDSV_DISPATCH_WIZNET,
+    #endif
+    MICROPY_BOARD_PENDSV_ENTRIES
+    PENDSV_DISPATCH_MAX
+};
+
+#define PENDSV_DISPATCH_NUM_SLOTS PENDSV_DISPATCH_MAX
+
+typedef void (*pendsv_dispatch_t)(void);
+
+void pendsv_suspend(void);
+void pendsv_resume(void);
+void pendsv_schedule_dispatch(size_t slot, pendsv_dispatch_t f);
+
+#endif // MICROPY_INCLUDED_RP2_PENDSV_H
+>>>>>>>> v1.20.0:ports/raspberrypi/pendsv.h

ports/mimxrt10xx/common-hal/analogio/AnalogOut.c

@@ -29,7 +29,6 @@
 
 #include "shared-bindings/analogio/AnalogOut.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 
 void common_hal_analogio_analogout_construct(analogio_analogout_obj_t *self, const mcu_pin_obj_t *pin) {
     mp_raise_NotImplementedError_varg(translate("%q"), MP_QSTR_AnalogOut);

ports/mimxrt10xx/common-hal/audiobusio/I2SOut.c

@@ -39,7 +39,6 @@
 #include "shared-bindings/audiobusio/I2SOut.h"
 #include "shared-bindings/audiocore/RawSample.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/shared/tick.h"
 
 // Where required we use identifier names that are required by NXP's

ports/mimxrt10xx/common-hal/audiobusio/I2SOut.h

@@ -1,9 +1,15 @@
 /*
  * This file is part of the MicroPython project, http://micropython.org/
  *
+ * This file provides functions for configuring the clocks.
+ *
  * The MIT License (MIT)
  *
+<<<<<<<< HEAD:ports/mimxrt10xx/common-hal/audiobusio/I2SOut.h
  * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+========
+ * Copyright (c) 2022 Robert Hammelrath
+>>>>>>>> v1.20.0:ports/samd/clock_config.h
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,6 +30,7 @@
  * THE SOFTWARE.
  */
 
+<<<<<<<< HEAD:ports/mimxrt10xx/common-hal/audiobusio/I2SOut.h
 #pragma once
 
 // Some boards don't implement I2SOut, so suppress any routines from here.
@@ -42,3 +49,11 @@ typedef struct {
 } audiobusio_i2sout_obj_t;
 
 #endif
+========
+void init_clocks(uint32_t cpu_freq);
+void set_cpu_freq(uint32_t cpu_freq);
+uint32_t get_cpu_freq(void);
+uint32_t get_peripheral_freq(void);
+void check_usb_recovery_mode(void);
+void enable_sercom_clock(int id);
+>>>>>>>> v1.20.0:ports/samd/clock_config.h

ports/mimxrt10xx/common-hal/audiopwmio/PWMAudioOut.c

@@ -36,7 +36,6 @@
 #include "common-hal/audiopwmio/PWMAudioOut.h"
 #include "shared-bindings/audiopwmio/PWMAudioOut.h"
 #include "shared-bindings/microcontroller/Pin.h"
-#include "supervisor/shared/translate/translate.h"
 #include "supervisor/shared/tick.h"
 
 // Where required we use identifier names that are required by NXP's

ports/mimxrt10xx/common-hal/digitalio/DigitalInOut.c

@@ -36,7 +36,6 @@
 
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
-#include "supervisor/shared/translate/translate.h"
 
 #define IOMUXC_SW_MUX_CTL_PAD_MUX_MODE_ALT5 5U