2013-12-21 18:17:45 +00:00
// All Micro Python objects are at least this type
// It must be of pointer size
typedef machine_ptr_t mp_obj_t ;
typedef machine_const_ptr_t mp_const_obj_t ;
// Integers that fit in a pointer have this type
// (do we need to expose this in the public API?)
typedef machine_int_t mp_small_int_t ;
// The machine floating-point type used for float and complex numbers
2013-12-17 18:27:24 +00:00
# if MICROPY_ENABLE_FLOAT
2013-12-21 18:17:45 +00:00
typedef machine_float_t mp_float_t ;
2013-12-17 18:27:24 +00:00
# endif
2014-01-07 15:58:30 +00:00
// Anything that wants to be a Micro Python object must have
// mp_obj_base_t as its first member (except NULL and small ints)
2013-12-21 18:17:45 +00:00
2014-01-06 17:52:29 +00:00
struct _mp_obj_type_t ;
2013-12-21 18:17:45 +00:00
struct _mp_obj_base_t {
2014-01-06 17:52:29 +00:00
const struct _mp_obj_type_t * type ;
2013-12-21 18:17:45 +00:00
} ;
2014-01-06 17:52:29 +00:00
typedef struct _mp_obj_base_t mp_obj_base_t ;
2013-12-21 18:17:45 +00:00
// The NULL object is used to indicate the absence of an object
// It *cannot* be used when an mp_obj_t is expected, except where explicitly allowed
# define MP_OBJ_NULL ((mp_obj_t)NULL)
2014-01-08 17:33:12 +00:00
// These macros check for small int, qstr or object, and access small int and qstr values
// - xxxx...xxx1: a small int, bits 1 and above are the value
// - xxxx...xx10: a qstr, bits 2 and above are the value
// - xxxx...xx00: a pointer to an mp_obj_base_t
2013-12-21 18:17:45 +00:00
2014-01-12 15:06:25 +00:00
// In SMALL_INT, next-to-highest bits is used as sign, so both must match for value in range
# define MP_OBJ_FITS_SMALL_INT(n) ((((n) ^ ((n) << 1)) & WORD_MSBIT_HIGH) == 0)
2013-12-21 18:17:45 +00:00
# define MP_OBJ_IS_SMALL_INT(o) ((((mp_small_int_t)(o)) & 1) != 0)
2014-01-08 17:33:12 +00:00
# define MP_OBJ_IS_QSTR(o) ((((mp_small_int_t)(o)) & 3) == 2)
# define MP_OBJ_IS_OBJ(o) ((((mp_small_int_t)(o)) & 3) == 0)
2014-01-25 00:17:36 +00:00
# define MP_OBJ_IS_TYPE(o, t) (MP_OBJ_IS_OBJ(o) && (((mp_obj_base_t*)(o))->type == (t))) // this does not work for checking a string, use below macro for that
2014-01-25 23:57:48 +00:00
# define MP_OBJ_IS_INT(o) (MP_OBJ_IS_SMALL_INT(o) || MP_OBJ_IS_TYPE(o, &int_type))
2014-01-22 14:35:10 +00:00
# define MP_OBJ_IS_STR(o) (MP_OBJ_IS_QSTR(o) || MP_OBJ_IS_TYPE(o, &str_type))
2014-01-08 17:33:12 +00:00
2013-12-21 18:17:45 +00:00
# define MP_OBJ_SMALL_INT_VALUE(o) (((mp_small_int_t)(o)) >> 1)
2014-01-08 17:33:12 +00:00
# define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)(((small_int) << 1) | 1))
# define MP_OBJ_QSTR_VALUE(o) (((mp_small_int_t)(o)) >> 2)
# define MP_OBJ_NEW_QSTR(qstr) ((mp_obj_t)((((machine_uint_t)qstr) << 2) | 2))
2013-12-21 18:17:45 +00: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
# define MP_DECLARE_CONST_FUN_OBJ(obj_name) extern const mp_obj_fun_native_t obj_name
2013-12-17 18:27:24 +00:00
2014-02-02 15:49:01 +00:00
# define MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, is_kw, n_args_min, n_args_max, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, {is_kw, n_args_min}, n_args_max, (void *)fun_name}
2014-01-07 18:01:08 +00:00
# define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 0, 0, (mp_fun_0_t)fun_name)
# define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 1, 1, (mp_fun_1_t)fun_name)
# define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 2, 2, (mp_fun_2_t)fun_name)
# define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 3, 3, (mp_fun_3_t)fun_name)
# define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, (~((machine_uint_t)0)), (mp_fun_var_t)fun_name)
# define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, n_args_max, (mp_fun_var_t)fun_name)
2014-01-13 19:55:18 +00:00
# define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, n_args_min, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, true, n_args_min, (~((machine_uint_t)0)), (mp_fun_kw_t)fun_name)
2014-01-07 17:29:16 +00:00
2014-01-11 19:22:29 +00: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
2014-02-06 20:31:44 +00:00
# define MP_DECLARE_CONST_STATICMETHOD_OBJ(obj_name) extern const mp_obj_static_class_method_t obj_name
# define MP_DECLARE_CONST_CLASSMETHOD_OBJ(obj_name) extern const mp_obj_static_class_method_t obj_name
2014-01-11 19:22:29 +00:00
2014-02-06 20:31:44 +00:00
# define MP_DEFINE_CONST_STATICMETHOD_OBJ(obj_name, fun_name) const mp_obj_static_class_method_t obj_name = {{&mp_type_staticmethod}, fun_name}
# define MP_DEFINE_CONST_CLASSMETHOD_OBJ(obj_name, fun_name) const mp_obj_static_class_method_t obj_name = {{&mp_type_classmethod}, fun_name}
2014-01-11 19:22:29 +00:00
2014-01-07 17:29:16 +00:00
// Need to declare this here so we are not dependent on map.h
struct _mp_map_t ;
2014-01-09 20:57:50 +00:00
struct _mp_map_elem_t ;
enum _mp_map_lookup_kind_t ;
2013-12-21 18:17:45 +00: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-04 01:15:01 +00:00
typedef mp_obj_t ( * mp_fun_3_t ) ( mp_obj_t , mp_obj_t , mp_obj_t ) ;
2013-12-21 18:17:45 +00:00
typedef mp_obj_t ( * mp_fun_t ) ( void ) ;
2014-01-19 16:02:09 +00:00
typedef mp_obj_t ( * mp_fun_var_t ) ( uint n , const mp_obj_t * ) ;
2014-01-18 14:10:48 +00:00
typedef mp_obj_t ( * mp_fun_kw_t ) ( uint n , const mp_obj_t * , struct _mp_map_t * ) ;
2013-12-21 18:17:45 +00:00
2014-01-13 17:19:16 +00:00
typedef enum {
PRINT_STR , PRINT_REPR
} mp_print_kind_t ;
typedef void ( * mp_print_fun_t ) ( void ( * print ) ( void * env , const char * fmt , . . . ) , void * env , mp_obj_t o , mp_print_kind_t kind ) ;
2014-01-18 14:10:48 +00:00
typedef mp_obj_t ( * mp_make_new_fun_t ) ( mp_obj_t type_in , uint n_args , uint n_kw , const mp_obj_t * args ) ;
typedef mp_obj_t ( * mp_call_fun_t ) ( mp_obj_t fun , uint n_args , uint n_kw , const mp_obj_t * args ) ;
2013-12-21 18:17:45 +00:00
typedef mp_obj_t ( * mp_unary_op_fun_t ) ( int op , mp_obj_t ) ;
typedef mp_obj_t ( * mp_binary_op_fun_t ) ( int op , mp_obj_t , mp_obj_t ) ;
2014-01-18 14:10:48 +00:00
typedef void ( * mp_load_attr_fun_t ) ( mp_obj_t self_in , qstr attr , mp_obj_t * dest ) ; // for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
2014-01-09 20:57:50 +00:00
typedef bool ( * mp_store_attr_fun_t ) ( mp_obj_t self_in , qstr attr , mp_obj_t value ) ; // return true if store succeeded
2014-01-18 11:10:51 +00:00
typedef bool ( * mp_store_item_fun_t ) ( mp_obj_t self_in , mp_obj_t index , mp_obj_t value ) ; // return true if store succeeded
2013-12-21 18:17:45 +00:00
typedef struct _mp_method_t {
2013-12-17 18:27:24 +00:00
const char * name ;
2013-12-21 18:17:45 +00:00
mp_const_obj_t fun ;
} mp_method_t ;
2014-01-07 18:12:26 +00:00
// Buffer protocol
typedef struct _buffer_info_t {
// if we'd bother to support various versions of structure
// (with different number of fields), we can distinguish
// them with ver = sizeof(struct). Cons: overkill for *micro*?
//int ver; // ?
void * buf ;
machine_int_t len ;
// Rationale: have array.array and have SIMD operations on them
// Cons: users can pass item size to processing functions themselves,
// though that's not "plug&play"
// int itemsize;
// Rationale: to load arbitrary-sized sprites directly to LCD
// Cons: a bit adhoc usecase
// int stride;
} buffer_info_t ;
# define BUFFER_READ (1)
# define BUFFER_WRITE (2)
# define BUFFER_RW (BUFFER_READ | BUFFER_WRITE)
typedef struct _mp_buffer_p_t {
machine_int_t ( * get_buffer ) ( mp_obj_t obj , buffer_info_t * bufinfo , int flags ) ;
} mp_buffer_p_t ;
// Stream protocol
typedef struct _mp_stream_p_t {
// On error, functions should return -1 and fill in *errcode (values are
// implementation-dependent, but will be exposed to user, e.g. via exception).
machine_int_t ( * read ) ( mp_obj_t obj , void * buf , machine_uint_t size , int * errcode ) ;
machine_int_t ( * write ) ( mp_obj_t obj , const void * buf , machine_uint_t size , int * errcode ) ;
// add seek() ?
} mp_stream_p_t ;
2013-12-21 18:17:45 +00:00
struct _mp_obj_type_t {
mp_obj_base_t base ;
2014-02-15 11:34:50 +00:00
qstr name ;
2013-12-21 18:17:45 +00:00
mp_print_fun_t print ;
2014-01-04 20:21:15 +00:00
mp_make_new_fun_t make_new ; // to make an instance of the type
2013-12-21 18:17:45 +00:00
2014-01-18 14:10:48 +00:00
mp_call_fun_t call ;
2013-12-21 18:17:45 +00:00
mp_unary_op_fun_t unary_op ; // can return NULL if op not supported
mp_binary_op_fun_t binary_op ; // can return NULL if op not supported
2014-02-15 11:34:50 +00:00
mp_load_attr_fun_t load_attr ;
mp_store_attr_fun_t store_attr ;
// Implements container[index] = val; note that load_item is implemented
// by binary_op(RT_BINARY_OP_SUBSCR)
mp_store_item_fun_t store_item ;
2013-12-21 18:17:45 +00:00
mp_fun_1_t getiter ;
mp_fun_1_t iternext ;
2014-01-07 18:12:26 +00:00
// Alternatively, pointer(s) to interfaces to save space
// in mp_obj_type_t at the expense of extra pointer and extra dereference
// when actually used.
mp_buffer_p_t buffer_p ;
mp_stream_p_t stream_p ;
2014-01-06 17:52:29 +00:00
const mp_method_t * methods ;
2013-12-21 18:17:45 +00:00
2014-01-09 21:43:51 +00:00
// these are for dynamically created types (classes)
mp_obj_t bases_tuple ;
mp_obj_t locals_dict ;
2014-01-09 20:57:50 +00:00
2013-12-21 18:17:45 +00:00
/*
What we might need to add here :
store_subscr list dict
2013-12-17 18:27:24 +00:00
2013-12-21 18:17:45 +00:00
len str tuple list map
abs float complex
hash bool int none str
equal int str
get_array_n tuple list
unpack seq list tuple
*/
} ;
2014-01-06 17:52:29 +00:00
typedef struct _mp_obj_type_t mp_obj_type_t ;
2013-12-21 18:17:45 +00:00
2014-02-15 16:10:44 +00:00
// Constant types, globally accessible
extern const mp_obj_type_t mp_type_type ;
extern const mp_obj_type_t mp_type_BaseException ;
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_ImportError ;
extern const mp_obj_type_t mp_type_IndentationError ;
extern const mp_obj_type_t mp_type_IndexError ;
extern const mp_obj_type_t mp_type_KeyError ;
extern const mp_obj_type_t mp_type_NameError ;
extern const mp_obj_type_t mp_type_SyntaxError ;
extern const mp_obj_type_t mp_type_TypeError ;
extern const mp_obj_type_t mp_type_ValueError ;
extern const mp_obj_type_t mp_type_OverflowError ;
extern const mp_obj_type_t mp_type_OSError ;
extern const mp_obj_type_t mp_type_NotImplementedError ;
extern const mp_obj_type_t mp_type_StopIteration ;
2013-12-21 18:17:45 +00:00
// Constant objects, globally accessible
extern const mp_obj_t mp_const_none ;
extern const mp_obj_t mp_const_false ;
extern const mp_obj_t mp_const_true ;
2014-01-04 20:21:15 +00:00
extern const mp_obj_t mp_const_empty_tuple ;
2014-01-04 18:44:46 +00:00
extern const mp_obj_t mp_const_ellipsis ;
2013-12-21 18:17:45 +00:00
extern const mp_obj_t mp_const_stop_iteration ; // special object indicating end of iteration (not StopIteration exception!)
// General API for objects
2014-02-15 11:34:50 +00:00
mp_obj_t mp_obj_new_type ( qstr name , mp_obj_t bases_tuple , mp_obj_t locals_dict ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_none ( void ) ;
mp_obj_t mp_obj_new_bool ( bool value ) ;
2013-12-30 22:32:17 +00:00
mp_obj_t mp_obj_new_cell ( mp_obj_t obj ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_int ( machine_int_t value ) ;
2014-01-12 15:30:48 +00:00
mp_obj_t mp_obj_new_int_from_uint ( machine_uint_t value ) ;
mp_obj_t mp_obj_new_int_from_long_str ( const char * s ) ;
2014-02-22 19:25:23 +00:00
# if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
mp_obj_t mp_obj_new_int_from_ll ( long long val ) ;
# endif
2014-01-22 14:35:10 +00:00
mp_obj_t mp_obj_new_str ( const byte * data , uint len , bool make_qstr_if_not_already ) ;
2014-01-24 20:50:40 +00:00
mp_obj_t mp_obj_new_bytes ( const byte * data , uint len ) ;
2013-12-17 18:27:24 +00:00
# if MICROPY_ENABLE_FLOAT
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_float ( mp_float_t val ) ;
mp_obj_t mp_obj_new_complex ( mp_float_t real , mp_float_t imag ) ;
2013-12-17 18:27:24 +00:00
# endif
2014-02-15 16:10:44 +00:00
mp_obj_t mp_obj_new_exception ( const mp_obj_type_t * exc_type ) ;
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!)
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_range ( int start , int stop , int step ) ;
mp_obj_t mp_obj_new_range_iterator ( int cur , int stop , int step ) ;
2014-02-16 16:30:49 +00:00
mp_obj_t mp_obj_new_fun_bc ( uint scope_flags , qstr * args , uint n_args , mp_obj_t def_args , uint n_state , const byte * code ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_fun_asm ( uint n_args , void * fun ) ;
2014-01-29 20:30:52 +00:00
mp_obj_t mp_obj_new_gen_wrap ( mp_obj_t fun ) ;
2014-01-02 20:57:05 +00:00
mp_obj_t mp_obj_new_gen_instance ( const byte * bytecode , uint n_state , int n_args , const mp_obj_t * args ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_closure ( mp_obj_t fun , mp_obj_t closure_tuple ) ;
2014-01-07 17:29:16 +00:00
mp_obj_t mp_obj_new_tuple ( uint n , const mp_obj_t * items ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_new_list ( uint n , mp_obj_t * items ) ;
mp_obj_t mp_obj_new_dict ( int n_args ) ;
mp_obj_t mp_obj_new_set ( int n_args , mp_obj_t * items ) ;
2014-01-03 00:41:17 +00:00
mp_obj_t mp_obj_new_slice ( mp_obj_t start , mp_obj_t stop , mp_obj_t step ) ;
2014-02-05 00:51:47 +00:00
mp_obj_t mp_obj_new_super ( mp_obj_t type , mp_obj_t obj ) ;
2014-01-18 14:10:48 +00:00
mp_obj_t mp_obj_new_bound_meth ( mp_obj_t meth , mp_obj_t self ) ;
2014-01-25 00:17:36 +00:00
mp_obj_t mp_obj_new_getitem_iter ( mp_obj_t * args ) ;
2014-01-02 21:30:26 +00:00
mp_obj_t mp_obj_new_module ( qstr module_name ) ;
2013-12-17 18:27:24 +00:00
2014-01-22 14:35:10 +00:00
mp_obj_type_t * mp_obj_get_type ( mp_obj_t o_in ) ;
2013-12-21 18:17:45 +00:00
const char * mp_obj_get_type_str ( mp_obj_t o_in ) ;
2014-02-15 16:10:44 +00:00
bool mp_obj_is_subclass ( mp_obj_t object , mp_obj_t classinfo ) ;
2013-12-17 18:27:24 +00:00
2014-01-13 17:19:16 +00:00
void mp_obj_print_helper ( void ( * print ) ( void * env , const char * fmt , . . . ) , void * env , mp_obj_t o_in , mp_print_kind_t kind ) ;
void mp_obj_print ( mp_obj_t o , mp_print_kind_t kind ) ;
2014-01-19 12:38:49 +00:00
void mp_obj_print_exception ( mp_obj_t exc ) ;
2013-12-17 18:27:24 +00:00
2013-12-21 18:17:45 +00:00
bool mp_obj_is_callable ( mp_obj_t o_in ) ;
machine_int_t mp_obj_hash ( mp_obj_t o_in ) ;
bool mp_obj_equal ( mp_obj_t o1 , mp_obj_t o2 ) ;
bool mp_obj_less ( mp_obj_t o1 , mp_obj_t o2 ) ;
2013-12-17 18:27:24 +00:00
2013-12-21 18:17:45 +00:00
machine_int_t mp_obj_get_int ( mp_obj_t arg ) ;
2013-12-17 18:27:24 +00:00
# if MICROPY_ENABLE_FLOAT
2013-12-21 18:17:45 +00:00
mp_float_t mp_obj_get_float ( mp_obj_t self_in ) ;
void mp_obj_get_complex ( mp_obj_t self_in , mp_float_t * real , mp_float_t * imag ) ;
2013-12-17 18:27:24 +00:00
# endif
2014-01-22 14:35:10 +00:00
//qstr mp_obj_get_qstr(mp_obj_t arg);
2013-12-21 18:17:45 +00:00
mp_obj_t * mp_obj_get_array_fixed_n ( mp_obj_t o , machine_int_t n ) ;
uint mp_get_index ( const mp_obj_type_t * type , machine_uint_t len , mp_obj_t index ) ;
2014-01-10 11:25:03 +00:00
mp_obj_t mp_obj_len_maybe ( mp_obj_t o_in ) ; /* may return NULL */
2013-12-21 18:17:45 +00:00
// none
extern const mp_obj_type_t none_type ;
// bool
extern const mp_obj_type_t bool_type ;
2014-01-11 00:58:59 +00:00
# define MP_BOOL(x) (x ? mp_const_true : mp_const_false)
2013-12-21 18:17:45 +00: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 20:21:15 +00:00
// int
extern const mp_obj_type_t int_type ;
2014-01-18 14:07:16 +00:00
// For long int, returns value truncated to machine_int_t
machine_int_t mp_obj_int_get ( mp_obj_t self_in ) ;
// Will rains exception if value doesn't fit into machine_int_t
machine_int_t mp_obj_int_get_checked ( mp_obj_t self_in ) ;
2014-01-04 20:21:15 +00:00
2013-12-29 17:17:43 +00:00
// exception
2014-02-15 16:10:44 +00:00
bool mp_obj_is_exception_type ( mp_obj_t self_in ) ;
bool mp_obj_is_exception_instance ( mp_obj_t self_in ) ;
void mp_obj_exception_clear_traceback ( mp_obj_t self_in ) ;
2014-01-19 12:38:49 +00:00
void mp_obj_exception_add_traceback ( mp_obj_t self_in , qstr file , machine_uint_t line , qstr block ) ;
void mp_obj_exception_get_traceback ( mp_obj_t self_in , machine_uint_t * n , machine_uint_t * * values ) ;
2013-12-29 17:17:43 +00:00
2013-12-21 18:17:45 +00:00
// str
extern const mp_obj_type_t str_type ;
2014-01-24 20:50:40 +00:00
mp_obj_t mp_obj_str_builder_start ( const mp_obj_type_t * type , uint len , byte * * data ) ;
2014-01-22 14:35:10 +00:00
mp_obj_t mp_obj_str_builder_end ( mp_obj_t o_in ) ;
bool mp_obj_str_equal ( mp_obj_t s1 , mp_obj_t s2 ) ;
uint mp_obj_str_get_hash ( mp_obj_t self_in ) ;
uint mp_obj_str_get_len ( mp_obj_t self_in ) ;
2014-01-25 13:51:19 +00: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 14:35:10 +00: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
2014-02-08 18:17:23 +00:00
const char * mp_obj_str_get_data ( mp_obj_t self_in , uint * len ) ;
2014-01-28 01:40:06 +00:00
void mp_str_print_quoted ( void ( * print ) ( void * env , const char * fmt , . . . ) , void * env , const byte * str_data , uint str_len ) ;
2013-12-21 18:17:45 +00:00
2014-01-24 20:50:40 +00:00
// bytes
extern const mp_obj_type_t bytes_type ;
2013-12-21 18:17:45 +00:00
# if MICROPY_ENABLE_FLOAT
// float
extern const mp_obj_type_t float_type ;
mp_float_t mp_obj_float_get ( mp_obj_t self_in ) ;
2014-01-06 22:13:00 +00:00
mp_obj_t mp_obj_float_binary_op ( int op , mp_float_t lhs_val , mp_obj_t rhs ) ;
2013-12-21 18:17:45 +00:00
// complex
extern const mp_obj_type_t complex_type ;
void mp_obj_complex_get ( mp_obj_t self_in , mp_float_t * real , mp_float_t * imag ) ;
2014-01-06 22:13:00 +00:00
mp_obj_t mp_obj_complex_binary_op ( int op , mp_float_t lhs_real , mp_float_t lhs_imag , mp_obj_t rhs_in ) ;
2013-12-21 18:17:45 +00:00
# endif
// tuple
extern const mp_obj_type_t tuple_type ;
void mp_obj_tuple_get ( mp_obj_t self_in , uint * len , mp_obj_t * * items ) ;
2014-01-13 02:31:00 +00:00
void mp_obj_tuple_del ( mp_obj_t self_in ) ;
2013-12-21 18:17:45 +00:00
// list
extern const mp_obj_type_t list_type ;
mp_obj_t mp_obj_list_append ( mp_obj_t self_in , mp_obj_t arg ) ;
void mp_obj_list_get ( mp_obj_t self_in , uint * len , mp_obj_t * * items ) ;
void mp_obj_list_store ( mp_obj_t self_in , mp_obj_t index , mp_obj_t value ) ;
2014-01-18 14:10:48 +00:00
mp_obj_t mp_obj_list_sort ( uint n_args , const mp_obj_t * args , struct _mp_map_t * kwargs ) ;
2013-12-21 18:17:45 +00:00
2014-01-15 01:10:09 +00:00
// map (the python builtin, not the dict implementation detail)
extern const mp_obj_type_t map_type ;
2014-01-14 23:55:01 +00:00
// enumerate
extern const mp_obj_type_t enumerate_type ;
2014-01-15 01:37:08 +00:00
// filter
extern const mp_obj_type_t filter_type ;
2013-12-21 18:17:45 +00:00
// dict
extern const mp_obj_type_t dict_type ;
2013-12-29 22:32:51 +00:00
uint mp_obj_dict_len ( mp_obj_t self_in ) ;
2013-12-21 18:17:45 +00:00
mp_obj_t mp_obj_dict_store ( mp_obj_t self_in , mp_obj_t key , mp_obj_t value ) ;
2014-01-09 20:57:50 +00:00
struct _mp_map_t * mp_obj_dict_get_map ( mp_obj_t self_in ) ;
2013-12-21 18:17:45 +00:00
// set
2014-01-04 20:21:15 +00:00
extern const mp_obj_type_t set_type ;
2013-12-21 18:17:45 +00:00
void mp_obj_set_store ( mp_obj_t self_in , mp_obj_t item ) ;
2014-01-03 00:41:17 +00:00
// slice
extern const mp_obj_type_t slice_type ;
void mp_obj_slice_get ( mp_obj_t self_in , machine_int_t * start , machine_int_t * stop , machine_int_t * step ) ;
2014-01-13 02:31:00 +00:00
// zip
extern const mp_obj_type_t zip_type ;
2014-01-18 17:24:47 +00:00
// array
extern const mp_obj_type_t array_type ;
2014-01-21 21:30:10 +00:00
uint mp_obj_array_len ( mp_obj_t self_in ) ;
2014-01-28 22:21:41 +00:00
mp_obj_t mp_obj_new_bytearray_by_ref ( uint n , void * items ) ;
2014-01-13 02:31:00 +00:00
2013-12-21 18:17:45 +00:00
// functions
2014-01-03 14:03:48 +00:00
typedef struct _mp_obj_fun_native_t { // need this so we can define const objects (to go in ROM)
2013-12-21 18:17:45 +00:00
mp_obj_base_t base ;
2014-02-02 15:49:01 +00:00
struct {
bool is_kw : 1 ;
machine_uint_t n_args_min : ( 8 * sizeof ( machine_uint_t ) - 1 ) ; // inclusive
} ;
2013-12-21 18:17:45 +00:00
machine_uint_t n_args_max ; // inclusive
void * fun ;
2014-01-03 14:03:48 +00:00
// TODO add mp_map_t *globals
// for const function objects, make an empty, const map
// such functions won't be able to access the global scope, but that's probably okay
2013-12-21 18:17:45 +00:00
} mp_obj_fun_native_t ;
2014-01-07 15:58:30 +00:00
2013-12-21 18:17:45 +00:00
extern const mp_obj_type_t fun_native_type ;
extern const mp_obj_type_t fun_bc_type ;
void mp_obj_fun_bc_get ( mp_obj_t self_in , int * n_args , uint * n_state , const byte * * code ) ;
2014-01-20 16:37:30 +00:00
mp_obj_t mp_identity ( mp_obj_t self ) ;
2014-02-08 19:57:19 +00:00
MP_DECLARE_CONST_FUN_OBJ ( mp_identity_obj ) ;
2014-01-20 16:37:30 +00:00
2014-02-05 00:51:47 +00:00
// super
extern const mp_obj_type_t super_type ;
2013-12-21 18:17:45 +00:00
// generator
extern const mp_obj_type_t gen_instance_type ;
2014-01-02 21:30:26 +00:00
// module
extern const mp_obj_type_t module_type ;
mp_obj_t mp_obj_new_module ( qstr module_name ) ;
2014-01-19 22:03:34 +00:00
mp_obj_t mp_obj_module_get ( qstr module_name ) ;
2014-01-02 21:30:26 +00:00
struct _mp_map_t * mp_obj_module_get_globals ( mp_obj_t self_in ) ;
2014-01-11 19:22:29 +00:00
// staticmethod and classmethod types; defined here so we can make const versions
extern const mp_obj_type_t mp_type_staticmethod ;
extern const mp_obj_type_t mp_type_classmethod ;
2014-02-06 20:31:44 +00:00
// this structure is used for instances of both staticmethod and classmethod
typedef struct _mp_obj_static_class_method_t {
2014-01-11 19:22:29 +00:00
mp_obj_base_t base ;
mp_obj_t fun ;
2014-02-06 20:31:44 +00:00
} mp_obj_static_class_method_t ;
2014-01-20 22:19:19 +00:00
// sequence helpers
void mp_seq_multiply ( const void * items , uint item_sz , uint len , uint times , void * dest ) ;
2014-02-02 00:38:22 +00:00
bool m_seq_get_fast_slice_indexes ( machine_uint_t len , mp_obj_t slice , machine_uint_t * begin , machine_uint_t * end ) ;
2014-02-08 21:17:51 +00:00
# define m_seq_copy(dest, src, len, item_t) memcpy(dest, src, len * sizeof(item_t))
# define m_seq_cat(dest, src1, len1, src2, len2, item_t) { memcpy(dest, src1, len1 * sizeof(item_t)); memcpy(dest + len1, src2, len2 * sizeof(item_t)); }
2014-02-02 06:24:07 +00:00
bool mp_seq_cmp_bytes ( int op , const byte * data1 , uint len1 , const byte * data2 , uint len2 ) ;
2014-02-08 20:49:46 +00:00
bool mp_seq_cmp_objs ( int op , const mp_obj_t * items1 , uint len1 , const mp_obj_t * items2 , uint len2 ) ;
2014-02-10 04:37:11 +00:00
mp_obj_t mp_seq_index_obj ( const mp_obj_t * items , uint len , uint n_args , const mp_obj_t * args ) ;
2014-02-10 05:10:55 +00:00
mp_obj_t mp_seq_count_obj ( const mp_obj_t * items , uint len , mp_obj_t value ) ;