2015-01-01 23:30:53 +00:00
|
|
|
/*
|
2017-06-30 08:22:17 +01:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2015-01-01 23:30:53 +00:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2014 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
|
|
|
|
* 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.
|
|
|
|
*/
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 22:14:58 +01:00
|
|
|
#ifndef MICROPY_INCLUDED_PY_MPSTATE_H
|
|
|
|
#define MICROPY_INCLUDED_PY_MPSTATE_H
|
2015-01-01 23:30:53 +00:00
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include "py/mpconfig.h"
|
2016-04-25 16:28:57 +01:00
|
|
|
#include "py/mpthread.h"
|
2015-01-01 23:30:53 +00:00
|
|
|
#include "py/misc.h"
|
|
|
|
#include "py/nlr.h"
|
|
|
|
#include "py/obj.h"
|
2015-02-07 17:24:10 +00:00
|
|
|
#include "py/objlist.h"
|
2015-01-01 23:30:53 +00:00
|
|
|
#include "py/objexcept.h"
|
|
|
|
|
2017-06-30 08:22:17 +01:00
|
|
|
// This file contains structures defining the state of the MicroPython
|
2015-01-01 23:30:53 +00:00
|
|
|
// memory system, runtime and virtual machine. The state is a global
|
|
|
|
// variable, but in the future it is hoped that the state can become local.
|
|
|
|
|
2016-02-11 22:30:53 +00:00
|
|
|
// This structure contains dynamic configuration for the compiler.
|
|
|
|
#if MICROPY_DYNAMIC_COMPILER
|
|
|
|
typedef struct mp_dynamic_compiler_t {
|
|
|
|
uint8_t small_int_bits; // must be <= host small_int_bits
|
|
|
|
bool opt_cache_map_lookup_in_bytecode;
|
|
|
|
bool py_builtins_str_unicode;
|
2019-03-08 23:59:25 +00:00
|
|
|
uint8_t native_arch;
|
2019-09-18 04:45:20 +01:00
|
|
|
uint8_t nlr_buf_num_regs;
|
2016-02-11 22:30:53 +00:00
|
|
|
} mp_dynamic_compiler_t;
|
|
|
|
extern mp_dynamic_compiler_t mp_dynamic_compiler;
|
|
|
|
#endif
|
|
|
|
|
2017-02-16 07:05:06 +00:00
|
|
|
// These are the values for sched_state
|
|
|
|
#define MP_SCHED_IDLE (1)
|
|
|
|
#define MP_SCHED_LOCKED (-1)
|
|
|
|
#define MP_SCHED_PENDING (0) // 0 so it's a quick check in the VM
|
|
|
|
|
|
|
|
typedef struct _mp_sched_item_t {
|
|
|
|
mp_obj_t func;
|
|
|
|
mp_obj_t arg;
|
|
|
|
} mp_sched_item_t;
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
// This structure hold information about the memory allocation system.
|
|
|
|
typedef struct _mp_state_mem_t {
|
|
|
|
#if MICROPY_MEM_STATS
|
|
|
|
size_t total_bytes_allocated;
|
|
|
|
size_t current_bytes_allocated;
|
|
|
|
size_t peak_bytes_allocated;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
byte *gc_alloc_table_start;
|
2015-12-17 01:09:11 +00:00
|
|
|
size_t gc_alloc_table_byte_len;
|
2015-01-01 23:30:53 +00:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
|
|
|
byte *gc_finaliser_table_start;
|
|
|
|
#endif
|
2015-11-27 13:07:48 +00:00
|
|
|
byte *gc_pool_start;
|
|
|
|
byte *gc_pool_end;
|
2015-01-01 23:30:53 +00:00
|
|
|
|
|
|
|
int gc_stack_overflow;
|
2018-02-23 17:59:31 +00:00
|
|
|
MICROPY_GC_STACK_ENTRY_TYPE gc_stack[MICROPY_ALLOC_GC_STACK_SIZE];
|
2015-01-01 23:30:53 +00:00
|
|
|
|
|
|
|
// This variable controls auto garbage collection. If set to 0 then the
|
|
|
|
// GC won't automatically run when gc_alloc can't find enough blocks. But
|
|
|
|
// you can still allocate/free memory and also explicitly call gc_collect.
|
|
|
|
uint16_t gc_auto_collect_enabled;
|
|
|
|
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 22:37:30 +01:00
|
|
|
#if MICROPY_GC_ALLOC_THRESHOLD
|
|
|
|
size_t gc_alloc_amount;
|
|
|
|
size_t gc_alloc_threshold;
|
|
|
|
#endif
|
|
|
|
|
2015-12-17 01:09:11 +00:00
|
|
|
size_t gc_last_free_atb_index;
|
2015-02-07 17:24:10 +00:00
|
|
|
|
|
|
|
#if MICROPY_PY_GC_COLLECT_RETVAL
|
2015-12-17 01:09:11 +00:00
|
|
|
size_t gc_collected;
|
2015-02-07 17:24:10 +00:00
|
|
|
#endif
|
2016-04-25 16:28:57 +01:00
|
|
|
|
2020-01-22 17:19:37 +00:00
|
|
|
#if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
|
2016-04-25 16:28:57 +01:00
|
|
|
// This is a global mutex used to make the GC thread-safe.
|
|
|
|
mp_thread_mutex_t gc_mutex;
|
|
|
|
#endif
|
2015-01-01 23:30:53 +00:00
|
|
|
} mp_state_mem_t;
|
|
|
|
|
|
|
|
// This structure hold runtime and VM information. It includes a section
|
|
|
|
// which contains root pointers that must be scanned by the GC.
|
|
|
|
typedef struct _mp_state_vm_t {
|
2018-05-12 13:09:34 +01:00
|
|
|
//
|
|
|
|
// CONTINUE ROOT POINTER SECTION
|
|
|
|
// This must start at the start of this structure and follows
|
|
|
|
// the state in the mp_state_thread_t structure, continuing
|
|
|
|
// the root pointer section from there.
|
2015-01-01 23:30:53 +00:00
|
|
|
//
|
|
|
|
|
|
|
|
qstr_pool_t *last_pool;
|
|
|
|
|
|
|
|
// non-heap memory for creating an exception if we can't allocate RAM
|
|
|
|
mp_obj_exception_t mp_emergency_exception_obj;
|
|
|
|
|
|
|
|
// memory for exception arguments if we can't allocate RAM
|
|
|
|
#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
|
|
|
|
#if MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE > 0
|
2017-04-10 07:02:56 +01:00
|
|
|
// statically allocated buf (needs to be aligned to mp_obj_t)
|
|
|
|
mp_obj_t mp_emergency_exception_buf[MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE / sizeof(mp_obj_t)];
|
2015-01-01 23:30:53 +00:00
|
|
|
#else
|
|
|
|
// dynamically allocated buf
|
|
|
|
byte *mp_emergency_exception_buf;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-12-15 02:00:19 +00:00
|
|
|
#if MICROPY_KBD_EXCEPTION
|
|
|
|
// exception object of type KeyboardInterrupt
|
|
|
|
mp_obj_exception_t mp_kbd_exception;
|
|
|
|
#endif
|
|
|
|
|
2015-12-04 22:09:10 +00:00
|
|
|
// dictionary with loaded modules (may be exposed as sys.modules)
|
|
|
|
mp_obj_dict_t mp_loaded_modules_dict;
|
2015-01-01 23:30:53 +00:00
|
|
|
|
2017-02-16 07:05:06 +00:00
|
|
|
#if MICROPY_ENABLE_SCHEDULER
|
2019-07-11 02:55:31 +01:00
|
|
|
mp_sched_item_t sched_queue[MICROPY_SCHEDULER_DEPTH];
|
2017-02-16 07:05:06 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-25 01:17:41 +01:00
|
|
|
// current exception being handled, for sys.exc_info()
|
|
|
|
#if MICROPY_PY_SYS_EXC_INFO
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_base_t *cur_exception;
|
2015-04-25 01:17:41 +01:00
|
|
|
#endif
|
|
|
|
|
2019-08-05 14:06:41 +01:00
|
|
|
#if MICROPY_PY_SYS_ATEXIT
|
|
|
|
// exposed through sys.atexit function
|
|
|
|
mp_obj_t sys_exitfunc;
|
|
|
|
#endif
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
// dictionary for the __main__ module
|
|
|
|
mp_obj_dict_t dict_main;
|
|
|
|
|
2015-02-07 17:24:10 +00:00
|
|
|
// these two lists must be initialised per port, after the call to mp_init
|
|
|
|
mp_obj_list_t mp_sys_path_obj;
|
|
|
|
mp_obj_list_t mp_sys_argv_obj;
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
// dictionary for overridden builtins
|
|
|
|
#if MICROPY_CAN_OVERRIDE_BUILTINS
|
|
|
|
mp_obj_dict_t *mp_module_builtins_override_dict;
|
|
|
|
#endif
|
|
|
|
|
2020-07-27 14:52:38 +01:00
|
|
|
#if MICROPY_PERSISTENT_CODE_TRACK_RELOC_CODE
|
|
|
|
// An mp_obj_list_t that tracks relocated native code to prevent the GC from reclaiming them.
|
|
|
|
mp_obj_t track_reloc_code_list;
|
|
|
|
#endif
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
// include any root pointers defined by a port
|
|
|
|
MICROPY_PORT_ROOT_POINTERS
|
|
|
|
|
2015-10-26 21:04:33 +00:00
|
|
|
// root pointers for extmod
|
2016-01-01 12:19:26 +00:00
|
|
|
|
2018-02-26 05:08:58 +00:00
|
|
|
#if MICROPY_REPL_EVENT_DRIVEN
|
|
|
|
vstr_t *repl_line;
|
|
|
|
#endif
|
|
|
|
|
2016-01-01 12:19:26 +00:00
|
|
|
#if MICROPY_PY_OS_DUPTERM
|
2017-10-13 10:01:57 +01:00
|
|
|
mp_obj_t dupterm_objs[MICROPY_PY_OS_DUPTERM];
|
2016-01-01 12:19:26 +00:00
|
|
|
#endif
|
|
|
|
|
2015-10-26 21:04:33 +00:00
|
|
|
#if MICROPY_PY_LWIP_SLIP
|
|
|
|
mp_obj_t lwip_slip_stream;
|
|
|
|
#endif
|
|
|
|
|
2017-01-27 04:10:09 +00:00
|
|
|
#if MICROPY_VFS
|
2017-01-27 11:40:15 +00:00
|
|
|
struct _mp_vfs_mount_t *vfs_cur;
|
|
|
|
struct _mp_vfs_mount_t *vfs_mount_table;
|
2017-01-27 04:10:09 +00:00
|
|
|
#endif
|
|
|
|
|
2019-07-23 15:49:06 +01:00
|
|
|
#if MICROPY_PY_BLUETOOTH
|
|
|
|
mp_obj_t bluetooth;
|
|
|
|
#endif
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
//
|
|
|
|
// END ROOT POINTER SECTION
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
|
2015-06-13 21:53:22 +01:00
|
|
|
// pointer and sizes to store interned string data
|
|
|
|
// (qstr_last_chunk can be root pointer but is also stored in qstr pool)
|
|
|
|
byte *qstr_last_chunk;
|
2015-12-17 12:41:40 +00:00
|
|
|
size_t qstr_last_alloc;
|
|
|
|
size_t qstr_last_used;
|
2015-06-13 21:53:22 +01:00
|
|
|
|
2020-01-22 17:19:37 +00:00
|
|
|
#if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
|
2016-05-26 10:06:46 +01:00
|
|
|
// This is a global mutex used to make qstr interning thread-safe.
|
|
|
|
mp_thread_mutex_t qstr_mutex;
|
|
|
|
#endif
|
|
|
|
|
2018-04-04 05:24:03 +01:00
|
|
|
#if MICROPY_ENABLE_COMPILER
|
2015-01-01 23:30:53 +00:00
|
|
|
mp_uint_t mp_optimise_value;
|
2019-08-23 02:20:50 +01:00
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
|
|
uint8_t default_emit_opt; // one of MP_EMIT_OPT_xxx
|
|
|
|
#endif
|
2018-04-04 05:24:03 +01:00
|
|
|
#endif
|
2015-01-01 23:30:53 +00:00
|
|
|
|
|
|
|
// size of the emergency exception buf, if it's dynamically allocated
|
|
|
|
#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF && MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE == 0
|
|
|
|
mp_int_t mp_emergency_exception_buf_size;
|
|
|
|
#endif
|
2016-05-26 11:42:53 +01:00
|
|
|
|
2018-05-12 13:09:34 +01:00
|
|
|
#if MICROPY_ENABLE_SCHEDULER
|
|
|
|
volatile int16_t sched_state;
|
2019-03-21 00:52:10 +00:00
|
|
|
uint8_t sched_len;
|
|
|
|
uint8_t sched_idx;
|
2018-05-12 13:09:34 +01:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 11:42:53 +01:00
|
|
|
#if MICROPY_PY_THREAD_GIL
|
|
|
|
// This is a global mutex used to make the VM/runtime thread-safe.
|
|
|
|
mp_thread_mutex_t gil_mutex;
|
|
|
|
#endif
|
2015-01-01 23:30:53 +00:00
|
|
|
} mp_state_vm_t;
|
|
|
|
|
2016-04-22 23:44:56 +01:00
|
|
|
// This structure holds state that is specific to a given thread.
|
|
|
|
// Everything in this structure is scanned for root pointers.
|
|
|
|
typedef struct _mp_state_thread_t {
|
|
|
|
// Stack top at the start of program
|
|
|
|
char *stack_top;
|
|
|
|
|
|
|
|
#if MICROPY_STACK_CHECK
|
|
|
|
size_t stack_limit;
|
|
|
|
#endif
|
py: Introduce a Python stack for scoped allocation.
This patch introduces the MICROPY_ENABLE_PYSTACK option (disabled by
default) which enables a "Python stack" that allows to allocate and free
memory in a scoped, or Last-In-First-Out (LIFO) way, similar to alloca().
A new memory allocation API is introduced along with this Py-stack. It
includes both "local" and "nonlocal" LIFO allocation. Local allocation is
intended to be equivalent to using alloca(), whereby the same function must
free the memory. Nonlocal allocation is where another function may free
the memory, so long as it's still LIFO.
Follow-up patches will convert all uses of alloca() and VLA to the new
scoped allocation API. The old behaviour (using alloca()) will still be
available, but when MICROPY_ENABLE_PYSTACK is enabled then alloca() is no
longer required or used.
The benefits of enabling this option are (or will be once subsequent
patches are made to convert alloca()/VLA):
- Toolchains without alloca() can use this feature to obtain correct and
efficient scoped memory allocation (compared to using the heap instead
of alloca(), which is slower).
- Even if alloca() is available, enabling the Py-stack gives slightly more
efficient use of stack space when calling nested Python functions, due to
the way that compilers implement alloca().
- Enabling the Py-stack with the stackless mode allows for even more
efficient stack usage, as well as retaining high performance (because the
heap is no longer used to build and destroy stackless code states).
- With Py-stack and stackless enabled, Python-calling-Python is no longer
recursive in the C mp_execute_bytecode function.
The micropython.pystack_use() function is included to measure usage of the
Python stack.
2017-11-26 12:28:40 +00:00
|
|
|
|
|
|
|
#if MICROPY_ENABLE_PYSTACK
|
|
|
|
uint8_t *pystack_start;
|
|
|
|
uint8_t *pystack_end;
|
|
|
|
uint8_t *pystack_cur;
|
|
|
|
#endif
|
2018-05-12 13:09:34 +01:00
|
|
|
|
2021-05-04 14:56:43 +01:00
|
|
|
// Locking of the GC is done per thread.
|
|
|
|
uint16_t gc_lock_depth;
|
|
|
|
|
2018-05-12 13:09:34 +01:00
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
// START ROOT POINTER SECTION
|
|
|
|
// Everything that needs GC scanning must start here, and
|
|
|
|
// is followed by state in the mp_state_vm_t structure.
|
|
|
|
//
|
|
|
|
|
|
|
|
mp_obj_dict_t *dict_locals;
|
|
|
|
mp_obj_dict_t *dict_globals;
|
|
|
|
|
|
|
|
nlr_buf_t *nlr_top;
|
2019-08-14 15:09:36 +01:00
|
|
|
|
2021-05-11 03:53:22 +01:00
|
|
|
// pending exception object (MP_OBJ_NULL if not pending)
|
|
|
|
volatile mp_obj_t mp_pending_exception;
|
|
|
|
|
2019-08-14 15:09:36 +01:00
|
|
|
#if MICROPY_PY_SYS_SETTRACE
|
|
|
|
mp_obj_t prof_trace_callback;
|
|
|
|
bool prof_callback_is_executing;
|
|
|
|
struct _mp_code_state_t *current_code_state;
|
|
|
|
#endif
|
2016-04-22 23:44:56 +01:00
|
|
|
} mp_state_thread_t;
|
|
|
|
|
2017-02-27 12:56:46 +00:00
|
|
|
// This structure combines the above 3 structures.
|
|
|
|
// The order of the entries are important for root pointer scanning in the GC to work.
|
2015-01-01 23:30:53 +00:00
|
|
|
typedef struct _mp_state_ctx_t {
|
2016-04-22 23:44:56 +01:00
|
|
|
mp_state_thread_t thread;
|
2015-01-01 23:30:53 +00:00
|
|
|
mp_state_vm_t vm;
|
|
|
|
mp_state_mem_t mem;
|
|
|
|
} mp_state_ctx_t;
|
|
|
|
|
|
|
|
extern mp_state_ctx_t mp_state_ctx;
|
|
|
|
|
|
|
|
#define MP_STATE_VM(x) (mp_state_ctx.vm.x)
|
|
|
|
#define MP_STATE_MEM(x) (mp_state_ctx.mem.x)
|
|
|
|
|
2016-04-22 23:52:33 +01:00
|
|
|
#if MICROPY_PY_THREAD
|
|
|
|
extern mp_state_thread_t *mp_thread_get_state(void);
|
|
|
|
#define MP_STATE_THREAD(x) (mp_thread_get_state()->x)
|
|
|
|
#else
|
2016-04-22 23:44:56 +01:00
|
|
|
#define MP_STATE_THREAD(x) (mp_state_ctx.thread.x)
|
2016-04-22 23:52:33 +01:00
|
|
|
#endif
|
2016-04-22 23:44:56 +01:00
|
|
|
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 22:14:58 +01:00
|
|
|
#endif // MICROPY_INCLUDED_PY_MPSTATE_H
|