2014-05-03 16:27:38 -06:00
/*
2017-06-30 01:22:17 -06:00
* This file is part of the MicroPython project , http : //micropython.org/
2014-05-03 16:27:38 -06:00
*
* The MIT License ( MIT )
*
* 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 .
*/
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 15:14:58 -06:00
# ifndef MICROPY_INCLUDED_PY_OBJ_H
# define MICROPY_INCLUDED_PY_OBJ_H
2014-12-28 18:02:19 -07:00
# include "py/mpconfig.h"
# include "py/misc.h"
# include "py/qstr.h"
2015-04-09 16:56:15 -06:00
# include "py/mpprint.h"
2017-08-28 21:04:01 -06:00
# include "py/runtime0.h"
2014-05-03 16:27:38 -06:00
2016-08-14 18:56:55 -06:00
// This is the definition of the opaque MicroPython object type.
// All concrete objects have an encoding within this type and the
// particular encoding is specified by MICROPY_OBJ_REPR.
2015-11-27 10:09:11 -07:00
# if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
typedef uint64_t mp_obj_t ;
typedef uint64_t mp_const_obj_t ;
# else
2016-08-14 18:56:55 -06:00
typedef void * mp_obj_t ;
typedef const void * mp_const_obj_t ;
2015-11-27 10:09:11 -07:00
# endif
2013-12-21 11:17:45 -07:00
2016-01-03 08:55:55 -07:00
// This mp_obj_type_t struct is a concrete MicroPython object which holds info
// about a type. See below for actual definition of the struct.
typedef struct _mp_obj_type_t mp_obj_type_t ;
2013-12-21 11:17:45 -07:00
2016-01-03 08:55:55 -07:00
// Anything that wants to be a concrete MicroPython object must have mp_obj_base_t
// as its first member (small ints, qstr objs and inline floats are not concrete).
2013-12-21 11:17:45 -07:00
struct _mp_obj_base_t {
2016-01-03 08:55:55 -07:00
const mp_obj_type_t * type MICROPY_OBJ_BASE_ALIGNMENT ;
2013-12-21 11:17:45 -07:00
} ;
2014-01-06 10:52:29 -07:00
typedef struct _mp_obj_base_t mp_obj_base_t ;
2013-12-21 11:17:45 -07:00
2014-04-17 16:19:36 -06:00
// These fake objects are used to indicate certain things in arguments or return
// values, and should only be used when explicitly allowed.
//
2014-05-21 12:42:43 -06:00
// - MP_OBJ_NULL : used to indicate the absence of an object, or unsupported operation.
2014-04-17 16:19:36 -06:00
// - MP_OBJ_STOP_ITERATION : used instead of throwing a StopIteration, for efficiency.
// - MP_OBJ_SENTINEL : used for various internal purposes where one needs
// an object which is unique from all other objects, including MP_OBJ_NULL.
//
// For debugging purposes they are all different. For non-debug mode, we alias
// as many as we can to MP_OBJ_NULL because it's cheaper to load/compare 0.
2019-03-07 21:48:20 -07:00
# if MICROPY_DEBUG_MP_OBJ_SENTINELS
2015-11-27 10:01:44 -07:00
# define MP_OBJ_NULL (MP_OBJ_FROM_PTR((void*)0))
# define MP_OBJ_STOP_ITERATION (MP_OBJ_FROM_PTR((void*)4))
# define MP_OBJ_SENTINEL (MP_OBJ_FROM_PTR((void*)8))
2019-03-07 21:48:20 -07:00
# else
# define MP_OBJ_NULL (MP_OBJ_FROM_PTR((void*)0))
# define MP_OBJ_STOP_ITERATION (MP_OBJ_FROM_PTR((void*)0))
# define MP_OBJ_SENTINEL (MP_OBJ_FROM_PTR((void*)4))
2014-04-17 16:19:36 -06:00
# endif
2014-04-17 15:10:53 -06:00
2015-03-29 07:05:46 -06:00
// These macros/inline functions operate on objects and depend on the
// particular object representation. They are used to query, pack and
// unpack small ints, qstrs and full object pointers.
2013-12-21 11:17:45 -07:00
2015-03-29 07:05:46 -06:00
# if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A
2014-01-08 10:33:12 -07:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_small_int ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 1 ) ! = 0 ) ; }
2014-07-03 06:25:24 -06:00
# define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 1)
2016-04-26 02:51:37 -06:00
# define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 1) | 1))
2014-01-08 10:33:12 -07:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_qstr ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 3 ) = = 2 ) ; }
2015-01-16 10:47:07 -07:00
# define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2)
2014-12-28 18:02:19 -07:00
# define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 2))
2013-12-21 11:17:45 -07:00
2015-10-17 15:57:34 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2015-11-27 06:38:15 -07:00
# define mp_const_float_e MP_ROM_PTR(&mp_const_float_e_obj)
# define mp_const_float_pi MP_ROM_PTR(&mp_const_float_pi_obj)
2015-10-17 15:57:34 -06:00
extern const struct _mp_obj_float_t mp_const_float_e_obj ;
extern const struct _mp_obj_float_t mp_const_float_pi_obj ;
2019-01-30 00:49:52 -07:00
# define mp_obj_is_float(o) mp_obj_is_type((o), &mp_type_float)
2015-10-17 15:57:34 -06:00
mp_float_t mp_obj_float_get ( mp_obj_t self_in ) ;
mp_obj_t mp_obj_new_float ( mp_float_t value ) ;
# endif
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_obj ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 3 ) = = 0 ) ; }
# elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_small_int ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 3 ) = = 1 ) ; }
# define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 2)
2016-04-26 02:51:37 -06:00
# define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 2) | 1))
2015-03-29 07:05:46 -06:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_qstr ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 3 ) = = 3 ) ; }
# define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2)
# define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 3))
2015-10-17 15:57:34 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2015-11-27 06:38:15 -07:00
# define mp_const_float_e MP_ROM_PTR(&mp_const_float_e_obj)
# define mp_const_float_pi MP_ROM_PTR(&mp_const_float_pi_obj)
2015-10-17 15:57:34 -06:00
extern const struct _mp_obj_float_t mp_const_float_e_obj ;
extern const struct _mp_obj_float_t mp_const_float_pi_obj ;
2019-01-30 00:49:52 -07:00
# define mp_obj_is_float(o) mp_obj_is_type((o), &mp_type_float)
2015-10-17 15:57:34 -06:00
mp_float_t mp_obj_float_get ( mp_obj_t self_in ) ;
mp_obj_t mp_obj_new_float ( mp_float_t value ) ;
# endif
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_obj ( mp_const_obj_t o )
2015-03-29 07:05:46 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 1 ) = = 0 ) ; }
2015-10-17 16:20:57 -06:00
# elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_small_int ( mp_const_obj_t o )
2015-10-17 16:20:57 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 1 ) ! = 0 ) ; }
# define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 1)
2016-04-26 02:51:37 -06:00
# define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 1) | 1))
2015-10-17 16:20:57 -06:00
2018-07-02 14:52:53 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2015-12-18 14:44:01 -07:00
# define mp_const_float_e MP_ROM_PTR((mp_obj_t)(((0x402df854 & ~3) | 2) + 0x80800000))
# define mp_const_float_pi MP_ROM_PTR((mp_obj_t)(((0x40490fdb & ~3) | 2) + 0x80800000))
2015-10-17 16:20:57 -06:00
static inline bool mp_obj_is_float ( mp_const_obj_t o )
2015-11-06 16:25:10 -07:00
{ return ( ( ( mp_uint_t ) ( o ) ) & 3 ) = = 2 & & ( ( ( mp_uint_t ) ( o ) ) & 0xff800007 ) ! = 0x00000006 ; }
2015-10-17 16:20:57 -06:00
static inline mp_float_t mp_obj_float_get ( mp_const_obj_t o ) {
union {
mp_float_t f ;
mp_uint_t u ;
2015-11-06 16:25:10 -07:00
} num = { . u = ( ( mp_uint_t ) o - 0x80800000 ) & ~ 3 } ;
2015-10-17 16:20:57 -06:00
return num . f ;
}
static inline mp_obj_t mp_obj_new_float ( mp_float_t f ) {
union {
mp_float_t f ;
mp_uint_t u ;
} num = { . f = f } ;
2015-11-06 16:25:10 -07:00
return ( mp_obj_t ) ( ( ( num . u & ~ 0x3 ) | 2 ) + 0x80800000 ) ;
2015-10-17 16:20:57 -06:00
}
2018-07-02 14:52:53 -06:00
# endif
2015-10-17 16:20:57 -06:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_qstr ( mp_const_obj_t o )
2015-11-06 16:25:10 -07:00
{ return ( ( ( mp_uint_t ) ( o ) ) & 0xff800007 ) = = 0x00000006 ; }
# define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 3)
# define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 3) | 0x00000006))
2015-10-17 16:20:57 -06:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_obj ( mp_const_obj_t o )
2015-10-17 16:20:57 -06:00
{ return ( ( ( ( mp_int_t ) ( o ) ) & 3 ) = = 0 ) ; }
2015-11-27 10:09:11 -07:00
# elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_small_int ( mp_const_obj_t o )
2018-10-01 00:36:46 -06:00
{ return ( ( ( ( uint64_t ) ( o ) ) & 0xffff000000000000 ) = = 0x0001000000000000 ) ; }
2017-12-11 04:39:12 -07:00
# define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)((o) << 16)) >> 17)
# define MP_OBJ_NEW_SMALL_INT(small_int) (((((uint64_t)(small_int)) & 0x7fffffffffff) << 1) | 0x0001000000000001)
2015-11-27 10:09:11 -07:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_qstr ( mp_const_obj_t o )
2018-10-01 00:36:46 -06:00
{ return ( ( ( ( uint64_t ) ( o ) ) & 0xffff000000000000 ) = = 0x0002000000000000 ) ; }
2016-01-08 06:43:13 -07:00
# define MP_OBJ_QSTR_VALUE(o) ((((uint32_t)(o)) >> 1) & 0xffffffff)
2019-12-27 05:33:34 -07:00
# define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)(((uint64_t)(((uint32_t)(qst)) << 1)) | 0x0002000000000001))
2015-11-27 10:09:11 -07:00
# if MICROPY_PY_BUILTINS_FLOAT
2018-07-08 07:45:05 -06:00
# if MICROPY_FLOAT_IMPL != MICROPY_FLOAT_IMPL_DOUBLE
# error MICROPY_OBJ_REPR_D requires MICROPY_FLOAT_IMPL_DOUBLE
# endif
2018-05-01 07:25:18 -06:00
# define mp_const_float_e {((mp_obj_t)((uint64_t)0x4005bf0a8b145769 + 0x8004000000000000))}
2015-11-27 10:09:11 -07:00
# define mp_const_float_pi {((mp_obj_t)((uint64_t)0x400921fb54442d18 + 0x8004000000000000))}
static inline bool mp_obj_is_float ( mp_const_obj_t o ) {
return ( ( uint64_t ) ( o ) & 0xfffc000000000000 ) ! = 0 ;
}
static inline mp_float_t mp_obj_float_get ( mp_const_obj_t o ) {
union {
mp_float_t f ;
uint64_t r ;
} num = { . r = o - 0x8004000000000000 } ;
return num . f ;
}
static inline mp_obj_t mp_obj_new_float ( mp_float_t f ) {
union {
mp_float_t f ;
uint64_t r ;
} num = { . f = f } ;
return num . r + 0x8004000000000000 ;
}
# endif
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_obj ( mp_const_obj_t o )
2015-11-27 10:09:11 -07:00
{ return ( ( ( ( uint64_t ) ( o ) ) & 0xffff000000000000 ) = = 0x0000000000000000 ) ; }
# define MP_OBJ_TO_PTR(o) ((void*)(uintptr_t)(o))
# define MP_OBJ_FROM_PTR(p) ((mp_obj_t)((uintptr_t)(p)))
// rom object storage needs special handling to widen 32-bit pointer to 64-bits
typedef union _mp_rom_obj_t { uint64_t u64 ; struct { const void * lo , * hi ; } u32 ; } mp_rom_obj_t ;
# define MP_ROM_INT(i) {MP_OBJ_NEW_SMALL_INT(i)}
# define MP_ROM_QSTR(q) {MP_OBJ_NEW_QSTR(q)}
# if MP_ENDIANNESS_LITTLE
# define MP_ROM_PTR(p) {.u32 = {.lo = (p), .hi = NULL}}
# else
# define MP_ROM_PTR(p) {.u32 = {.lo = NULL, .hi = (p)}}
# endif
2015-03-29 07:05:46 -06:00
# endif
2015-03-25 01:25:41 -06:00
// Macros to convert between mp_obj_t and concrete object types.
// These are identity operations in MicroPython, but ability to override
// these operations are provided to experiment with other methods of
// object representation and memory management.
// Cast mp_obj_t to object pointer
2015-11-27 10:01:44 -07:00
# ifndef MP_OBJ_TO_PTR
# define MP_OBJ_TO_PTR(o) ((void*)o)
2015-03-25 01:25:41 -06:00
# endif
// Cast object pointer to mp_obj_t
2015-11-27 10:01:44 -07:00
# ifndef MP_OBJ_FROM_PTR
# define MP_OBJ_FROM_PTR(p) ((mp_obj_t)p)
2015-03-25 01:25:41 -06:00
# endif
2015-11-27 06:38:15 -07:00
// Macros to create objects that are stored in ROM.
2019-12-15 21:40:05 -07:00
# ifndef MP_ROM_NONE
# define MP_ROM_NONE MP_ROM_PTR(&mp_const_none_obj)
# endif
2019-12-15 21:42:17 -07:00
# ifndef MP_ROM_FALSE
# define MP_ROM_FALSE MP_ROM_PTR(&mp_const_false_obj)
# define MP_ROM_TRUE MP_ROM_PTR(&mp_const_true_obj)
# endif
2015-11-27 06:38:15 -07:00
# ifndef MP_ROM_INT
typedef mp_const_obj_t mp_rom_obj_t ;
# define MP_ROM_INT(i) MP_OBJ_NEW_SMALL_INT(i)
# define MP_ROM_QSTR(q) MP_OBJ_NEW_QSTR(q)
# define MP_ROM_PTR(p) (p)
/* for testing
typedef struct _mp_rom_obj_t { mp_const_obj_t o ; } mp_rom_obj_t ;
# define MP_ROM_INT(i) {MP_OBJ_NEW_SMALL_INT(i)}
# define MP_ROM_QSTR(q) {MP_OBJ_NEW_QSTR(q)}
# define MP_ROM_PTR(p) {.o = p}
*/
# endif
2013-12-21 11:17:45 -07:00
// These macros are used to declare and define constant function objects
// You can put "static" in front of the definitions to make them local
2016-10-17 18:49:27 -06:00
# define MP_DECLARE_CONST_FUN_OBJ_0(obj_name) extern const mp_obj_fun_builtin_fixed_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_1(obj_name) extern const mp_obj_fun_builtin_fixed_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_2(obj_name) extern const mp_obj_fun_builtin_fixed_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_3(obj_name) extern const mp_obj_fun_builtin_fixed_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_VAR(obj_name) extern const mp_obj_fun_builtin_var_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name) extern const mp_obj_fun_builtin_var_t obj_name
# define MP_DECLARE_CONST_FUN_OBJ_KW(obj_name) extern const mp_obj_fun_builtin_var_t obj_name
2013-12-17 11:27:24 -07:00
2018-09-13 21:39:17 -06:00
# define MP_OBJ_FUN_ARGS_MAX (0xffff) // to set maximum value in n_args_max below
2019-01-24 22:03:05 -07:00
# define MP_OBJ_FUN_MAKE_SIG(n_args_min, n_args_max, takes_kw) ((uint32_t)((((uint32_t)(n_args_min)) << 17) | (((uint32_t)(n_args_max)) << 1) | ((takes_kw) ? 1 : 0)))
2018-09-13 21:39:17 -06:00
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_fixed_t obj_name = \
{ { & mp_type_fun_builtin_0 } , . fun . _0 = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_fixed_t obj_name = \
{ { & mp_type_fun_builtin_1 } , . fun . _1 = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_fixed_t obj_name = \
{ { & mp_type_fun_builtin_2 } , . fun . _2 = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_fixed_t obj_name = \
{ { & mp_type_fun_builtin_3 } , . fun . _3 = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_var_t obj_name = \
2018-09-13 21:39:17 -06:00
{ { & mp_type_fun_builtin_var } , MP_OBJ_FUN_MAKE_SIG ( n_args_min , MP_OBJ_FUN_ARGS_MAX , false ) , . fun . var = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_var_t obj_name = \
2018-09-13 21:39:17 -06:00
{ { & mp_type_fun_builtin_var } , MP_OBJ_FUN_MAKE_SIG ( n_args_min , n_args_max , false ) , . fun . var = fun_name }
2016-01-03 04:53:44 -07:00
# define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, n_args_min, fun_name) \
2016-10-17 18:49:27 -06:00
const mp_obj_fun_builtin_var_t obj_name = \
2018-09-13 21:39:17 -06:00
{ { & mp_type_fun_builtin_var } , MP_OBJ_FUN_MAKE_SIG ( n_args_min , MP_OBJ_FUN_ARGS_MAX , true ) , . fun . kw = fun_name }
2014-01-07 10:29:16 -07:00
2014-12-09 09:19:48 -07:00
// These macros are used to define constant map/dict objects
2014-03-26 15:47:19 -06:00
// You can put "static" in front of the definition to make it local
2014-12-09 09:19:48 -07:00
# define MP_DEFINE_CONST_MAP(map_name, table_name) \
const mp_map_t map_name = { \
. all_keys_are_qstrs = 1 , \
2015-03-17 17:25:04 -06:00
. is_fixed = 1 , \
. is_ordered = 1 , \
2014-12-09 09:19:48 -07:00
. used = MP_ARRAY_SIZE ( table_name ) , \
. alloc = MP_ARRAY_SIZE ( table_name ) , \
2015-11-27 06:38:15 -07:00
. table = ( mp_map_elem_t * ) ( mp_rom_map_elem_t * ) table_name , \
2014-12-09 09:19:48 -07:00
}
2014-03-26 15:47:19 -06:00
# define MP_DEFINE_CONST_DICT(dict_name, table_name) \
const mp_obj_dict_t dict_name = { \
2014-03-29 07:43:38 -06:00
. base = { & mp_type_dict } , \
2014-03-26 15:47:19 -06:00
. map = { \
. all_keys_are_qstrs = 1 , \
2015-03-17 17:25:04 -06:00
. is_fixed = 1 , \
. is_ordered = 1 , \
2014-11-29 07:39:27 -07:00
. used = MP_ARRAY_SIZE ( table_name ) , \
. alloc = MP_ARRAY_SIZE ( table_name ) , \
2015-11-27 06:38:15 -07:00
. table = ( mp_map_elem_t * ) ( mp_rom_map_elem_t * ) table_name , \
2014-03-26 15:47:19 -06:00
} , \
}
2014-01-11 12:22:29 -07:00
// These macros are used to declare and define constant staticmethond and classmethod objects
// You can put "static" in front of the definitions to make them local
2015-11-27 06:38:15 -07:00
# define MP_DECLARE_CONST_STATICMETHOD_OBJ(obj_name) extern const mp_rom_obj_static_class_method_t obj_name
# define MP_DECLARE_CONST_CLASSMETHOD_OBJ(obj_name) extern const mp_rom_obj_static_class_method_t obj_name
2014-01-11 12:22:29 -07:00
2015-11-27 06:38:15 -07:00
# define MP_DEFINE_CONST_STATICMETHOD_OBJ(obj_name, fun_name) const mp_rom_obj_static_class_method_t obj_name = {{&mp_type_staticmethod}, fun_name}
# define MP_DEFINE_CONST_CLASSMETHOD_OBJ(obj_name, fun_name) const mp_rom_obj_static_class_method_t obj_name = {{&mp_type_classmethod}, fun_name}
2014-01-11 12:22:29 -07:00
2019-02-17 20:58:44 -07:00
// Declare a module as a builtin, processed by makemoduledefs.py
// param module_name: MP_QSTR_<module name>
// param obj_module: mp_obj_module_t instance
// prarm enabled_define: used as `#if (enabled_define) around entry`
# define MP_REGISTER_MODULE(module_name, obj_module, enabled_define)
2014-03-30 06:54:02 -06:00
// Underlying map/hash table implementation (not dict object or map function)
typedef struct _mp_map_elem_t {
mp_obj_t key ;
mp_obj_t value ;
} mp_map_elem_t ;
2015-11-27 06:38:15 -07:00
typedef struct _mp_rom_map_elem_t {
mp_rom_obj_t key ;
mp_rom_obj_t value ;
} mp_rom_map_elem_t ;
2014-03-30 06:54:02 -06:00
// TODO maybe have a truncated mp_map_t for fixed tables, since alloc=used
// put alloc last in the structure, so the truncated version does not need it
// this would save 1 ROM word for all ROM objects that have a locals_dict
// would also need a trucated dict structure
typedef struct _mp_map_t {
2017-02-07 17:00:15 -07:00
size_t all_keys_are_qstrs : 1 ;
size_t is_fixed : 1 ; // a fixed array that can't be modified; must also be ordered
size_t is_ordered : 1 ; // an ordered array
size_t used : ( 8 * sizeof ( size_t ) - 3 ) ;
size_t alloc ;
2014-03-30 06:54:02 -06:00
mp_map_elem_t * table ;
} mp_map_t ;
2015-03-20 11:41:37 -06:00
// mp_set_lookup requires these constants to have the values they do
2014-03-30 06:54:02 -06:00
typedef enum _mp_map_lookup_kind_t {
2015-03-20 11:41:37 -06:00
MP_MAP_LOOKUP = 0 ,
MP_MAP_LOOKUP_ADD_IF_NOT_FOUND = 1 ,
MP_MAP_LOOKUP_REMOVE_IF_FOUND = 2 ,
MP_MAP_LOOKUP_ADD_IF_NOT_FOUND_OR_REMOVE_IF_FOUND = 3 , // only valid for mp_set_lookup
2014-03-30 06:54:02 -06:00
} mp_map_lookup_kind_t ;
2014-11-26 12:17:16 -07:00
extern const mp_map_t mp_const_empty_map ;
2019-01-30 03:57:29 -07:00
static inline bool mp_map_slot_is_filled ( const mp_map_t * map , size_t pos ) { return ( ( map ) - > table [ pos ] . key ! = MP_OBJ_NULL & & ( map ) - > table [ pos ] . key ! = MP_OBJ_SENTINEL ) ; }
2014-04-05 14:53:54 -06:00
2017-02-07 17:00:15 -07:00
void mp_map_init ( mp_map_t * map , size_t n ) ;
void mp_map_init_fixed_table ( mp_map_t * map , size_t n , const mp_obj_t * table ) ;
mp_map_t * mp_map_new ( size_t n ) ;
2014-03-30 06:54:02 -06:00
void mp_map_deinit ( mp_map_t * map ) ;
void mp_map_free ( mp_map_t * map ) ;
2015-04-04 08:53:11 -06:00
mp_map_elem_t * mp_map_lookup ( mp_map_t * map , mp_obj_t index , mp_map_lookup_kind_t lookup_kind ) ;
2014-03-30 06:54:02 -06:00
void mp_map_clear ( mp_map_t * map ) ;
2014-04-04 19:14:22 -06:00
void mp_map_dump ( mp_map_t * map ) ;
2014-03-30 06:54:02 -06:00
// Underlying set implementation (not set object)
typedef struct _mp_set_t {
2017-02-07 17:00:15 -07:00
size_t alloc ;
size_t used ;
2014-03-30 06:54:02 -06:00
mp_obj_t * table ;
} mp_set_t ;
2019-01-30 03:57:29 -07:00
static inline bool mp_set_slot_is_filled ( const mp_set_t * set , size_t pos ) { return ( ( set ) - > table [ pos ] ! = MP_OBJ_NULL & & ( set ) - > table [ pos ] ! = MP_OBJ_SENTINEL ) ; }
2014-04-05 14:53:54 -06:00
2017-02-07 17:00:15 -07:00
void mp_set_init ( mp_set_t * set , size_t n ) ;
2014-03-30 06:54:02 -06:00
mp_obj_t mp_set_lookup ( mp_set_t * set , mp_obj_t index , mp_map_lookup_kind_t lookup_kind ) ;
2014-04-05 10:17:19 -06:00
mp_obj_t mp_set_remove_first ( mp_set_t * set ) ;
2014-03-30 06:54:02 -06:00
void mp_set_clear ( mp_set_t * set ) ;
2013-12-21 11:17:45 -07:00
// Type definitions for methods
typedef mp_obj_t ( * mp_fun_0_t ) ( void ) ;
typedef mp_obj_t ( * mp_fun_1_t ) ( mp_obj_t ) ;
typedef mp_obj_t ( * mp_fun_2_t ) ( mp_obj_t , mp_obj_t ) ;
2014-01-03 18:15:01 -07:00
typedef mp_obj_t ( * mp_fun_3_t ) ( mp_obj_t , mp_obj_t , mp_obj_t ) ;
2016-01-03 07:21:40 -07:00
typedef mp_obj_t ( * mp_fun_var_t ) ( size_t n , const mp_obj_t * ) ;
2016-04-04 06:35:44 -06:00
// mp_fun_kw_t takes mp_map_t* (and not const mp_map_t*) to ease passing
// this arg to mp_map_lookup().
2016-01-03 07:21:40 -07:00
typedef mp_obj_t ( * mp_fun_kw_t ) ( size_t n , const mp_obj_t * , mp_map_t * ) ;
2013-12-21 11:17:45 -07:00
2014-01-13 10:19:16 -07:00
typedef enum {
2014-05-01 16:51:25 -06:00
PRINT_STR = 0 ,
PRINT_REPR = 1 ,
PRINT_EXC = 2 , // Special format for printing exception in unhandled exception message
2014-09-17 15:56:34 -06:00
PRINT_JSON = 3 ,
2015-12-20 07:44:36 -07:00
PRINT_RAW = 4 , // Special format for printing bytes as an undercorated string
2014-09-17 15:56:34 -06:00
PRINT_EXC_SUBCLASS = 0x80 , // Internal flag for printing exception subclasses
2014-01-13 10:19:16 -07:00
} mp_print_kind_t ;
2016-01-09 16:14:54 -07:00
typedef struct _mp_obj_iter_buf_t {
mp_obj_base_t base ;
mp_obj_t buf [ 3 ] ;
} mp_obj_iter_buf_t ;
2017-03-22 23:36:08 -06:00
// The number of slots that an mp_obj_iter_buf_t needs on the Python value stack.
// It's rounded up in case mp_obj_base_t is smaller than mp_obj_t (eg for OBJ_REPR_D).
# define MP_OBJ_ITER_BUF_NSLOTS ((sizeof(mp_obj_iter_buf_t) + sizeof(mp_obj_t) - 1) / sizeof(mp_obj_t))
2015-04-09 16:56:15 -06:00
typedef void ( * mp_print_fun_t ) ( const mp_print_t * print , mp_obj_t o , mp_print_kind_t kind ) ;
2016-01-03 08:55:55 -07:00
typedef mp_obj_t ( * mp_make_new_fun_t ) ( const mp_obj_type_t * type , size_t n_args , size_t n_kw , const mp_obj_t * args ) ;
2016-01-03 02:59:18 -07:00
typedef mp_obj_t ( * mp_call_fun_t ) ( mp_obj_t fun , size_t n_args , size_t n_kw , const mp_obj_t * args ) ;
2017-08-28 21:04:01 -06:00
typedef mp_obj_t ( * mp_unary_op_fun_t ) ( mp_unary_op_t op , mp_obj_t ) ;
typedef mp_obj_t ( * mp_binary_op_fun_t ) ( mp_binary_op_t op , mp_obj_t , mp_obj_t ) ;
2015-04-01 08:10:50 -06:00
typedef void ( * mp_attr_fun_t ) ( mp_obj_t self_in , qstr attr , mp_obj_t * dest ) ;
2014-04-17 15:10:53 -06:00
typedef mp_obj_t ( * mp_subscr_fun_t ) ( mp_obj_t self_in , mp_obj_t index , mp_obj_t value ) ;
2016-01-09 16:14:54 -07:00
typedef mp_obj_t ( * mp_getiter_fun_t ) ( mp_obj_t self_in , mp_obj_iter_buf_t * iter_buf ) ;
2013-12-21 11:17:45 -07:00
2014-01-07 11:12:26 -07:00
// Buffer protocol
2014-04-18 15:29:21 -06:00
typedef struct _mp_buffer_info_t {
2014-10-03 11:44:14 -06:00
void * buf ; // can be NULL if len == 0
2016-03-15 06:20:57 -06:00
size_t len ; // in bytes
2014-10-03 11:44:14 -06:00
int typecode ; // as per binary.h
2014-04-18 15:29:21 -06:00
} mp_buffer_info_t ;
# define MP_BUFFER_READ (1)
# define MP_BUFFER_WRITE (2)
# define MP_BUFFER_RW (MP_BUFFER_READ | MP_BUFFER_WRITE)
2014-01-07 11:12:26 -07:00
typedef struct _mp_buffer_p_t {
2014-08-30 07:28:06 -06:00
mp_int_t ( * get_buffer ) ( mp_obj_t obj , mp_buffer_info_t * bufinfo , mp_uint_t flags ) ;
2014-01-07 11:12:26 -07:00
} mp_buffer_p_t ;
2014-08-30 07:28:06 -06:00
bool mp_get_buffer ( mp_obj_t obj , mp_buffer_info_t * bufinfo , mp_uint_t flags ) ;
void mp_get_buffer_raise ( mp_obj_t obj , mp_buffer_info_t * bufinfo , mp_uint_t flags ) ;
2014-01-07 11:12:26 -07:00
2013-12-21 11:17:45 -07:00
struct _mp_obj_type_t {
2017-04-05 18:25:32 -06:00
// A type is an object so must start with this entry, which points to mp_type_type.
2013-12-21 11:17:45 -07:00
mp_obj_base_t base ;
2017-04-05 18:25:32 -06:00
2018-05-25 00:48:19 -06:00
// Flags associated with this type.
uint16_t flags ;
// The name of this type, a qstr.
uint16_t name ;
2017-04-05 18:25:32 -06:00
// Corresponds to __repr__ and __str__ special methods.
2013-12-21 11:17:45 -07:00
mp_print_fun_t print ;
2017-04-05 18:25:32 -06:00
// Corresponds to __new__ and __init__ special methods, to make an instance of the type.
mp_make_new_fun_t make_new ;
// Corresponds to __call__ special method, ie T(...).
2014-01-18 07:10:48 -07:00
mp_call_fun_t call ;
2013-12-21 11:17:45 -07:00
2017-04-05 18:25:32 -06:00
// Implements unary and binary operations.
// Can return MP_OBJ_NULL if the operation is not supported.
mp_unary_op_fun_t unary_op ;
mp_binary_op_fun_t binary_op ;
// Implements load, store and delete attribute.
2015-04-01 08:10:50 -06:00
//
// dest[0] = MP_OBJ_NULL means load
// return: for fail, do nothing
// for attr, dest[0] = value
// for method, dest[0] = method, dest[1] = self
//
// dest[0,1] = {MP_OBJ_SENTINEL, MP_OBJ_NULL} means delete
// dest[0,1] = {MP_OBJ_SENTINEL, object} means store
// return: for fail, do nothing
// for success set dest[0] = MP_OBJ_NULL
mp_attr_fun_t attr ;
2014-04-08 14:32:29 -06:00
2017-04-05 18:25:32 -06:00
// Implements load, store and delete subscripting:
// - value = MP_OBJ_SENTINEL means load
// - value = MP_OBJ_NULL means delete
// - all other values mean store the value
// Can return MP_OBJ_NULL if operation not supported.
mp_subscr_fun_t subscr ;
2014-02-15 04:34:50 -07:00
2017-04-05 18:25:32 -06:00
// Corresponds to __iter__ special method.
// Can use the given mp_obj_iter_buf_t to store iterator object,
// otherwise can return a pointer to an object on the heap.
2016-01-09 16:14:54 -07:00
mp_getiter_fun_t getiter ;
2017-04-05 18:25:32 -06:00
// Corresponds to __next__ special method. May return MP_OBJ_STOP_ITERATION
// as an optimisation instead of raising StopIteration() with no args.
mp_fun_1_t iternext ;
2013-12-21 11:17:45 -07:00
2017-04-05 18:25:32 -06:00
// Implements the buffer protocol if supported by this type.
2014-01-07 11:12:26 -07:00
mp_buffer_p_t buffer_p ;
2017-04-05 18:25:32 -06:00
2016-06-18 09:19:24 -06:00
// One of disjoint protocols (interfaces), like mp_stream_p_t, etc.
const void * protocol ;
2014-01-07 11:12:26 -07:00
2017-04-05 20:09:01 -06:00
// A pointer to the parents of this type:
// - 0 parents: pointer is NULL (object is implicitly the single parent)
// - 1 parent: a pointer to the type of that parent
// - 2 or more parents: pointer to a tuple object containing the parent types
const void * parent ;
2013-12-21 11:17:45 -07:00
2017-04-05 18:25:32 -06:00
// A dict mapping qstrs to objects local methods/constants/etc.
struct _mp_obj_dict_t * locals_dict ;
2013-12-21 11:17:45 -07:00
} ;
2014-02-15 09:10:44 -07:00
// Constant types, globally accessible
extern const mp_obj_type_t mp_type_type ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_object ;
extern const mp_obj_type_t mp_type_NoneType ;
extern const mp_obj_type_t mp_type_bool ;
extern const mp_obj_type_t mp_type_int ;
extern const mp_obj_type_t mp_type_str ;
extern const mp_obj_type_t mp_type_bytes ;
2014-04-08 13:09:14 -06:00
extern const mp_obj_type_t mp_type_bytearray ;
2014-10-23 06:34:35 -06:00
extern const mp_obj_type_t mp_type_memoryview ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_float ;
extern const mp_obj_type_t mp_type_complex ;
extern const mp_obj_type_t mp_type_tuple ;
extern const mp_obj_type_t mp_type_list ;
extern const mp_obj_type_t mp_type_map ; // map (the python builtin, not the dict implementation detail)
extern const mp_obj_type_t mp_type_enumerate ;
extern const mp_obj_type_t mp_type_filter ;
2018-02-05 15:06:42 -07:00
extern const mp_obj_type_t mp_type_deque ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_dict ;
2015-03-17 17:25:04 -06:00
extern const mp_obj_type_t mp_type_ordereddict ;
2014-04-17 11:18:55 -06:00
extern const mp_obj_type_t mp_type_range ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_set ;
2014-05-10 07:02:17 -06:00
extern const mp_obj_type_t mp_type_frozenset ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_slice ;
extern const mp_obj_type_t mp_type_zip ;
extern const mp_obj_type_t mp_type_array ;
extern const mp_obj_type_t mp_type_super ;
2018-06-29 00:32:58 -06:00
extern const mp_obj_type_t mp_type_gen_wrap ;
2018-09-30 21:07:04 -06:00
extern const mp_obj_type_t mp_type_native_gen_wrap ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_gen_instance ;
2016-10-17 18:49:27 -06:00
extern const mp_obj_type_t mp_type_fun_builtin_0 ;
extern const mp_obj_type_t mp_type_fun_builtin_1 ;
extern const mp_obj_type_t mp_type_fun_builtin_2 ;
extern const mp_obj_type_t mp_type_fun_builtin_3 ;
extern const mp_obj_type_t mp_type_fun_builtin_var ;
2014-03-29 07:43:38 -06:00
extern const mp_obj_type_t mp_type_fun_bc ;
extern const mp_obj_type_t mp_type_module ;
extern const mp_obj_type_t mp_type_staticmethod ;
extern const mp_obj_type_t mp_type_classmethod ;
2014-04-13 11:59:45 -06:00
extern const mp_obj_type_t mp_type_property ;
2014-04-26 11:26:14 -06:00
extern const mp_obj_type_t mp_type_stringio ;
2014-05-14 22:28:19 -06:00
extern const mp_obj_type_t mp_type_bytesio ;
2014-08-12 11:33:40 -06:00
extern const mp_obj_type_t mp_type_reversed ;
2015-12-14 14:48:12 -07:00
extern const mp_obj_type_t mp_type_polymorph_iter ;
2014-03-22 09:28:16 -06:00
// Exceptions
2014-02-15 09:10:44 -07:00
extern const mp_obj_type_t mp_type_BaseException ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_ArithmeticError ;
extern const mp_obj_type_t mp_type_AssertionError ;
extern const mp_obj_type_t mp_type_AttributeError ;
extern const mp_obj_type_t mp_type_EOFError ;
extern const mp_obj_type_t mp_type_Exception ;
extern const mp_obj_type_t mp_type_GeneratorExit ;
extern const mp_obj_type_t mp_type_ImportError ;
extern const mp_obj_type_t mp_type_IndentationError ;
extern const mp_obj_type_t mp_type_IndexError ;
2014-10-25 11:19:55 -06:00
extern const mp_obj_type_t mp_type_KeyboardInterrupt ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_KeyError ;
extern const mp_obj_type_t mp_type_LookupError ;
extern const mp_obj_type_t mp_type_MemoryError ;
extern const mp_obj_type_t mp_type_NameError ;
extern const mp_obj_type_t mp_type_NotImplementedError ;
extern const mp_obj_type_t mp_type_OSError ;
2015-06-29 14:45:39 -06:00
extern const mp_obj_type_t mp_type_TimeoutError ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_OverflowError ;
extern const mp_obj_type_t mp_type_RuntimeError ;
2016-01-27 13:23:11 -07:00
extern const mp_obj_type_t mp_type_StopAsyncIteration ;
2014-03-25 08:29:40 -06:00
extern const mp_obj_type_t mp_type_StopIteration ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_SyntaxError ;
2014-05-24 16:32:19 -06:00
extern const mp_obj_type_t mp_type_SystemExit ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_TypeError ;
2015-02-23 14:18:36 -07:00
extern const mp_obj_type_t mp_type_UnicodeError ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_ValueError ;
2015-04-20 07:29:31 -06:00
extern const mp_obj_type_t mp_type_ViperTypeError ;
2014-03-22 09:28:16 -06:00
extern const mp_obj_type_t mp_type_ZeroDivisionError ;
2013-12-21 11:17:45 -07:00
// Constant objects, globally accessible
2014-03-29 07:15:08 -06:00
// The macros are for convenience only
2015-11-27 10:01:44 -07:00
# define mp_const_none (MP_OBJ_FROM_PTR(&mp_const_none_obj))
# define mp_const_false (MP_OBJ_FROM_PTR(&mp_const_false_obj))
# define mp_const_true (MP_OBJ_FROM_PTR(&mp_const_true_obj))
# define mp_const_empty_bytes (MP_OBJ_FROM_PTR(&mp_const_empty_bytes_obj))
# define mp_const_empty_tuple (MP_OBJ_FROM_PTR(&mp_const_empty_tuple_obj))
2017-08-29 16:35:48 -06:00
# define mp_const_notimplemented (MP_OBJ_FROM_PTR(&mp_const_notimplemented_obj))
2014-03-29 07:15:08 -06:00
extern const struct _mp_obj_none_t mp_const_none_obj ;
extern const struct _mp_obj_bool_t mp_const_false_obj ;
extern const struct _mp_obj_bool_t mp_const_true_obj ;
2014-10-11 10:56:43 -06:00
extern const struct _mp_obj_str_t mp_const_empty_bytes_obj ;
2014-03-29 07:15:08 -06:00
extern const struct _mp_obj_tuple_t mp_const_empty_tuple_obj ;
2015-05-05 13:18:07 -06:00
extern const struct _mp_obj_singleton_t mp_const_ellipsis_obj ;
extern const struct _mp_obj_singleton_t mp_const_notimplemented_obj ;
2014-03-29 07:15:08 -06:00
extern const struct _mp_obj_exception_t mp_const_GeneratorExit_obj ;
2013-12-21 11:17:45 -07:00
// General API for objects
2019-01-30 00:49:52 -07:00
// These macros are derived from more primitive ones and are used to
// check for more specific object types.
// Note: these are kept as macros because inline functions sometimes use much
// more code space than the equivalent macros, depending on the compiler.
# define mp_obj_is_type(o, t) (mp_obj_is_obj(o) && (((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type == (t))) // this does not work for checking int, str or fun; use below macros for that
# define mp_obj_is_int(o) (mp_obj_is_small_int(o) || mp_obj_is_type(o, &mp_type_int))
# define mp_obj_is_str(o) (mp_obj_is_qstr(o) || mp_obj_is_type(o, &mp_type_str))
# define mp_obj_is_str_or_bytes(o) (mp_obj_is_qstr(o) || (mp_obj_is_obj(o) && ((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type->binary_op == mp_obj_str_binary_op))
# define mp_obj_is_fun(o) (mp_obj_is_obj(o) && (((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type->name == MP_QSTR_function))
2014-02-15 04:34:50 -07:00
mp_obj_t mp_obj_new_type ( qstr name , mp_obj_t bases_tuple , mp_obj_t locals_dict ) ;
2015-10-11 03:09:43 -06:00
static inline mp_obj_t mp_obj_new_bool ( mp_int_t x ) { return x ? mp_const_true : mp_const_false ; }
2013-12-30 15:32:17 -07:00
mp_obj_t mp_obj_new_cell ( mp_obj_t obj ) ;
2014-07-03 06:25:24 -06:00
mp_obj_t mp_obj_new_int ( mp_int_t value ) ;
mp_obj_t mp_obj_new_int_from_uint ( mp_uint_t value ) ;
2017-02-15 22:41:43 -07:00
mp_obj_t mp_obj_new_int_from_str_len ( const char * * str , size_t len , bool neg , unsigned int base ) ;
2014-03-12 09:38:15 -06:00
mp_obj_t mp_obj_new_int_from_ll ( long long val ) ; // this must return a multi-precision integer object (or raise an overflow exception)
2014-09-10 15:10:33 -06:00
mp_obj_t mp_obj_new_int_from_ull ( unsigned long long val ) ; // this must return a multi-precision integer object (or raise an overflow exception)
2017-11-15 19:17:51 -07:00
mp_obj_t mp_obj_new_str ( const char * data , size_t len ) ;
mp_obj_t mp_obj_new_str_via_qstr ( const char * data , size_t len ) ;
2015-01-21 12:14:25 -07:00
mp_obj_t mp_obj_new_str_from_vstr ( const mp_obj_type_t * type , vstr_t * vstr ) ;
2017-02-15 22:26:48 -07:00
mp_obj_t mp_obj_new_bytes ( const byte * data , size_t len ) ;
2017-02-15 22:31:43 -07:00
mp_obj_t mp_obj_new_bytearray ( size_t n , void * items ) ;
mp_obj_t mp_obj_new_bytearray_by_ref ( size_t n , void * items ) ;
2014-06-01 06:32:54 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2014-12-29 15:34:54 -07:00
mp_obj_t mp_obj_new_int_from_float ( mp_float_t val ) ;
2013-12-21 11:17:45 -07:00
mp_obj_t mp_obj_new_complex ( mp_float_t real , mp_float_t imag ) ;
2013-12-17 11:27:24 -07:00
# endif
2014-02-15 09:10:44 -07:00
mp_obj_t mp_obj_new_exception ( const mp_obj_type_t * exc_type ) ;
2014-04-21 15:01:13 -06:00
mp_obj_t mp_obj_new_exception_arg1 ( const mp_obj_type_t * exc_type , mp_obj_t arg ) ;
2017-02-15 22:38:14 -07:00
mp_obj_t mp_obj_new_exception_args ( const mp_obj_type_t * exc_type , size_t n_args , const mp_obj_t * args ) ;
2014-02-15 09:10:44 -07:00
mp_obj_t mp_obj_new_exception_msg ( const mp_obj_type_t * exc_type , const char * msg ) ;
mp_obj_t mp_obj_new_exception_msg_varg ( const mp_obj_type_t * exc_type , const char * fmt , . . . ) ; // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)
2015-10-22 18:23:11 -06:00
mp_obj_t mp_obj_new_fun_bc ( mp_obj_t def_args , mp_obj_t def_kw_args , const byte * code , const mp_uint_t * const_table ) ;
mp_obj_t mp_obj_new_fun_native ( mp_obj_t def_args_in , mp_obj_t def_kw_args , const void * fun_data , const mp_uint_t * const_table ) ;
2019-02-19 19:08:42 -07:00
mp_obj_t mp_obj_new_fun_asm ( size_t n_args , const void * fun_data , mp_uint_t type_sig ) ;
2014-01-29 13:30:52 -07:00
mp_obj_t mp_obj_new_gen_wrap ( mp_obj_t fun ) ;
2017-02-15 22:36:04 -07:00
mp_obj_t mp_obj_new_closure ( mp_obj_t fun , size_t n_closed , const mp_obj_t * closed ) ;
2017-02-15 22:09:51 -07:00
mp_obj_t mp_obj_new_tuple ( size_t n , const mp_obj_t * items ) ;
2017-02-15 22:12:41 -07:00
mp_obj_t mp_obj_new_list ( size_t n , mp_obj_t * items ) ;
2017-02-15 22:15:04 -07:00
mp_obj_t mp_obj_new_dict ( size_t n_args ) ;
2017-02-15 22:16:33 -07:00
mp_obj_t mp_obj_new_set ( size_t n_args , mp_obj_t * items ) ;
2014-01-02 17:41:17 -07:00
mp_obj_t mp_obj_new_slice ( mp_obj_t start , mp_obj_t stop , mp_obj_t step ) ;
2014-01-18 07:10:48 -07:00
mp_obj_t mp_obj_new_bound_meth ( mp_obj_t meth , mp_obj_t self ) ;
2016-01-09 16:14:54 -07:00
mp_obj_t mp_obj_new_getitem_iter ( mp_obj_t * args , mp_obj_iter_buf_t * iter_buf ) ;
2014-01-02 14:30:26 -07:00
mp_obj_t mp_obj_new_module ( qstr module_name ) ;
2017-02-15 22:31:43 -07:00
mp_obj_t mp_obj_new_memoryview ( byte typecode , size_t nitems , void * items ) ;
2013-12-17 11:27:24 -07:00
2020-01-08 17:01:14 -07:00
const mp_obj_type_t * mp_obj_get_type ( mp_const_obj_t o_in ) ;
2014-05-10 17:26:42 -06:00
const char * mp_obj_get_type_str ( mp_const_obj_t o_in ) ;
2014-03-26 12:37:06 -06:00
bool mp_obj_is_subclass_fast ( mp_const_obj_t object , mp_const_obj_t classinfo ) ; // arguments should be type objects
2014-05-10 18:16:04 -06:00
mp_obj_t mp_instance_cast_to_native_base ( mp_const_obj_t self_in , mp_const_obj_t native_type ) ;
2013-12-17 11:27:24 -07:00
2015-04-09 16:56:15 -06:00
void mp_obj_print_helper ( const mp_print_t * print , mp_obj_t o_in , mp_print_kind_t kind ) ;
2014-01-13 10:19:16 -07:00
void mp_obj_print ( mp_obj_t o , mp_print_kind_t kind ) ;
2015-04-09 16:56:15 -06:00
void mp_obj_print_exception ( const mp_print_t * print , mp_obj_t exc ) ;
2013-12-17 11:27:24 -07:00
2014-08-30 07:28:06 -06:00
bool mp_obj_is_true ( mp_obj_t arg ) ;
2013-12-21 11:17:45 -07:00
bool mp_obj_is_callable ( mp_obj_t o_in ) ;
bool mp_obj_equal ( mp_obj_t o1 , mp_obj_t o2 ) ;
2013-12-17 11:27:24 -07:00
2019-01-30 00:49:52 -07:00
static inline bool mp_obj_is_integer ( mp_const_obj_t o ) { return mp_obj_is_int ( o ) | | mp_obj_is_type ( o , & mp_type_bool ) ; } // returns true if o is bool, small int or long int
2014-07-03 06:25:24 -06:00
mp_int_t mp_obj_get_int ( mp_const_obj_t arg ) ;
2015-05-12 16:05:53 -06:00
mp_int_t mp_obj_get_int_truncated ( mp_const_obj_t arg ) ;
2014-07-03 06:25:24 -06:00
bool mp_obj_get_int_maybe ( mp_const_obj_t arg , mp_int_t * value ) ;
2014-06-01 06:32:54 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2013-12-21 11:17:45 -07:00
mp_float_t mp_obj_get_float ( mp_obj_t self_in ) ;
2017-09-02 12:19:01 -06:00
bool mp_obj_get_float_maybe ( mp_obj_t arg , mp_float_t * value ) ;
2013-12-21 11:17:45 -07:00
void mp_obj_get_complex ( mp_obj_t self_in , mp_float_t * real , mp_float_t * imag ) ;
2013-12-17 11:27:24 -07:00
# endif
2017-03-25 02:35:08 -06:00
void mp_obj_get_array ( mp_obj_t o , size_t * len , mp_obj_t * * items ) ; // *items may point inside a GC block
2017-03-26 02:20:06 -06:00
void mp_obj_get_array_fixed_n ( mp_obj_t o , size_t len , mp_obj_t * * items ) ; // *items may point inside a GC block
2017-03-22 23:17:40 -06:00
size_t mp_get_index ( const mp_obj_type_t * type , size_t len , mp_obj_t index , bool is_slice ) ;
2014-08-22 14:48:30 -06:00
mp_obj_t mp_obj_id ( mp_obj_t o_in ) ;
2014-08-12 11:33:40 -06:00
mp_obj_t mp_obj_len ( mp_obj_t o_in ) ;
2015-04-04 08:53:11 -06:00
mp_obj_t mp_obj_len_maybe ( mp_obj_t o_in ) ; // may return MP_OBJ_NULL
2014-04-17 15:10:53 -06:00
mp_obj_t mp_obj_subscr ( mp_obj_t base , mp_obj_t index , mp_obj_t val ) ;
2017-08-28 21:04:01 -06:00
mp_obj_t mp_generic_unary_op ( mp_unary_op_t op , mp_obj_t o_in ) ;
2013-12-21 11:17:45 -07:00
// cell
mp_obj_t mp_obj_cell_get ( mp_obj_t self_in ) ;
void mp_obj_cell_set ( mp_obj_t self_in , mp_obj_t obj ) ;
2014-01-04 13:21:15 -07:00
// int
2014-07-03 06:25:24 -06:00
// For long int, returns value truncated to mp_int_t
2014-12-05 16:13:52 -07:00
mp_int_t mp_obj_int_get_truncated ( mp_const_obj_t self_in ) ;
// Will raise exception if value doesn't fit into mp_int_t
mp_int_t mp_obj_int_get_checked ( mp_const_obj_t self_in ) ;
2014-01-04 13:21:15 -07:00
2013-12-29 10:17:43 -07:00
// exception
2014-05-01 16:51:25 -06:00
# define mp_obj_is_native_exception_instance(o) (mp_obj_get_type(o)->make_new == mp_obj_exception_make_new)
2014-02-15 09:10:44 -07:00
bool mp_obj_is_exception_type ( mp_obj_t self_in ) ;
bool mp_obj_is_exception_instance ( mp_obj_t self_in ) ;
2014-09-24 07:05:40 -06:00
bool mp_obj_exception_match ( mp_obj_t exc , mp_const_obj_t exc_type ) ;
2014-02-15 09:10:44 -07:00
void mp_obj_exception_clear_traceback ( mp_obj_t self_in ) ;
2016-01-02 15:04:12 -07:00
void mp_obj_exception_add_traceback ( mp_obj_t self_in , qstr file , size_t line , qstr block ) ;
void mp_obj_exception_get_traceback ( mp_obj_t self_in , size_t * n , size_t * * values ) ;
2014-03-26 11:17:20 -06:00
mp_obj_t mp_obj_exception_get_value ( mp_obj_t self_in ) ;
2016-01-03 08:55:55 -07:00
mp_obj_t mp_obj_exception_make_new ( const mp_obj_type_t * type_in , size_t n_args , size_t n_kw , const mp_obj_t * args ) ;
2014-07-02 00:46:53 -06:00
mp_obj_t mp_alloc_emergency_exception_buf ( mp_obj_t size_in ) ;
void mp_init_emergency_exception_buf ( void ) ;
2013-12-29 10:17:43 -07:00
2013-12-21 11:17:45 -07:00
// str
2014-01-22 07:35:10 -07:00
bool mp_obj_str_equal ( mp_obj_t s1 , mp_obj_t s2 ) ;
2014-01-25 06:51:19 -07:00
qstr mp_obj_str_get_qstr ( mp_obj_t self_in ) ; // use this if you will anyway convert the string to a qstr
2014-01-22 07:35:10 -07:00
const char * mp_obj_str_get_str ( mp_obj_t self_in ) ; // use this only if you need the string to be null terminated
2017-03-25 02:48:18 -06:00
const char * mp_obj_str_get_data ( mp_obj_t self_in , size_t * len ) ;
2014-06-07 16:13:35 -06:00
mp_obj_t mp_obj_str_intern ( mp_obj_t str ) ;
2018-03-29 18:09:00 -06:00
mp_obj_t mp_obj_str_intern_checked ( mp_obj_t obj ) ;
2017-02-15 22:26:48 -07:00
void mp_str_print_quoted ( const mp_print_t * print , const byte * str_data , size_t str_len , bool is_bytes ) ;
2013-12-21 11:17:45 -07:00
2014-06-01 06:32:54 -06:00
# if MICROPY_PY_BUILTINS_FLOAT
2013-12-21 11:17:45 -07:00
// float
2017-04-06 01:27:33 -06:00
# if MICROPY_FLOAT_HIGH_QUALITY_HASH
mp_int_t mp_float_hash ( mp_float_t val ) ;
# else
2017-04-03 19:57:21 -06:00
static inline mp_int_t mp_float_hash ( mp_float_t val ) { return ( mp_int_t ) val ; }
2017-04-06 01:27:33 -06:00
# endif
2017-08-28 21:04:01 -06:00
mp_obj_t mp_obj_float_binary_op ( mp_binary_op_t op , mp_float_t lhs_val , mp_obj_t rhs ) ; // can return MP_OBJ_NULL if op not supported
2013-12-21 11:17:45 -07:00
// complex
void mp_obj_complex_get ( mp_obj_t self_in , mp_float_t * real , mp_float_t * imag ) ;
2017-08-28 21:04:01 -06:00
mp_obj_t mp_obj_complex_binary_op ( mp_binary_op_t op , mp_float_t lhs_real , mp_float_t lhs_imag , mp_obj_t rhs_in ) ; // can return MP_OBJ_NULL if op not supported
2016-02-14 10:12:57 -07:00
# else
# define mp_obj_is_float(o) (false)
2013-12-21 11:17:45 -07:00
# endif
// tuple
2017-03-25 02:35:08 -06:00
void mp_obj_tuple_get ( mp_obj_t self_in , size_t * len , mp_obj_t * * items ) ;
2014-01-12 19:31:00 -07:00
void mp_obj_tuple_del ( mp_obj_t self_in ) ;
2014-07-03 06:25:24 -06:00
mp_int_t mp_obj_tuple_hash ( mp_obj_t self_in ) ;
2013-12-21 11:17:45 -07:00
// list
mp_obj_t mp_obj_list_append ( mp_obj_t self_in , mp_obj_t arg ) ;
2015-02-21 07:47:02 -07:00
mp_obj_t mp_obj_list_remove ( mp_obj_t self_in , mp_obj_t value ) ;
2017-03-25 02:35:08 -06:00
void mp_obj_list_get ( mp_obj_t self_in , size_t * len , mp_obj_t * * items ) ;
2017-02-15 22:12:41 -07:00
void mp_obj_list_set_len ( mp_obj_t self_in , size_t len ) ;
2013-12-21 11:17:45 -07:00
void mp_obj_list_store ( mp_obj_t self_in , mp_obj_t index , mp_obj_t value ) ;
2016-01-03 07:21:40 -07:00
mp_obj_t mp_obj_list_sort ( size_t n_args , const mp_obj_t * args , mp_map_t * kwargs ) ;
2013-12-21 11:17:45 -07:00
// dict
2014-03-30 06:54:02 -06:00
typedef struct _mp_obj_dict_t {
mp_obj_base_t base ;
mp_map_t map ;
} mp_obj_dict_t ;
2017-02-15 22:15:04 -07:00
void mp_obj_dict_init ( mp_obj_dict_t * dict , size_t n_args ) ;
size_t mp_obj_dict_len ( mp_obj_t self_in ) ;
2014-06-05 11:02:15 -06:00
mp_obj_t mp_obj_dict_get ( mp_obj_t self_in , mp_obj_t index ) ;
2013-12-21 11:17:45 -07:00
mp_obj_t mp_obj_dict_store ( mp_obj_t self_in , mp_obj_t key , mp_obj_t value ) ;
2014-04-05 06:25:13 -06:00
mp_obj_t mp_obj_dict_delete ( mp_obj_t self_in , mp_obj_t key ) ;
2018-07-08 06:23:57 -06:00
static inline mp_map_t * mp_obj_dict_get_map ( mp_obj_t dict ) {
return & ( ( mp_obj_dict_t * ) MP_OBJ_TO_PTR ( dict ) ) - > map ;
}
2013-12-21 11:17:45 -07:00
// set
void mp_obj_set_store ( mp_obj_t self_in , mp_obj_t item ) ;
2019-11-16 17:07:11 -07:00
// slice indexes resolved to particular sequence
typedef struct {
mp_int_t start ;
mp_int_t stop ;
mp_int_t step ;
} mp_bound_slice_t ;
2014-01-02 17:41:17 -07:00
// slice
2019-11-20 18:53:07 -07:00
typedef struct _mp_obj_slice_t {
mp_obj_base_t base ;
mp_obj_t start ;
mp_obj_t stop ;
mp_obj_t step ;
} mp_obj_slice_t ;
2019-11-16 17:07:11 -07:00
void mp_obj_slice_indices ( mp_obj_t self_in , mp_int_t length , mp_bound_slice_t * result ) ;
2014-01-02 17:41:17 -07:00
2013-12-21 11:17:45 -07:00
// functions
2016-10-17 18:49:27 -06:00
typedef struct _mp_obj_fun_builtin_fixed_t {
2013-12-21 11:17:45 -07:00
mp_obj_base_t base ;
2016-01-03 04:53:44 -07:00
union {
mp_fun_0_t _0 ;
mp_fun_1_t _1 ;
mp_fun_2_t _2 ;
mp_fun_3_t _3 ;
2016-10-17 18:49:27 -06:00
} fun ;
} mp_obj_fun_builtin_fixed_t ;
typedef struct _mp_obj_fun_builtin_var_t {
mp_obj_base_t base ;
2018-09-13 21:39:17 -06:00
uint32_t sig ; // see MP_OBJ_FUN_MAKE_SIG
2016-10-17 18:49:27 -06:00
union {
2016-01-03 04:53:44 -07:00
mp_fun_var_t var ;
mp_fun_kw_t kw ;
} fun ;
2016-10-17 18:49:27 -06:00
} mp_obj_fun_builtin_var_t ;
2014-01-07 08:58:30 -07:00
2015-02-14 10:44:31 -07:00
qstr mp_obj_fun_get_name ( mp_const_obj_t fun ) ;
qstr mp_obj_code_get_name ( const byte * code_info ) ;
2013-12-21 11:17:45 -07:00
2014-01-20 09:37:30 -07:00
mp_obj_t mp_identity ( mp_obj_t self ) ;
2016-10-17 18:06:20 -06:00
MP_DECLARE_CONST_FUN_OBJ_1 ( mp_identity_obj ) ;
2016-01-09 16:14:54 -07:00
mp_obj_t mp_identity_getiter ( mp_obj_t self , mp_obj_iter_buf_t * iter_buf ) ;
2014-01-20 09:37:30 -07:00
2014-01-02 14:30:26 -07:00
// module
2014-03-08 08:24:39 -07:00
typedef struct _mp_obj_module_t {
mp_obj_base_t base ;
2014-04-05 14:53:54 -06:00
mp_obj_dict_t * globals ;
2014-03-08 08:24:39 -07:00
} mp_obj_module_t ;
2018-07-08 06:27:39 -06:00
static inline mp_obj_dict_t * mp_obj_module_get_globals ( mp_obj_t module ) {
return ( ( mp_obj_module_t * ) MP_OBJ_TO_PTR ( module ) ) - > globals ;
}
2014-10-25 12:04:13 -06:00
// check if given module object is a package
bool mp_obj_is_package ( mp_obj_t module ) ;
2014-01-11 12:22:29 -07:00
// staticmethod and classmethod types; defined here so we can make const versions
2014-02-06 13:31:44 -07:00
// this structure is used for instances of both staticmethod and classmethod
typedef struct _mp_obj_static_class_method_t {
2014-01-11 12:22:29 -07:00
mp_obj_base_t base ;
mp_obj_t fun ;
2014-02-06 13:31:44 -07:00
} mp_obj_static_class_method_t ;
2015-11-27 06:38:15 -07:00
typedef struct _mp_rom_obj_static_class_method_t {
mp_obj_base_t base ;
mp_rom_obj_t fun ;
} mp_rom_obj_static_class_method_t ;
2014-01-20 15:19:19 -07:00
2014-04-13 11:59:45 -06:00
// property
const mp_obj_t * mp_obj_property_get ( mp_obj_t self_in ) ;
2014-01-20 15:19:19 -07:00
// sequence helpers
2014-05-25 12:21:57 -06:00
2017-03-22 23:23:20 -06:00
void mp_seq_multiply ( const void * items , size_t item_sz , size_t len , size_t times , void * dest ) ;
2014-06-01 06:49:35 -06:00
# if MICROPY_PY_BUILTINS_SLICE
2014-07-03 06:25:24 -06:00
bool mp_seq_get_fast_slice_indexes ( mp_uint_t len , mp_obj_t slice , mp_bound_slice_t * indexes ) ;
2014-06-01 06:49:35 -06:00
# endif
2014-05-10 12:36:33 -06:00
# define mp_seq_copy(dest, src, len, item_t) memcpy(dest, src, len * sizeof(item_t))
# define mp_seq_cat(dest, src1, len1, src2, len2, item_t) { memcpy(dest, src1, (len1) * sizeof(item_t)); memcpy(dest + (len1), src2, (len2) * sizeof(item_t)); }
2017-03-22 23:23:20 -06:00
bool mp_seq_cmp_bytes ( mp_uint_t op , const byte * data1 , size_t len1 , const byte * data2 , size_t len2 ) ;
bool mp_seq_cmp_objs ( mp_uint_t op , const mp_obj_t * items1 , size_t len1 , const mp_obj_t * items2 , size_t len2 ) ;
mp_obj_t mp_seq_index_obj ( const mp_obj_t * items , size_t len , size_t n_args , const mp_obj_t * args ) ;
mp_obj_t mp_seq_count_obj ( const mp_obj_t * items , size_t len , mp_obj_t value ) ;
mp_obj_t mp_seq_extract_slice ( size_t len , const mp_obj_t * seq , mp_bound_slice_t * indexes ) ;
2014-04-27 15:16:57 -06:00
// Helper to clear stale pointers from allocated, but unused memory, to preclude GC problems
# define mp_seq_clear(start, len, alloc_len, item_sz) memset((byte*)(start) + (len) * (item_sz), 0, ((alloc_len) - (len)) * (item_sz))
2015-02-27 13:16:05 -07:00
# define mp_seq_replace_slice_no_grow(dest, dest_len, beg, end, slice, slice_len, item_sz) \
/*printf("memcpy(%p, %p, %d)\n", dest + beg, slice, slice_len * (item_sz));*/ \
memcpy ( ( ( char * ) dest ) + ( beg ) * ( item_sz ) , slice , slice_len * ( item_sz ) ) ; \
/*printf("memmove(%p, %p, %d)\n", dest + (beg + slice_len), dest + end, (dest_len - end) * (item_sz));*/ \
memmove ( ( ( char * ) dest ) + ( beg + slice_len ) * ( item_sz ) , ( ( char * ) dest ) + ( end ) * ( item_sz ) , ( dest_len - end ) * ( item_sz ) ) ;
2017-04-02 01:28:24 -06:00
// Note: dest and slice regions may overlap
2015-02-27 13:16:05 -07:00
# define mp_seq_replace_slice_grow_inplace(dest, dest_len, beg, end, slice, slice_len, len_adj, item_sz) \
/*printf("memmove(%p, %p, %d)\n", dest + beg + len_adj, dest + beg, (dest_len - beg) * (item_sz));*/ \
2017-04-02 01:28:24 -06:00
memmove ( ( ( char * ) dest ) + ( beg + slice_len ) * ( item_sz ) , ( ( char * ) dest ) + ( end ) * ( item_sz ) , ( ( dest_len ) + ( len_adj ) - ( ( beg ) + ( slice_len ) ) ) * ( item_sz ) ) ; \
memmove ( ( ( char * ) dest ) + ( beg ) * ( item_sz ) , slice , slice_len * ( item_sz ) ) ;
2014-12-28 18:02:19 -07:00
2019-01-30 00:49:52 -07:00
// Provide translation for legacy API
# define MP_OBJ_IS_SMALL_INT mp_obj_is_small_int
# define MP_OBJ_IS_QSTR mp_obj_is_qstr
# define MP_OBJ_IS_OBJ mp_obj_is_obj
# define MP_OBJ_IS_INT mp_obj_is_int
# define MP_OBJ_IS_TYPE mp_obj_is_type
# define MP_OBJ_IS_STR mp_obj_is_str
# define MP_OBJ_IS_STR_OR_BYTES mp_obj_is_str_or_bytes
# define MP_OBJ_IS_FUN mp_obj_is_fun
2019-01-30 03:57:29 -07:00
# define MP_MAP_SLOT_IS_FILLED mp_map_slot_is_filled
# define MP_SET_SLOT_IS_FILLED mp_set_slot_is_filled
2019-01-30 00:49:52 -07: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 15:14:58 -06:00
# endif // MICROPY_INCLUDED_PY_OBJ_H