/*

* This file is part of the MicroPython project, http://micropython.org/

*

* The MIT License (MIT)

*

* SPDX-FileCopyrightText: Copyright (c) 2013, 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.

*/

#ifndef MICROPY_INCLUDED_PY_MPCONFIG_H

#define MICROPY_INCLUDED_PY_MPCONFIG_H

// This file contains default configuration settings for MicroPython.

// You can override any of the options below using mpconfigport.h file

// located in a directory of your port.

// mpconfigport.h is a file containing configuration settings for a

// particular port. mpconfigport.h is actually a default name for

// such config, and it can be overridden using MP_CONFIGFILE preprocessor

// define (you can do that by passing CFLAGS_EXTRA='-DMP_CONFIGFILE="<file.h>"'

// argument to make when using standard MicroPython makefiles).

// This is useful to have more than one config per port, for example,

// release vs debug configs, etc. Note that if you switch from one config

// to another, you must rebuild from scratch using "-B" switch to make.

#ifdef MP_CONFIGFILE

#include MP_CONFIGFILE

#else

#include <mpconfigport.h>

#endif

// Is this a CircuitPython build?

#ifndef CIRCUITPY

#define CIRCUITPY 0

#endif

// Disable all optional features (i.e. minimal port).

#define MICROPY_CONFIG_ROM_LEVEL_MINIMUM (0)

// Only enable core features (constrained flash, e.g. STM32L072)

#define MICROPY_CONFIG_ROM_LEVEL_CORE_FEATURES (10)

// Enable most common features (small on-device flash, e.g. STM32F411)

#define MICROPY_CONFIG_ROM_LEVEL_BASIC_FEATURES (20)

// Enable convenience features (medium on-device flash, e.g. STM32F405)

#define MICROPY_CONFIG_ROM_LEVEL_EXTRA_FEATURES (30)

// Enable all common features (large/external flash, rp2, unix)

#define MICROPY_CONFIG_ROM_LEVEL_FULL_FEATURES (40)

// Enable everything (e.g. coverage)

#define MICROPY_CONFIG_ROM_LEVEL_EVERYTHING (50)

// Ports/boards should set this, but default to level=core.

#ifndef MICROPY_CONFIG_ROM_LEVEL

#define MICROPY_CONFIG_ROM_LEVEL (MICROPY_CONFIG_ROM_LEVEL_CORE_FEATURES)

#endif

// Helper macros for "have at least this level".

#define MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES (MICROPY_CONFIG_ROM_LEVEL >= MICROPY_CONFIG_ROM_LEVEL_CORE_FEATURES)

#define MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_BASIC_FEATURES (MICROPY_CONFIG_ROM_LEVEL >= MICROPY_CONFIG_ROM_LEVEL_BASIC_FEATURES)

#define MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES (MICROPY_CONFIG_ROM_LEVEL >= MICROPY_CONFIG_ROM_LEVEL_EXTRA_FEATURES)

#define MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_FULL_FEATURES (MICROPY_CONFIG_ROM_LEVEL >= MICROPY_CONFIG_ROM_LEVEL_FULL_FEATURES)

#define MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EVERYTHING (MICROPY_CONFIG_ROM_LEVEL >= MICROPY_CONFIG_ROM_LEVEL_EVERYTHING)

// Any options not explicitly set in mpconfigport.h will get default

// values below.

/*****************************************************************************/

/* Object representation */

// A MicroPython object is a machine word having the following form:

// - xxxx...xxx1 : a small int, bits 1 and above are the value

// - xxxx...x010 : a qstr, bits 3 and above are the value

// - xxxx...x110 : an immediate object, bits 3 and above are the value

// - xxxx...xx00 : a pointer to an mp_obj_base_t (unless a fake object)

#define MICROPY_OBJ_REPR_A (0)

// A MicroPython object is a machine word having the following form:

// - xxxx...xx01 : a small int, bits 2 and above are the value

// - xxxx...x011 : a qstr, bits 3 and above are the value

// - xxxx...x111 : an immediate object, bits 3 and above are the value

// - xxxx...xxx0 : a pointer to an mp_obj_base_t (unless a fake object)

#define MICROPY_OBJ_REPR_B (1)

// A MicroPython object is a machine word having the following form (called R):

// - iiiiiiii iiiiiiii iiiiiiii iiiiiii1 small int with 31-bit signed value

// - 01111111 1qqqqqqq qqqqqqqq qqqq0110 str with 19-bit qstr value

// - 01111111 10000000 00000000 ssss1110 immediate object with 4-bit value

// - s1111111 10000000 00000000 00000010 +/- inf

// - s1111111 1xxxxxxx xxxxxxxx xxxxx010 nan, x != 0

// - seeeeeee efffffff ffffffff ffffff10 30-bit fp, e != 0xff

// - pppppppp pppppppp pppppppp pppppp00 ptr (4 byte alignment)

// Str, immediate and float stored as O = R + 0x80800000, retrieved as R = O - 0x80800000.

// This makes strs/immediates easier to encode/decode as they have zeros in the top 9 bits.

// This scheme only works with 32-bit word size and float enabled.

#define MICROPY_OBJ_REPR_C (2)

// A MicroPython object is a 64-bit word having the following form (called R):

// - seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff 64-bit fp, e != 0x7ff

// - s1111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000 +/- inf

// - 01111111 11111000 00000000 00000000 00000000 00000000 00000000 00000000 normalised nan

// - 01111111 11111101 iiiiiiii iiiiiiii iiiiiiii iiiiiiii iiiiiiii iiiiiii1 small int

// - 01111111 11111110 00000000 00000000 qqqqqqqq qqqqqqqq qqqqqqqq qqqqqqq1 str

// - 01111111 11111111 ss000000 00000000 00000000 00000000 00000000 00000000 immediate object

// - 01111111 11111100 00000000 00000000 pppppppp pppppppp pppppppp pppppp00 ptr (4 byte alignment)

// Stored as O = R + 0x8004000000000000, retrieved as R = O - 0x8004000000000000.

// This makes pointers have all zeros in the top 32 bits.

// Small-ints and strs have 1 as LSB to make sure they don't look like pointers

// to the garbage collector.

#define MICROPY_OBJ_REPR_D (3)

#ifndef MICROPY_OBJ_REPR

#define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A)

#endif

// Whether to encode None/False/True as immediate objects instead of pointers to

// real objects. Reduces code size by a decent amount without hurting

// performance, for all representations except D on some architectures.

#ifndef MICROPY_OBJ_IMMEDIATE_OBJS

#define MICROPY_OBJ_IMMEDIATE_OBJS (MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D)

#endif

/*****************************************************************************/

/* Memory allocation policy */

// Number of bytes in memory allocation/GC block. Any size allocated will be

// rounded up to be multiples of this.

#ifndef MICROPY_BYTES_PER_GC_BLOCK

#define MICROPY_BYTES_PER_GC_BLOCK (4 * MP_BYTES_PER_OBJ_WORD)

#endif

// Number of words allocated (in BSS) to the GC stack (minimum is 1)

#ifndef MICROPY_ALLOC_GC_STACK_SIZE

#define MICROPY_ALLOC_GC_STACK_SIZE (64)

#endif

// The C-type to use for entries in the GC stack. By default it allows the

// heap to be as large as the address space, but the bit-width of this type can

// be reduced to save memory when the heap is small enough. The type must be

// big enough to index all blocks in the heap, which is set by

// heap-size-in-bytes / MICROPY_BYTES_PER_GC_BLOCK.

#ifndef MICROPY_GC_STACK_ENTRY_TYPE

#define MICROPY_GC_STACK_ENTRY_TYPE size_t

#endif

// Be conservative and always clear to zero newly (re)allocated memory in the GC.

// This helps eliminate stray pointers that hold on to memory that's no longer

// used. It decreases performance due to unnecessary memory clearing.

// A memory manager which always clears memory can set this to 0.

// TODO Do analysis to understand why some memory is not properly cleared and

// find a more efficient way to clear it.

#ifndef MICROPY_GC_CONSERVATIVE_CLEAR

#define MICROPY_GC_CONSERVATIVE_CLEAR (MICROPY_ENABLE_GC)

#endif

// Support automatic GC when reaching allocation threshold,

// configurable by gc.threshold().

#ifndef MICROPY_GC_ALLOC_THRESHOLD

#define MICROPY_GC_ALLOC_THRESHOLD (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Number of bytes to allocate initially when creating new chunks to store

// interned string data. Smaller numbers lead to more chunks being needed

// and more wastage at the end of the chunk. Larger numbers lead to wasted

// space at the end when no more strings need interning.

#ifndef MICROPY_ALLOC_QSTR_CHUNK_INIT

#define MICROPY_ALLOC_QSTR_CHUNK_INIT (128)

#endif

// Max number of entries in newly allocated QSTR pools. Smaller numbers may make QSTR lookups

// slightly slower but reduce the waste of unused spots.

#ifndef MICROPY_QSTR_POOL_MAX_ENTRIES

#define MICROPY_QSTR_POOL_MAX_ENTRIES (64)

#endif

// Initial amount for lexer indentation level

#ifndef MICROPY_ALLOC_LEXER_INDENT_INIT

#define MICROPY_ALLOC_LEXER_INDENT_INIT (10)

#endif

// Increment for lexer indentation level

#ifndef MICROPY_ALLOC_LEXEL_INDENT_INC

#define MICROPY_ALLOC_LEXEL_INDENT_INC (8)

#endif

// Initial amount for parse rule stack

#ifndef MICROPY_ALLOC_PARSE_RULE_INIT

#define MICROPY_ALLOC_PARSE_RULE_INIT (64)

#endif

// Increment for parse rule stack

#ifndef MICROPY_ALLOC_PARSE_RULE_INC

#define MICROPY_ALLOC_PARSE_RULE_INC (16)

#endif

// Initial amount for parse result stack

#ifndef MICROPY_ALLOC_PARSE_RESULT_INIT

#define MICROPY_ALLOC_PARSE_RESULT_INIT (32)

#endif

// Increment for parse result stack

#ifndef MICROPY_ALLOC_PARSE_RESULT_INC

#define MICROPY_ALLOC_PARSE_RESULT_INC (16)

#endif

// Strings this length or less will be interned by the parser

#ifndef MICROPY_ALLOC_PARSE_INTERN_STRING_LEN

#define MICROPY_ALLOC_PARSE_INTERN_STRING_LEN (10)

#endif

// Number of bytes to allocate initially when creating new chunks to store

// parse nodes. Small leads to fragmentation, large leads to excess use.

#ifndef MICROPY_ALLOC_PARSE_CHUNK_INIT

#define MICROPY_ALLOC_PARSE_CHUNK_INIT (128)

#endif

// Initial amount for ids in a scope

#ifndef MICROPY_ALLOC_SCOPE_ID_INIT

#define MICROPY_ALLOC_SCOPE_ID_INIT (4)

#endif

// Increment for ids in a scope

#ifndef MICROPY_ALLOC_SCOPE_ID_INC

#define MICROPY_ALLOC_SCOPE_ID_INC (6)

#endif

// Maximum length of a path in the filesystem

// So we can allocate a buffer on the stack for path manipulation in import

#ifndef MICROPY_ALLOC_PATH_MAX

#define MICROPY_ALLOC_PATH_MAX (512)

#endif

// Initial size of module dict

#ifndef MICROPY_MODULE_DICT_SIZE

#define MICROPY_MODULE_DICT_SIZE (1)

#endif

// Initial size of sys.modules dict

#ifndef MICROPY_LOADED_MODULES_DICT_SIZE

#define MICROPY_LOADED_MODULES_DICT_SIZE (3)

#endif

// Whether realloc/free should be passed allocated memory region size

// You must enable this if MICROPY_MEM_STATS is enabled

#ifndef MICROPY_MALLOC_USES_ALLOCATED_SIZE

#define MICROPY_MALLOC_USES_ALLOCATED_SIZE (0)

#endif

// Number of bytes used to store qstr length

// Dictates hard limit on maximum Python identifier length, but 1 byte

// (limit of 255 bytes in an identifier) should be enough for everyone

#ifndef MICROPY_QSTR_BYTES_IN_LEN

#define MICROPY_QSTR_BYTES_IN_LEN (1)

#endif

// Number of bytes used to store qstr hash

#ifndef MICROPY_QSTR_BYTES_IN_HASH

#if MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES

#define MICROPY_QSTR_BYTES_IN_HASH (2)

#else

#define MICROPY_QSTR_BYTES_IN_HASH (1)

#endif

#endif

// Avoid using C stack when making Python function calls. C stack still

// may be used if there's no free heap.

#ifndef MICROPY_STACKLESS

#define MICROPY_STACKLESS (0)

#endif

// Never use C stack when making Python function calls. This may break

// testsuite as will subtly change which exception is thrown in case

// of too deep recursion and other similar cases.

#ifndef MICROPY_STACKLESS_STRICT

#define MICROPY_STACKLESS_STRICT (0)

#endif

// Don't use alloca calls. As alloca() is not part of ANSI C, this

// workaround option is provided for compilers lacking this de-facto

// standard function. The way it works is allocating from heap, and

// relying on garbage collection to free it eventually. This is of

// course much less optimal than real alloca().

#if defined(MICROPY_NO_ALLOCA) && MICROPY_NO_ALLOCA

#undef alloca

#define alloca(x) m_malloc(x)

#endif

// Number of atb indices to cache. Allocations of fewer blocks will be faster

// because the search will be accelerated by the index cache. This only applies

// to short lived allocations because we assume the long lived allocations are

// contiguous.

#ifndef MICROPY_ATB_INDICES

#define MICROPY_ATB_INDICES (8)

#endif

/*****************************************************************************/

/* MicroPython emitters */

// Whether to support loading of persistent code

#ifndef MICROPY_PERSISTENT_CODE_LOAD

#define MICROPY_PERSISTENT_CODE_LOAD (0)

#endif

// Whether to support saving of persistent code

#ifndef MICROPY_PERSISTENT_CODE_SAVE

#define MICROPY_PERSISTENT_CODE_SAVE (0)

#endif

// Whether to support saving persistent code to a file via mp_raw_code_save_file

#ifndef MICROPY_PERSISTENT_CODE_SAVE_FILE

#define MICROPY_PERSISTENT_CODE_SAVE_FILE (0)

#endif

// Whether generated code can persist independently of the VM/runtime instance

// This is enabled automatically when needed by other features

#ifndef MICROPY_PERSISTENT_CODE

#define MICROPY_PERSISTENT_CODE (MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE || MICROPY_MODULE_FROZEN_MPY)

#endif

// Whether to emit x64 native code

#ifndef MICROPY_EMIT_X64

#define MICROPY_EMIT_X64 (0)

#endif

// Whether to emit x86 native code

#ifndef MICROPY_EMIT_X86

#define MICROPY_EMIT_X86 (0)

#endif

// Whether to emit thumb native code

#ifndef MICROPY_EMIT_THUMB

#define MICROPY_EMIT_THUMB (0)

#endif

// Whether to emit ARMv7-M instruction support in thumb native code

#ifndef MICROPY_EMIT_THUMB_ARMV7M

#define MICROPY_EMIT_THUMB_ARMV7M (1)

#endif

// Whether to enable the thumb inline assembler

#ifndef MICROPY_EMIT_INLINE_THUMB

#define MICROPY_EMIT_INLINE_THUMB (0)

#endif

// Whether to enable ARMv7-M instruction support in the Thumb2 inline assembler

#ifndef MICROPY_EMIT_INLINE_THUMB_ARMV7M

#define MICROPY_EMIT_INLINE_THUMB_ARMV7M (1)

#endif

// Whether to enable float support in the Thumb2 inline assembler

#ifndef MICROPY_EMIT_INLINE_THUMB_FLOAT

#define MICROPY_EMIT_INLINE_THUMB_FLOAT (1)

#endif

// Whether to emit ARM native code

#ifndef MICROPY_EMIT_ARM

#define MICROPY_EMIT_ARM (0)

#endif

// Whether to emit Xtensa native code

#ifndef MICROPY_EMIT_XTENSA

#define MICROPY_EMIT_XTENSA (0)

#endif

// Whether to enable the Xtensa inline assembler

#ifndef MICROPY_EMIT_INLINE_XTENSA

#define MICROPY_EMIT_INLINE_XTENSA (0)

#endif

// Whether to emit Xtensa-Windowed native code

#ifndef MICROPY_EMIT_XTENSAWIN

#define MICROPY_EMIT_XTENSAWIN (0)

#endif

// Convenience definition for whether any native emitter is enabled

#define MICROPY_EMIT_NATIVE (MICROPY_EMIT_X64 || MICROPY_EMIT_X86 || MICROPY_EMIT_THUMB || MICROPY_EMIT_ARM || MICROPY_EMIT_XTENSA || MICROPY_EMIT_XTENSAWIN)

// Select prelude-as-bytes-object for certain emitters

#define MICROPY_EMIT_NATIVE_PRELUDE_AS_BYTES_OBJ (MICROPY_EMIT_XTENSAWIN)

// Convenience definition for whether any inline assembler emitter is enabled

#define MICROPY_EMIT_INLINE_ASM (MICROPY_EMIT_INLINE_THUMB || MICROPY_EMIT_INLINE_XTENSA)

// Convenience definition for whether any native or inline assembler emitter is enabled

#define MICROPY_EMIT_MACHINE_CODE (MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM)

// Whether native relocatable code loaded from .mpy files is explicitly tracked

// so that the GC cannot reclaim it. Needed on architectures that allocate

// executable memory on the MicroPython heap and don't explicitly track this

// data some other way.

#ifndef MICROPY_PERSISTENT_CODE_TRACK_RELOC_CODE

#if !MICROPY_EMIT_MACHINE_CODE || defined(MP_PLAT_ALLOC_EXEC) || defined(MP_PLAT_COMMIT_EXEC)

#define MICROPY_PERSISTENT_CODE_TRACK_RELOC_CODE (0)

#else

#define MICROPY_PERSISTENT_CODE_TRACK_RELOC_CODE (1)

#endif

#endif

/*****************************************************************************/

/* Compiler configuration */

// Whether to include the compiler

#ifndef MICROPY_ENABLE_COMPILER

#define MICROPY_ENABLE_COMPILER (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether the compiler is dynamically configurable (ie at runtime)

// This will disable the ability to execute native/viper code

#ifndef MICROPY_DYNAMIC_COMPILER

#define MICROPY_DYNAMIC_COMPILER (0)

#endif

// Configure dynamic compiler macros

#if MICROPY_DYNAMIC_COMPILER

#define MICROPY_PY_BUILTINS_STR_UNICODE_DYNAMIC (mp_dynamic_compiler.py_builtins_str_unicode)

#else

#define MICROPY_PY_BUILTINS_STR_UNICODE_DYNAMIC MICROPY_PY_BUILTINS_STR_UNICODE

#endif

// Whether to enable constant folding; eg 1+2 rewritten as 3

#ifndef MICROPY_COMP_CONST_FOLDING

#define MICROPY_COMP_CONST_FOLDING (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to enable optimisations for constant literals, eg OrderedDict

#ifndef MICROPY_COMP_CONST_LITERAL

#define MICROPY_COMP_CONST_LITERAL (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to enable lookup of constants in modules; eg module.CONST

#ifndef MICROPY_COMP_MODULE_CONST

#define MICROPY_COMP_MODULE_CONST (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to enable constant optimisation; id = const(value)

#ifndef MICROPY_COMP_CONST

#define MICROPY_COMP_CONST (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to enable optimisation of: a, b = c, d

// Costs 124 bytes (Thumb2)

#ifndef MICROPY_COMP_DOUBLE_TUPLE_ASSIGN

#define MICROPY_COMP_DOUBLE_TUPLE_ASSIGN (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to enable optimisation of: a, b, c = d, e, f

// Requires MICROPY_COMP_DOUBLE_TUPLE_ASSIGN and costs 68 bytes (Thumb2)

#ifndef MICROPY_COMP_TRIPLE_TUPLE_ASSIGN

#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to enable optimisation of: return a if b else c

// Costs about 80 bytes (Thumb2) and saves 2 bytes of bytecode for each use

#ifndef MICROPY_COMP_RETURN_IF_EXPR

#define MICROPY_COMP_RETURN_IF_EXPR (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to include parsing of f-string literals

#ifndef MICROPY_COMP_FSTRING_LITERAL

#define MICROPY_COMP_FSTRING_LITERAL (1)

#endif

/*****************************************************************************/

/* Internal debugging stuff */

// Whether to collect memory allocation stats

#ifndef MICROPY_MEM_STATS

#define MICROPY_MEM_STATS (0)

#endif

// The mp_print_t printer used for debugging output

#ifndef MICROPY_DEBUG_PRINTER

#define MICROPY_DEBUG_PRINTER (&mp_plat_print)

#endif

// Whether to build functions that print debugging info:

// mp_bytecode_print

// mp_parse_node_print

#ifndef MICROPY_DEBUG_PRINTERS

#define MICROPY_DEBUG_PRINTERS (0)

#endif

// Whether to enable all debugging outputs (it will be extremely verbose)

#ifndef MICROPY_DEBUG_VERBOSE

#define MICROPY_DEBUG_VERBOSE (0)

#endif

// Whether to enable debugging versions of MP_OBJ_NULL/STOP_ITERATION/SENTINEL

#ifndef MICROPY_DEBUG_MP_OBJ_SENTINELS

#define MICROPY_DEBUG_MP_OBJ_SENTINELS (0)

#endif

// Whether to print parse rule names (rather than integers) in mp_parse_node_print

#ifndef MICROPY_DEBUG_PARSE_RULE_NAME

#define MICROPY_DEBUG_PARSE_RULE_NAME (0)

#endif

// Whether to enable a simple VM stack overflow check

#ifndef MICROPY_DEBUG_VM_STACK_OVERFLOW

#define MICROPY_DEBUG_VM_STACK_OVERFLOW (0)

#endif

// Whether to enable extra instrumentation for valgrind

#ifndef MICROPY_DEBUG_VALGRIND

#define MICROPY_DEBUG_VALGRIND (0)

#endif

/*****************************************************************************/

/* Optimisations */

// Whether to use computed gotos in the VM, or a switch

// Computed gotos are roughly 10% faster, and increase VM code size by a little,

// e.g. ~1kiB on Cortex M4.

// Note: enabling this will use the gcc-specific extensions of ranged designated

// initialisers and addresses of labels, which are not part of the C99 standard.

#ifndef MICROPY_OPT_COMPUTED_GOTO

#define MICROPY_OPT_COMPUTED_GOTO (0)

#endif

// Whether to save trade flash space for speed in MICROPY_OPT_COMPUTED_GOTO.

// Costs about 3% speed, saves about 1500 bytes space. In addition to the assumptions

// of MICROPY_OPT_COMPUTED_GOTO, also assumes that mp_execute_bytecode is less than

// 32kB in size.

#ifndef MICROPY_OPT_COMPUTED_GOTO_SAVE_SPACE

#define MICROPY_OPT_COMPUTED_GOTO_SAVE_SPACE (0)

#endif

// Optimise the fast path for loading attributes from instance types. Increases

// Thumb2 code size by about 48 bytes.

#ifndef MICROPY_OPT_LOAD_ATTR_FAST_PATH

#define MICROPY_OPT_LOAD_ATTR_FAST_PATH (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Use extra RAM to cache map lookups by remembering the likely location of

// the index. Avoids the hash computation on unordered maps, and avoids the

// linear search on ordered (especially in-ROM) maps. Can provide a +10-15%

// performance improvement on benchmarks involving lots of attribute access

// or dictionary lookup.

#ifndef MICROPY_OPT_MAP_LOOKUP_CACHE

#define MICROPY_OPT_MAP_LOOKUP_CACHE (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// How much RAM (in bytes) to use for the map lookup cache.

#ifndef MICROPY_OPT_MAP_LOOKUP_CACHE_SIZE

#define MICROPY_OPT_MAP_LOOKUP_CACHE_SIZE (128)

#endif

// Whether to use fast versions of bitwise operations (and, or, xor) when the

// arguments are both positive. Increases Thumb2 code size by about 250 bytes.

#ifndef MICROPY_OPT_MPZ_BITWISE

#define MICROPY_OPT_MPZ_BITWISE (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether math.factorial is large, fast and recursive (1) or small and slow (0).

#ifndef MICROPY_OPT_MATH_FACTORIAL

#define MICROPY_OPT_MATH_FACTORIAL (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

/*****************************************************************************/

/* Python internal features */

// Whether to enable import of external modules

// When disabled, only importing of built-in modules is supported

// When enabled, a port must implement mp_import_stat (among other things)

#ifndef MICROPY_ENABLE_EXTERNAL_IMPORT

#define MICROPY_ENABLE_EXTERNAL_IMPORT (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to use the POSIX reader for importing files

#ifndef MICROPY_READER_POSIX

#define MICROPY_READER_POSIX (0)

#endif

// Whether to use the VFS reader for importing files

#ifndef MICROPY_READER_VFS

#define MICROPY_READER_VFS (0)

#endif

// Whether any readers have been defined

#ifndef MICROPY_HAS_FILE_READER

#define MICROPY_HAS_FILE_READER (MICROPY_READER_POSIX || MICROPY_READER_VFS)

#endif

// Number of VFS mounts to persist across soft-reset.

#ifndef MICROPY_FATFS_NUM_PERSISTENT

#define MICROPY_FATFS_NUM_PERSISTENT (0)

#endif

// Hook for the VM at the start of the opcode loop (can contain variable

// definitions usable by the other hook functions)

#ifndef MICROPY_VM_HOOK_INIT

#define MICROPY_VM_HOOK_INIT

#endif

// Hook for the VM during the opcode loop (but only after jump opcodes)

#ifndef MICROPY_VM_HOOK_LOOP

#define MICROPY_VM_HOOK_LOOP

#endif

// Hook for the VM just before return opcode is finished being interpreted

#ifndef MICROPY_VM_HOOK_RETURN

#define MICROPY_VM_HOOK_RETURN

#endif

// Hook for mp_sched_schedule when a function gets scheduled on sched_queue

// (this macro executes within an atomic section)

#ifndef MICROPY_SCHED_HOOK_SCHEDULED

#define MICROPY_SCHED_HOOK_SCHEDULED

#endif

// Whether to include the garbage collector

#ifndef MICROPY_ENABLE_GC

#define MICROPY_ENABLE_GC (0)

#endif

// Hook to run code during time consuming garbage collector operations

#ifndef MICROPY_GC_HOOK_LOOP

#define MICROPY_GC_HOOK_LOOP

#endif

// Whether to enable finalisers in the garbage collector (ie call __del__)

#ifndef MICROPY_ENABLE_FINALISER

#define MICROPY_ENABLE_FINALISER (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to enable a separate allocator for the Python stack.

// If enabled then the code must call mp_pystack_init before mp_init.

#ifndef MICROPY_ENABLE_PYSTACK

#define MICROPY_ENABLE_PYSTACK (0)

#endif

// Number of bytes that memory returned by mp_pystack_alloc will be aligned by.

#ifndef MICROPY_PYSTACK_ALIGN

#define MICROPY_PYSTACK_ALIGN (8)

#endif

// Whether to check C stack usage. C stack used for calling Python functions,

// etc. Not checking means segfault on overflow.

#ifndef MICROPY_STACK_CHECK

#define MICROPY_STACK_CHECK (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to measure maximum stack excursion

#ifndef MICROPY_MAX_STACK_USAGE

#define MICROPY_MAX_STACK_USAGE (0)

#endif

// Whether to have an emergency exception buffer

#ifndef MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF

#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (0)

#endif

#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF

#ifndef MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE

#define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE (0) // 0 - implies dynamic allocation

#endif

#endif

// Whether to provide the mp_kbd_exception object, and micropython.kbd_intr function

#ifndef MICROPY_KBD_EXCEPTION

#define MICROPY_KBD_EXCEPTION (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Prefer to raise KeyboardInterrupt asynchronously (from signal or interrupt

// handler) - if supported by a particular port.

#ifndef MICROPY_ASYNC_KBD_INTR

#define MICROPY_ASYNC_KBD_INTR (0)

#endif

// Whether to include REPL helper function

#ifndef MICROPY_HELPER_REPL

#define MICROPY_HELPER_REPL (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Allow enabling debug prints after each REPL line

#ifndef MICROPY_REPL_INFO

#define MICROPY_REPL_INFO (0)

#endif

// Whether to include emacs-style readline behavior in REPL

#ifndef MICROPY_REPL_EMACS_KEYS

#define MICROPY_REPL_EMACS_KEYS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to include emacs-style word movement/kill readline behavior in REPL.

// This adds Alt+F, Alt+B, Alt+D and Alt+Backspace for forward-word, backward-word, forward-kill-word

// and backward-kill-word, respectively.

#ifndef MICROPY_REPL_EMACS_WORDS_MOVE

#define MICROPY_REPL_EMACS_WORDS_MOVE (0)

#endif

// Whether to include extra convenience keys for word movement/kill in readline REPL.

// This adds Ctrl+Right, Ctrl+Left and Ctrl+W for forward-word, backward-word and backward-kill-word

// respectively. Ctrl+Delete is not implemented because it's a very different escape sequence.

// Depends on MICROPY_REPL_EMACS_WORDS_MOVE.

#ifndef MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE

#define MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE (0)

#endif

// Whether to implement auto-indent in REPL

#ifndef MICROPY_REPL_AUTO_INDENT

#define MICROPY_REPL_AUTO_INDENT (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether port requires event-driven REPL functions

#ifndef MICROPY_REPL_EVENT_DRIVEN

#define MICROPY_REPL_EVENT_DRIVEN (0)

#endif

// Whether to include lexer helper function for unix

#ifndef MICROPY_HELPER_LEXER_UNIX

#define MICROPY_HELPER_LEXER_UNIX (0)

#endif

// Long int implementation

#define MICROPY_LONGINT_IMPL_NONE (0)

#define MICROPY_LONGINT_IMPL_LONGLONG (1)

#define MICROPY_LONGINT_IMPL_MPZ (2)

#ifndef MICROPY_LONGINT_IMPL

#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_NONE)

#endif

#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG

typedef long long mp_longint_impl_t;

#endif

// Whether to include information in the byte code to determine source

// line number (increases RAM usage, but doesn't slow byte code execution)

#ifndef MICROPY_ENABLE_SOURCE_LINE

#define MICROPY_ENABLE_SOURCE_LINE (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to include doc strings (increases RAM usage)

#ifndef MICROPY_ENABLE_DOC_STRING

#define MICROPY_ENABLE_DOC_STRING (0)

#endif

// Exception messages are removed (requires disabling MICROPY_ROM_TEXT_COMPRESSION)

#define MICROPY_ERROR_REPORTING_NONE (0)

// Exception messages are short static strings

#define MICROPY_ERROR_REPORTING_TERSE (1)

// Exception messages provide basic error details

#define MICROPY_ERROR_REPORTING_NORMAL (2)

// Exception messages provide full info, e.g. object names

#define MICROPY_ERROR_REPORTING_DETAILED (3)

#ifndef MICROPY_ERROR_REPORTING

#if MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_FULL_FEATURES

#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_DETAILED)

#elif MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES

#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_NORMAL)

#else

#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_TERSE)

#endif

#endif

// Whether issue warnings during compiling/execution

#ifndef MICROPY_WARNINGS

#define MICROPY_WARNINGS (0)

#endif

// Whether to support warning categories

#ifndef MICROPY_WARNINGS_CATEGORY

#define MICROPY_WARNINGS_CATEGORY (0)

#endif

// This macro is used when printing runtime warnings and errors

#ifndef MICROPY_ERROR_PRINTER

#define MICROPY_ERROR_PRINTER (&mp_plat_print)

#endif

// Float and complex implementation

#define MICROPY_FLOAT_IMPL_NONE (0)

#define MICROPY_FLOAT_IMPL_FLOAT (1)

#define MICROPY_FLOAT_IMPL_DOUBLE (2)

#ifndef MICROPY_FLOAT_IMPL

#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_NONE)

#endif

#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT

#define MICROPY_PY_BUILTINS_FLOAT (1)

#define MICROPY_FLOAT_CONST(x) x##F

#define MICROPY_FLOAT_C_FUN(fun) fun##f

typedef float mp_float_t;

#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE

#define MICROPY_PY_BUILTINS_FLOAT (1)

#define MICROPY_FLOAT_CONST(x) x

#define MICROPY_FLOAT_C_FUN(fun) fun

typedef double mp_float_t;

#else

#define MICROPY_PY_BUILTINS_FLOAT (0)

#endif

#ifndef MICROPY_PY_BUILTINS_COMPLEX

#define MICROPY_PY_BUILTINS_COMPLEX (MICROPY_PY_BUILTINS_FLOAT)

#endif

// Whether to provide a high-quality hash for float and complex numbers.

// Otherwise the default is a very simple but correct hashing function.

#ifndef MICROPY_FLOAT_HIGH_QUALITY_HASH

#define MICROPY_FLOAT_HIGH_QUALITY_HASH (0)

#endif

// Enable features which improve CPython compatibility

// but may lead to more code size/memory usage.

// TODO: Originally intended as generic category to not

// add bunch of once-off options. May need refactoring later

#ifndef MICROPY_CPYTHON_COMPAT

#define MICROPY_CPYTHON_COMPAT (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Perform full checks as done by CPython. Disabling this

// may produce incorrect results, if incorrect data is fed,

// but should not lead to MicroPython crashes or similar

// grave issues (in other words, only user app should be,

// affected, not system).

#ifndef MICROPY_FULL_CHECKS

#define MICROPY_FULL_CHECKS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether POSIX-semantics non-blocking streams are supported

#ifndef MICROPY_STREAMS_NON_BLOCK

#define MICROPY_STREAMS_NON_BLOCK (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to provide stream functions with POSIX-like signatures

// (useful for porting existing libraries to MicroPython).

#ifndef MICROPY_STREAMS_POSIX_API

#define MICROPY_STREAMS_POSIX_API (0)

#endif

// Whether to call __init__ when importing builtin modules for the first time

#ifndef MICROPY_MODULE_BUILTIN_INIT

#define MICROPY_MODULE_BUILTIN_INIT (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to support module-level __getattr__ (see PEP 562)

#ifndef MICROPY_MODULE_GETATTR

#define MICROPY_MODULE_GETATTR (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether module weak links are supported

#ifndef MICROPY_MODULE_WEAK_LINKS

#define MICROPY_MODULE_WEAK_LINKS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to enable importing foo.py with __name__ set to '__main__'

// Used by the unix port for the -m flag.

#ifndef MICROPY_MODULE_OVERRIDE_MAIN_IMPORT

#define MICROPY_MODULE_OVERRIDE_MAIN_IMPORT (0)

#endif

// Whether frozen modules are supported in the form of strings

#ifndef MICROPY_MODULE_FROZEN_STR

#define MICROPY_MODULE_FROZEN_STR (0)

#endif

// Whether frozen modules are supported in the form of .mpy files

#ifndef MICROPY_MODULE_FROZEN_MPY

#define MICROPY_MODULE_FROZEN_MPY (0)

#endif

// Convenience macro for whether frozen modules are supported

#ifndef MICROPY_MODULE_FROZEN

#define MICROPY_MODULE_FROZEN (MICROPY_MODULE_FROZEN_STR || MICROPY_MODULE_FROZEN_MPY)

#endif

// Whether you can override builtins in the builtins module

#ifndef MICROPY_CAN_OVERRIDE_BUILTINS

#define MICROPY_CAN_OVERRIDE_BUILTINS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to check that the "self" argument of a builtin method has the

// correct type. Such an explicit check is only needed if a builtin

// method escapes to Python land without a first argument, eg

// list.append([], 1). Without this check such calls will have undefined

// behaviour (usually segfault) if the first argument is the wrong type.

#ifndef MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG

#define MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to use internally defined errno's (otherwise system provided ones)

#ifndef MICROPY_USE_INTERNAL_ERRNO

#define MICROPY_USE_INTERNAL_ERRNO (0)

#endif

// Whether to use internally defined *printf() functions (otherwise external ones)

#ifndef MICROPY_USE_INTERNAL_PRINTF

#define MICROPY_USE_INTERNAL_PRINTF (1)

#endif

// Support for internal scheduler

#ifndef MICROPY_ENABLE_SCHEDULER

#define MICROPY_ENABLE_SCHEDULER (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Maximum number of entries in the scheduler

#ifndef MICROPY_SCHEDULER_DEPTH

#define MICROPY_SCHEDULER_DEPTH (4)

#endif

// Support for generic VFS sub-system

#ifndef MICROPY_VFS

#define MICROPY_VFS (0)

#endif

// Support for VFS POSIX component, to mount a POSIX filesystem within VFS

#ifndef MICROPY_VFS

#define MICROPY_VFS_POSIX (0)

#endif

// Support for VFS FAT component, to mount a FAT filesystem within VFS

#ifndef MICROPY_VFS

#define MICROPY_VFS_FAT (0)

#endif

// 1 when building C code for native mpy files. 0 otherwise.

#ifndef MICROPY_ENABLE_DYNRUNTIME

#define MICROPY_ENABLE_DYNRUNTIME (0)

#endif

/*****************************************************************************/

/* Fine control over Python builtins, classes, modules, etc */

// Whether to support multiple inheritance of Python classes. Multiple

// inheritance makes some C functions inherently recursive, and adds a bit of

// code overhead.

#ifndef MICROPY_MULTIPLE_INHERITANCE

#define MICROPY_MULTIPLE_INHERITANCE (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Whether to implement attributes on functions

#ifndef MICROPY_PY_FUNCTION_ATTRS

#define MICROPY_PY_FUNCTION_ATTRS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to support the descriptors __get__, __set__, __delete__

// This costs some code size and makes load/store/delete of instance

// attributes slower for the classes that use this feature

#ifndef MICROPY_PY_DESCRIPTORS

#define MICROPY_PY_DESCRIPTORS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to support class __delattr__ and __setattr__ methods

// This costs some code size and makes store/delete of instance

// attributes slower for the classes that use this feature

#ifndef MICROPY_PY_DELATTR_SETATTR

#define MICROPY_PY_DELATTR_SETATTR (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Support for async/await/async for/async with

#ifndef MICROPY_PY_ASYNC_AWAIT

#define MICROPY_PY_ASYNC_AWAIT (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Support for literal string interpolation, f-strings (see PEP 498, Python 3.6+)

#ifndef MICROPY_PY_FSTRINGS

#define MICROPY_PY_FSTRINGS (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Support for assignment expressions with := (see PEP 572, Python 3.8+)

#ifndef MICROPY_PY_ASSIGN_EXPR

#define MICROPY_PY_ASSIGN_EXPR (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Non-standard .pend_throw() method for generators, allowing for

// Future-like behavior with respect to exception handling: an

// exception set with .pend_throw() will activate on the next call

// to generator's .send() or .__next__(). (This is useful to implement

// async schedulers.)

#ifndef MICROPY_PY_GENERATOR_PEND_THROW

#define MICROPY_PY_GENERATOR_PEND_THROW (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_CORE_FEATURES)

#endif

// Issue a warning when comparing str and bytes objects

#ifndef MICROPY_PY_STR_BYTES_CMP_WARN

#define MICROPY_PY_STR_BYTES_CMP_WARN (0)

#endif

// Whether str object is proper unicode

#ifndef MICROPY_PY_BUILTINS_STR_UNICODE

#define MICROPY_PY_BUILTINS_STR_UNICODE (MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_EXTRA_FEATURES)

#endif

// Whether to check for valid UTF-8 when converting bytes to str