Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 1 | // All Micro Python objects are at least this type |
| 2 | // It must be of pointer size |
| 3 | |
| 4 | typedef machine_ptr_t mp_obj_t; |
| 5 | typedef machine_const_ptr_t mp_const_obj_t; |
| 6 | |
| 7 | // Integers that fit in a pointer have this type |
| 8 | // (do we need to expose this in the public API?) |
| 9 | |
| 10 | typedef machine_int_t mp_small_int_t; |
| 11 | |
Damien George | 97209d3 | 2014-01-07 15:58:30 +0000 | [diff] [blame] | 12 | // Anything that wants to be a Micro Python object must have |
| 13 | // mp_obj_base_t as its first member (except NULL and small ints) |
Damien | 660365e | 2013-12-17 18:27:24 +0000 | [diff] [blame] | 14 | |
ian-v | 7a16fad | 2014-01-06 09:52:29 -0800 | [diff] [blame] | 15 | struct _mp_obj_type_t; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 16 | struct _mp_obj_base_t { |
ian-v | 7a16fad | 2014-01-06 09:52:29 -0800 | [diff] [blame] | 17 | const struct _mp_obj_type_t *type; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 18 | }; |
ian-v | 7a16fad | 2014-01-06 09:52:29 -0800 | [diff] [blame] | 19 | typedef struct _mp_obj_base_t mp_obj_base_t; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 20 | |
| 21 | // The NULL object is used to indicate the absence of an object |
| 22 | // It *cannot* be used when an mp_obj_t is expected, except where explicitly allowed |
| 23 | |
| 24 | #define MP_OBJ_NULL ((mp_obj_t)NULL) |
| 25 | |
Damien George | 38a2da6 | 2014-01-08 17:33:12 +0000 | [diff] [blame] | 26 | // These macros check for small int, qstr or object, and access small int and qstr values |
| 27 | // - xxxx...xxx1: a small int, bits 1 and above are the value |
| 28 | // - xxxx...xx10: a qstr, bits 2 and above are the value |
| 29 | // - xxxx...xx00: a pointer to an mp_obj_base_t |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 30 | |
Paul Sokolovsky | 757ac81 | 2014-01-12 17:06:25 +0200 | [diff] [blame] | 31 | // In SMALL_INT, next-to-highest bits is used as sign, so both must match for value in range |
Damien George | 9d68e9c | 2014-03-12 15:38:15 +0000 | [diff] [blame] | 32 | #define MP_SMALL_INT_MIN ((mp_small_int_t)(((machine_int_t)WORD_MSBIT_HIGH) >> 1)) |
| 33 | #define MP_SMALL_INT_MAX ((mp_small_int_t)(~(MP_SMALL_INT_MIN))) |
Paul Sokolovsky | 757ac81 | 2014-01-12 17:06:25 +0200 | [diff] [blame] | 34 | #define MP_OBJ_FITS_SMALL_INT(n) ((((n) ^ ((n) << 1)) & WORD_MSBIT_HIGH) == 0) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 35 | #define MP_OBJ_IS_SMALL_INT(o) ((((mp_small_int_t)(o)) & 1) != 0) |
Damien George | 38a2da6 | 2014-01-08 17:33:12 +0000 | [diff] [blame] | 36 | #define MP_OBJ_IS_QSTR(o) ((((mp_small_int_t)(o)) & 3) == 2) |
| 37 | #define MP_OBJ_IS_OBJ(o) ((((mp_small_int_t)(o)) & 3) == 0) |
Damien George | 7c9c667 | 2014-01-25 00:17:36 +0000 | [diff] [blame] | 38 | #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 |
Paul Sokolovsky | 2ca84aa | 2014-01-26 01:57:48 +0200 | [diff] [blame] | 39 | #define MP_OBJ_IS_INT(o) (MP_OBJ_IS_SMALL_INT(o) || MP_OBJ_IS_TYPE(o, &int_type)) |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 40 | #define MP_OBJ_IS_STR(o) (MP_OBJ_IS_QSTR(o) || MP_OBJ_IS_TYPE(o, &str_type)) |
Damien George | 38a2da6 | 2014-01-08 17:33:12 +0000 | [diff] [blame] | 41 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 42 | #define MP_OBJ_SMALL_INT_VALUE(o) (((mp_small_int_t)(o)) >> 1) |
Damien George | 38a2da6 | 2014-01-08 17:33:12 +0000 | [diff] [blame] | 43 | #define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)(((small_int) << 1) | 1)) |
| 44 | |
| 45 | #define MP_OBJ_QSTR_VALUE(o) (((mp_small_int_t)(o)) >> 2) |
| 46 | #define MP_OBJ_NEW_QSTR(qstr) ((mp_obj_t)((((machine_uint_t)qstr) << 2) | 2)) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 47 | |
| 48 | // These macros are used to declare and define constant function objects |
| 49 | // You can put "static" in front of the definitions to make them local |
| 50 | |
| 51 | #define MP_DECLARE_CONST_FUN_OBJ(obj_name) extern const mp_obj_fun_native_t obj_name |
| 52 | |
Damien George | 5104775 | 2014-02-26 17:40:52 +0000 | [diff] [blame] | 53 | #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} |
John R. Lenton | 270112f | 2014-01-07 18:01:08 +0000 | [diff] [blame] | 54 | #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) |
| 55 | #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) |
| 56 | #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) |
| 57 | #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) |
Damien George | d5e8182 | 2014-02-26 17:47:05 +0000 | [diff] [blame] | 58 | #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, MP_OBJ_FUN_ARGS_MAX, (mp_fun_var_t)fun_name) |
John R. Lenton | 270112f | 2014-01-07 18:01:08 +0000 | [diff] [blame] | 59 | #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) |
Damien George | d5e8182 | 2014-02-26 17:47:05 +0000 | [diff] [blame] | 60 | #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, MP_OBJ_FUN_ARGS_MAX, (mp_fun_kw_t)fun_name) |
John R. Lenton | c06763a | 2014-01-07 17:29:16 +0000 | [diff] [blame] | 61 | |
Damien George | 9b196cd | 2014-03-26 21:47:19 +0000 | [diff] [blame] | 62 | // This macro is used to define constant dict objects |
| 63 | // You can put "static" in front of the definition to make it local |
| 64 | |
| 65 | #define MP_DEFINE_CONST_DICT(dict_name, table_name) \ |
| 66 | const mp_obj_dict_t dict_name = { \ |
| 67 | .base = {&dict_type}, \ |
| 68 | .map = { \ |
| 69 | .all_keys_are_qstrs = 1, \ |
| 70 | .table_is_fixed_array = 1, \ |
| 71 | .used = sizeof(table_name) / sizeof(mp_map_elem_t), \ |
| 72 | .alloc = sizeof(table_name) / sizeof(mp_map_elem_t), \ |
| 73 | .table = (mp_map_elem_t*)table_name, \ |
| 74 | }, \ |
| 75 | } |
| 76 | |
Damien George | eae1644 | 2014-01-11 19:22:29 +0000 | [diff] [blame] | 77 | // These macros are used to declare and define constant staticmethond and classmethod objects |
| 78 | // You can put "static" in front of the definitions to make them local |
| 79 | |
Damien George | 64131f3 | 2014-02-06 20:31:44 +0000 | [diff] [blame] | 80 | #define MP_DECLARE_CONST_STATICMETHOD_OBJ(obj_name) extern const mp_obj_static_class_method_t obj_name |
| 81 | #define MP_DECLARE_CONST_CLASSMETHOD_OBJ(obj_name) extern const mp_obj_static_class_method_t obj_name |
Damien George | eae1644 | 2014-01-11 19:22:29 +0000 | [diff] [blame] | 82 | |
Damien George | 64131f3 | 2014-02-06 20:31:44 +0000 | [diff] [blame] | 83 | #define MP_DEFINE_CONST_STATICMETHOD_OBJ(obj_name, fun_name) const mp_obj_static_class_method_t obj_name = {{&mp_type_staticmethod}, fun_name} |
| 84 | #define MP_DEFINE_CONST_CLASSMETHOD_OBJ(obj_name, fun_name) const mp_obj_static_class_method_t obj_name = {{&mp_type_classmethod}, fun_name} |
Damien George | eae1644 | 2014-01-11 19:22:29 +0000 | [diff] [blame] | 85 | |
John R. Lenton | c06763a | 2014-01-07 17:29:16 +0000 | [diff] [blame] | 86 | // Need to declare this here so we are not dependent on map.h |
| 87 | struct _mp_map_t; |
Damien George | 062478e | 2014-01-09 20:57:50 +0000 | [diff] [blame] | 88 | struct _mp_map_elem_t; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 89 | |
| 90 | // Type definitions for methods |
| 91 | |
| 92 | typedef mp_obj_t (*mp_fun_0_t)(void); |
| 93 | typedef mp_obj_t (*mp_fun_1_t)(mp_obj_t); |
| 94 | typedef mp_obj_t (*mp_fun_2_t)(mp_obj_t, mp_obj_t); |
John R. Lenton | 45a8744 | 2014-01-04 01:15:01 +0000 | [diff] [blame] | 95 | typedef mp_obj_t (*mp_fun_3_t)(mp_obj_t, mp_obj_t, mp_obj_t); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 96 | typedef mp_obj_t (*mp_fun_t)(void); |
Damien George | a11ceca | 2014-01-19 16:02:09 +0000 | [diff] [blame] | 97 | typedef mp_obj_t (*mp_fun_var_t)(uint n, const mp_obj_t *); |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 98 | typedef mp_obj_t (*mp_fun_kw_t)(uint n, const mp_obj_t *, struct _mp_map_t *); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 99 | |
Paul Sokolovsky | 76d982e | 2014-01-13 19:19:16 +0200 | [diff] [blame] | 100 | typedef enum { |
| 101 | PRINT_STR, PRINT_REPR |
| 102 | } mp_print_kind_t; |
| 103 | |
| 104 | typedef void (*mp_print_fun_t)(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o, mp_print_kind_t kind); |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 105 | 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); |
| 106 | typedef mp_obj_t (*mp_call_fun_t)(mp_obj_t fun, uint n_args, uint n_kw, const mp_obj_t *args); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 107 | typedef mp_obj_t (*mp_unary_op_fun_t)(int op, mp_obj_t); |
| 108 | typedef mp_obj_t (*mp_binary_op_fun_t)(int op, mp_obj_t, mp_obj_t); |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 109 | 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 |
Damien George | 062478e | 2014-01-09 20:57:50 +0000 | [diff] [blame] | 110 | typedef bool (*mp_store_attr_fun_t)(mp_obj_t self_in, qstr attr, mp_obj_t value); // return true if store succeeded |
Paul Sokolovsky | 6d8edf6 | 2014-01-18 13:10:51 +0200 | [diff] [blame] | 111 | 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 |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 112 | |
| 113 | typedef struct _mp_method_t { |
Damien George | c12b221 | 2014-03-26 20:15:40 +0000 | [diff] [blame] | 114 | qstr name; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 115 | mp_const_obj_t fun; |
| 116 | } mp_method_t; |
| 117 | |
Paul Sokolovsky | 5b15daf | 2014-01-07 20:12:26 +0200 | [diff] [blame] | 118 | // Buffer protocol |
| 119 | typedef struct _buffer_info_t { |
| 120 | // if we'd bother to support various versions of structure |
| 121 | // (with different number of fields), we can distinguish |
| 122 | // them with ver = sizeof(struct). Cons: overkill for *micro*? |
| 123 | //int ver; // ? |
| 124 | |
| 125 | void *buf; |
| 126 | machine_int_t len; |
| 127 | |
| 128 | // Rationale: have array.array and have SIMD operations on them |
| 129 | // Cons: users can pass item size to processing functions themselves, |
| 130 | // though that's not "plug&play" |
| 131 | // int itemsize; |
| 132 | |
| 133 | // Rationale: to load arbitrary-sized sprites directly to LCD |
| 134 | // Cons: a bit adhoc usecase |
| 135 | // int stride; |
| 136 | } buffer_info_t; |
| 137 | #define BUFFER_READ (1) |
| 138 | #define BUFFER_WRITE (2) |
| 139 | #define BUFFER_RW (BUFFER_READ | BUFFER_WRITE) |
| 140 | typedef struct _mp_buffer_p_t { |
| 141 | machine_int_t (*get_buffer)(mp_obj_t obj, buffer_info_t *bufinfo, int flags); |
| 142 | } mp_buffer_p_t; |
| 143 | |
| 144 | // Stream protocol |
| 145 | typedef struct _mp_stream_p_t { |
| 146 | // On error, functions should return -1 and fill in *errcode (values are |
| 147 | // implementation-dependent, but will be exposed to user, e.g. via exception). |
| 148 | machine_int_t (*read)(mp_obj_t obj, void *buf, machine_uint_t size, int *errcode); |
| 149 | machine_int_t (*write)(mp_obj_t obj, const void *buf, machine_uint_t size, int *errcode); |
| 150 | // add seek() ? |
| 151 | } mp_stream_p_t; |
| 152 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 153 | struct _mp_obj_type_t { |
| 154 | mp_obj_base_t base; |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 155 | qstr name; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 156 | mp_print_fun_t print; |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 157 | mp_make_new_fun_t make_new; // to make an instance of the type |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 158 | |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 159 | mp_call_fun_t call; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 160 | mp_unary_op_fun_t unary_op; // can return NULL if op not supported |
| 161 | mp_binary_op_fun_t binary_op; // can return NULL if op not supported |
| 162 | |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 163 | mp_load_attr_fun_t load_attr; |
| 164 | mp_store_attr_fun_t store_attr; |
| 165 | // Implements container[index] = val; note that load_item is implemented |
| 166 | // by binary_op(RT_BINARY_OP_SUBSCR) |
| 167 | mp_store_item_fun_t store_item; |
| 168 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 169 | mp_fun_1_t getiter; |
Damien George | 66eaf84 | 2014-03-26 19:27:58 +0000 | [diff] [blame] | 170 | mp_fun_1_t iternext; // may return MP_OBJ_NULL as an optimisation instead of raising StopIteration() (with no args) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 171 | |
Paul Sokolovsky | 5b15daf | 2014-01-07 20:12:26 +0200 | [diff] [blame] | 172 | // Alternatively, pointer(s) to interfaces to save space |
| 173 | // in mp_obj_type_t at the expense of extra pointer and extra dereference |
| 174 | // when actually used. |
| 175 | mp_buffer_p_t buffer_p; |
| 176 | mp_stream_p_t stream_p; |
| 177 | |
Damien George | 004cdce | 2014-01-09 21:43:51 +0000 | [diff] [blame] | 178 | // these are for dynamically created types (classes) |
| 179 | mp_obj_t bases_tuple; |
| 180 | mp_obj_t locals_dict; |
Damien George | 062478e | 2014-01-09 20:57:50 +0000 | [diff] [blame] | 181 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 182 | /* |
| 183 | What we might need to add here: |
| 184 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 185 | store_subscr list dict |
| 186 | |
| 187 | len str tuple list map |
| 188 | abs float complex |
| 189 | hash bool int none str |
| 190 | equal int str |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 191 | |
| 192 | unpack seq list tuple |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 193 | */ |
| 194 | }; |
| 195 | |
ian-v | 7a16fad | 2014-01-06 09:52:29 -0800 | [diff] [blame] | 196 | typedef struct _mp_obj_type_t mp_obj_type_t; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 197 | |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 198 | // Constant types, globally accessible |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 199 | extern const mp_obj_type_t mp_type_type; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 200 | |
| 201 | // Exceptions |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 202 | extern const mp_obj_type_t mp_type_BaseException; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 203 | extern const mp_obj_type_t mp_type_ArithmeticError; |
| 204 | extern const mp_obj_type_t mp_type_AssertionError; |
| 205 | extern const mp_obj_type_t mp_type_AttributeError; |
| 206 | extern const mp_obj_type_t mp_type_BufferError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 207 | extern const mp_obj_type_t mp_type_EOFError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 208 | extern const mp_obj_type_t mp_type_Exception; |
| 209 | extern const mp_obj_type_t mp_type_FloatingPointError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 210 | extern const mp_obj_type_t mp_type_GeneratorExit; |
| 211 | extern const mp_obj_type_t mp_type_IOError; |
| 212 | extern const mp_obj_type_t mp_type_ImportError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 213 | extern const mp_obj_type_t mp_type_IndentationError; |
| 214 | extern const mp_obj_type_t mp_type_IndexError; |
| 215 | extern const mp_obj_type_t mp_type_KeyError; |
| 216 | extern const mp_obj_type_t mp_type_LookupError; |
| 217 | extern const mp_obj_type_t mp_type_MemoryError; |
| 218 | extern const mp_obj_type_t mp_type_NameError; |
| 219 | extern const mp_obj_type_t mp_type_NotImplementedError; |
| 220 | extern const mp_obj_type_t mp_type_OSError; |
| 221 | extern const mp_obj_type_t mp_type_OverflowError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 222 | extern const mp_obj_type_t mp_type_RuntimeError; |
Damien George | ffb5cfc | 2014-03-25 14:29:40 +0000 | [diff] [blame] | 223 | extern const mp_obj_type_t mp_type_StopIteration; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 224 | extern const mp_obj_type_t mp_type_SyntaxError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 225 | extern const mp_obj_type_t mp_type_SystemError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 226 | extern const mp_obj_type_t mp_type_TypeError; |
| 227 | extern const mp_obj_type_t mp_type_UnboundLocalError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 228 | extern const mp_obj_type_t mp_type_ValueError; |
Rachel Dowdall | 721c55d | 2014-03-22 15:28:16 +0000 | [diff] [blame] | 229 | extern const mp_obj_type_t mp_type_ZeroDivisionError; |
| 230 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 231 | // Constant objects, globally accessible |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 232 | extern const mp_obj_t mp_const_none; |
| 233 | extern const mp_obj_t mp_const_false; |
| 234 | extern const mp_obj_t mp_const_true; |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 235 | extern const mp_obj_t mp_const_empty_tuple; |
Damien George | e9906ac | 2014-01-04 18:44:46 +0000 | [diff] [blame] | 236 | extern const mp_obj_t mp_const_ellipsis; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 237 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 238 | // General API for objects |
| 239 | |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 240 | mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 241 | mp_obj_t mp_obj_new_none(void); |
| 242 | mp_obj_t mp_obj_new_bool(bool value); |
Damien George | 6baf76e | 2013-12-30 22:32:17 +0000 | [diff] [blame] | 243 | mp_obj_t mp_obj_new_cell(mp_obj_t obj); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 244 | mp_obj_t mp_obj_new_int(machine_int_t value); |
Paul Sokolovsky | 48b3572 | 2014-01-12 17:30:48 +0200 | [diff] [blame] | 245 | mp_obj_t mp_obj_new_int_from_uint(machine_uint_t value); |
| 246 | mp_obj_t mp_obj_new_int_from_long_str(const char *s); |
Damien George | 9d68e9c | 2014-03-12 15:38:15 +0000 | [diff] [blame] | 247 | 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) |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 248 | mp_obj_t mp_obj_new_str(const byte* data, uint len, bool make_qstr_if_not_already); |
Paul Sokolovsky | 91fb1c9 | 2014-01-24 22:50:40 +0200 | [diff] [blame] | 249 | mp_obj_t mp_obj_new_bytes(const byte* data, uint len); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 250 | #if MICROPY_ENABLE_FLOAT |
| 251 | mp_obj_t mp_obj_new_float(mp_float_t val); |
| 252 | mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag); |
| 253 | #endif |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 254 | mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type); |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 255 | mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, uint n_args, const mp_obj_t *args); |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 256 | mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg); |
| 257 | 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!) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 258 | mp_obj_t mp_obj_new_range(int start, int stop, int step); |
| 259 | mp_obj_t mp_obj_new_range_iterator(int cur, int stop, int step); |
Damien George | bee17b0 | 2014-03-27 11:07:04 +0000 | [diff] [blame^] | 260 | mp_obj_t mp_obj_new_fun_bc(uint scope_flags, qstr *args, uint n_args, mp_obj_t def_args, const byte *code); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 261 | mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun); |
Damien George | d0691cc | 2014-01-29 20:30:52 +0000 | [diff] [blame] | 262 | mp_obj_t mp_obj_new_gen_wrap(mp_obj_t fun); |
Damien George | bee17b0 | 2014-03-27 11:07:04 +0000 | [diff] [blame^] | 263 | mp_obj_t mp_obj_new_gen_instance(const byte *bytecode, int n_args, const mp_obj_t *args); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 264 | mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple); |
John R. Lenton | c06763a | 2014-01-07 17:29:16 +0000 | [diff] [blame] | 265 | mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 266 | mp_obj_t mp_obj_new_list(uint n, mp_obj_t *items); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 267 | mp_obj_t mp_obj_new_dict(int n_args); |
| 268 | mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items); |
Paul Sokolovsky | 1c6de11 | 2014-01-03 02:41:17 +0200 | [diff] [blame] | 269 | mp_obj_t mp_obj_new_slice(mp_obj_t start, mp_obj_t stop, mp_obj_t step); |
Damien George | 35e2a4e | 2014-02-05 00:51:47 +0000 | [diff] [blame] | 270 | mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj); |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 271 | mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self); |
Damien George | 7c9c667 | 2014-01-25 00:17:36 +0000 | [diff] [blame] | 272 | mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args); |
Damien George | 2870862 | 2014-01-02 21:30:26 +0000 | [diff] [blame] | 273 | mp_obj_t mp_obj_new_module(qstr module_name); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 274 | |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 275 | mp_obj_type_t *mp_obj_get_type(mp_obj_t o_in); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 276 | const char *mp_obj_get_type_str(mp_obj_t o_in); |
Damien George | 9e6e935 | 2014-03-26 18:37:06 +0000 | [diff] [blame] | 277 | bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo); // arguments should be type objects |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 278 | |
Paul Sokolovsky | 76d982e | 2014-01-13 19:19:16 +0200 | [diff] [blame] | 279 | void mp_obj_print_helper(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind); |
| 280 | void mp_obj_print(mp_obj_t o, mp_print_kind_t kind); |
Damien George | 136b149 | 2014-01-19 12:38:49 +0000 | [diff] [blame] | 281 | void mp_obj_print_exception(mp_obj_t exc); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 282 | |
| 283 | bool mp_obj_is_callable(mp_obj_t o_in); |
| 284 | machine_int_t mp_obj_hash(mp_obj_t o_in); |
| 285 | bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2); |
| 286 | bool mp_obj_less(mp_obj_t o1, mp_obj_t o2); |
| 287 | |
| 288 | machine_int_t mp_obj_get_int(mp_obj_t arg); |
| 289 | #if MICROPY_ENABLE_FLOAT |
| 290 | mp_float_t mp_obj_get_float(mp_obj_t self_in); |
| 291 | void mp_obj_get_complex(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag); |
| 292 | #endif |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 293 | //qstr mp_obj_get_qstr(mp_obj_t arg); |
Damien George | 24ff063 | 2014-03-24 10:47:13 +0000 | [diff] [blame] | 294 | void mp_obj_get_array(mp_obj_t o, uint *len, mp_obj_t **items); |
| 295 | void mp_obj_get_array_fixed_n(mp_obj_t o, uint len, mp_obj_t **items); |
xbe | 9e1e8cd | 2014-03-12 22:57:16 -0700 | [diff] [blame] | 296 | uint mp_get_index(const mp_obj_type_t *type, machine_uint_t len, mp_obj_t index, bool is_slice); |
John R. Lenton | 4bee76e | 2014-01-10 11:25:03 +0000 | [diff] [blame] | 297 | mp_obj_t mp_obj_len_maybe(mp_obj_t o_in); /* may return NULL */ |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 298 | |
Damien George | 3ec0a1a | 2014-03-22 21:31:28 +0000 | [diff] [blame] | 299 | // object |
| 300 | extern const mp_obj_type_t mp_type_object; |
| 301 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 302 | // none |
| 303 | extern const mp_obj_type_t none_type; |
| 304 | |
| 305 | // bool |
| 306 | extern const mp_obj_type_t bool_type; |
John R. Lenton | b8698fc | 2014-01-11 00:58:59 +0000 | [diff] [blame] | 307 | #define MP_BOOL(x) (x ? mp_const_true : mp_const_false) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 308 | |
| 309 | // cell |
| 310 | mp_obj_t mp_obj_cell_get(mp_obj_t self_in); |
| 311 | void mp_obj_cell_set(mp_obj_t self_in, mp_obj_t obj); |
| 312 | |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 313 | // int |
| 314 | extern const mp_obj_type_t int_type; |
Paul Sokolovsky | d26b379 | 2014-01-18 16:07:16 +0200 | [diff] [blame] | 315 | // For long int, returns value truncated to machine_int_t |
| 316 | machine_int_t mp_obj_int_get(mp_obj_t self_in); |
Damien George | eabdf67 | 2014-03-22 20:54:01 +0000 | [diff] [blame] | 317 | #if MICROPY_ENABLE_FLOAT |
| 318 | mp_float_t mp_obj_int_as_float(mp_obj_t self_in); |
| 319 | #endif |
Paul Sokolovsky | d26b379 | 2014-01-18 16:07:16 +0200 | [diff] [blame] | 320 | // Will rains exception if value doesn't fit into machine_int_t |
| 321 | machine_int_t mp_obj_int_get_checked(mp_obj_t self_in); |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 322 | |
Damien | b86e3f9 | 2013-12-29 17:17:43 +0000 | [diff] [blame] | 323 | // exception |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 324 | bool mp_obj_is_exception_type(mp_obj_t self_in); |
| 325 | bool mp_obj_is_exception_instance(mp_obj_t self_in); |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 326 | bool mp_obj_exception_match(mp_obj_t exc, const mp_obj_type_t *exc_type); |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 327 | void mp_obj_exception_clear_traceback(mp_obj_t self_in); |
Damien George | 136b149 | 2014-01-19 12:38:49 +0000 | [diff] [blame] | 328 | void mp_obj_exception_add_traceback(mp_obj_t self_in, qstr file, machine_uint_t line, qstr block); |
| 329 | void mp_obj_exception_get_traceback(mp_obj_t self_in, machine_uint_t *n, machine_uint_t **values); |
Paul Sokolovsky | af1ae30 | 2014-03-26 19:17:20 +0200 | [diff] [blame] | 330 | mp_obj_t mp_obj_exception_get_value(mp_obj_t self_in); |
Damien | b86e3f9 | 2013-12-29 17:17:43 +0000 | [diff] [blame] | 331 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 332 | // str |
| 333 | extern const mp_obj_type_t str_type; |
Paul Sokolovsky | 91fb1c9 | 2014-01-24 22:50:40 +0200 | [diff] [blame] | 334 | mp_obj_t mp_obj_str_builder_start(const mp_obj_type_t *type, uint len, byte **data); |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 335 | mp_obj_t mp_obj_str_builder_end(mp_obj_t o_in); |
| 336 | bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2); |
| 337 | uint mp_obj_str_get_hash(mp_obj_t self_in); |
| 338 | uint mp_obj_str_get_len(mp_obj_t self_in); |
Damien George | b829b5c | 2014-01-25 13:51:19 +0000 | [diff] [blame] | 339 | qstr mp_obj_str_get_qstr(mp_obj_t self_in); // use this if you will anyway convert the string to a qstr |
Damien George | 5fa93b6 | 2014-01-22 14:35:10 +0000 | [diff] [blame] | 340 | const char *mp_obj_str_get_str(mp_obj_t self_in); // use this only if you need the string to be null terminated |
Damien George | 698ec21 | 2014-02-08 18:17:23 +0000 | [diff] [blame] | 341 | const char *mp_obj_str_get_data(mp_obj_t self_in, uint *len); |
Paul Sokolovsky | 0b7e29c | 2014-01-28 03:40:06 +0200 | [diff] [blame] | 342 | void mp_str_print_quoted(void (*print)(void *env, const char *fmt, ...), void *env, const byte *str_data, uint str_len); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 343 | |
Paul Sokolovsky | 91fb1c9 | 2014-01-24 22:50:40 +0200 | [diff] [blame] | 344 | // bytes |
| 345 | extern const mp_obj_type_t bytes_type; |
| 346 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 347 | #if MICROPY_ENABLE_FLOAT |
| 348 | // float |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 349 | typedef struct _mp_obj_float_t { |
| 350 | mp_obj_base_t base; |
| 351 | mp_float_t value; |
| 352 | } mp_obj_float_t; |
| 353 | extern const mp_obj_type_t mp_type_float; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 354 | mp_float_t mp_obj_float_get(mp_obj_t self_in); |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 355 | mp_obj_t mp_obj_float_binary_op(int op, mp_float_t lhs_val, mp_obj_t rhs); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 356 | |
| 357 | // complex |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 358 | extern const mp_obj_type_t mp_type_complex; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 359 | void mp_obj_complex_get(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag); |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 360 | 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); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 361 | #endif |
| 362 | |
| 363 | // tuple |
| 364 | extern const mp_obj_type_t tuple_type; |
| 365 | void mp_obj_tuple_get(mp_obj_t self_in, uint *len, mp_obj_t **items); |
John R. Lenton | 07205ec | 2014-01-13 02:31:00 +0000 | [diff] [blame] | 366 | void mp_obj_tuple_del(mp_obj_t self_in); |
Damien George | 7f8be59 | 2014-03-20 19:20:59 +0000 | [diff] [blame] | 367 | machine_int_t mp_obj_tuple_hash(mp_obj_t self_in); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 368 | |
| 369 | // list |
| 370 | extern const mp_obj_type_t list_type; |
| 371 | mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg); |
| 372 | void mp_obj_list_get(mp_obj_t self_in, uint *len, mp_obj_t **items); |
| 373 | void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value); |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 374 | mp_obj_t mp_obj_list_sort(uint n_args, const mp_obj_t *args, struct _mp_map_t *kwargs); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 375 | |
John R. Lenton | 39b174e | 2014-01-15 01:10:09 +0000 | [diff] [blame] | 376 | // map (the python builtin, not the dict implementation detail) |
| 377 | extern const mp_obj_type_t map_type; |
| 378 | |
John R. Lenton | 9daa789 | 2014-01-14 23:55:01 +0000 | [diff] [blame] | 379 | // enumerate |
| 380 | extern const mp_obj_type_t enumerate_type; |
| 381 | |
John R. Lenton | fca456b | 2014-01-15 01:37:08 +0000 | [diff] [blame] | 382 | // filter |
| 383 | extern const mp_obj_type_t filter_type; |
| 384 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 385 | // dict |
| 386 | extern const mp_obj_type_t dict_type; |
Damien | dae7eb7 | 2013-12-29 22:32:51 +0000 | [diff] [blame] | 387 | uint mp_obj_dict_len(mp_obj_t self_in); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 388 | mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value); |
Damien George | 062478e | 2014-01-09 20:57:50 +0000 | [diff] [blame] | 389 | struct _mp_map_t *mp_obj_dict_get_map(mp_obj_t self_in); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 390 | |
| 391 | // set |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 392 | extern const mp_obj_type_t set_type; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 393 | void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item); |
| 394 | |
Paul Sokolovsky | 1c6de11 | 2014-01-03 02:41:17 +0200 | [diff] [blame] | 395 | // slice |
| 396 | extern const mp_obj_type_t slice_type; |
| 397 | void mp_obj_slice_get(mp_obj_t self_in, machine_int_t *start, machine_int_t *stop, machine_int_t *step); |
| 398 | |
John R. Lenton | 07205ec | 2014-01-13 02:31:00 +0000 | [diff] [blame] | 399 | // zip |
| 400 | extern const mp_obj_type_t zip_type; |
| 401 | |
Paul Sokolovsky | 427905c | 2014-01-18 19:24:47 +0200 | [diff] [blame] | 402 | // array |
Damien George | caac542 | 2014-03-25 14:18:18 +0000 | [diff] [blame] | 403 | extern const mp_obj_type_t mp_type_array; |
Paul Sokolovsky | 3399668 | 2014-01-21 23:30:10 +0200 | [diff] [blame] | 404 | uint mp_obj_array_len(mp_obj_t self_in); |
Paul Sokolovsky | 7f11c79 | 2014-01-29 00:21:41 +0200 | [diff] [blame] | 405 | mp_obj_t mp_obj_new_bytearray_by_ref(uint n, void *items); |
John R. Lenton | 07205ec | 2014-01-13 02:31:00 +0000 | [diff] [blame] | 406 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 407 | // functions |
Damien George | d5e8182 | 2014-02-26 17:47:05 +0000 | [diff] [blame] | 408 | #define MP_OBJ_FUN_ARGS_MAX (0xffff) // to set maximum value in n_args_max below |
Damien George | 66028ab | 2014-01-03 14:03:48 +0000 | [diff] [blame] | 409 | typedef struct _mp_obj_fun_native_t { // need this so we can define const objects (to go in ROM) |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 410 | mp_obj_base_t base; |
Damien George | 5104775 | 2014-02-26 17:40:52 +0000 | [diff] [blame] | 411 | bool is_kw : 1; |
Damien George | d5e8182 | 2014-02-26 17:47:05 +0000 | [diff] [blame] | 412 | uint n_args_min : 15; // inclusive |
| 413 | uint n_args_max : 16; // inclusive |
Damien | 660365e | 2013-12-17 18:27:24 +0000 | [diff] [blame] | 414 | void *fun; |
Damien George | 66028ab | 2014-01-03 14:03:48 +0000 | [diff] [blame] | 415 | // TODO add mp_map_t *globals |
| 416 | // for const function objects, make an empty, const map |
| 417 | // such functions won't be able to access the global scope, but that's probably okay |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 418 | } mp_obj_fun_native_t; |
Damien George | 97209d3 | 2014-01-07 15:58:30 +0000 | [diff] [blame] | 419 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 420 | extern const mp_obj_type_t fun_native_type; |
| 421 | extern const mp_obj_type_t fun_bc_type; |
Damien George | bee17b0 | 2014-03-27 11:07:04 +0000 | [diff] [blame^] | 422 | void mp_obj_fun_bc_get(mp_obj_t self_in, int *n_args, const byte **code); |
Damien | 660365e | 2013-12-17 18:27:24 +0000 | [diff] [blame] | 423 | |
Paul Sokolovsky | dff3f89 | 2014-01-20 18:37:30 +0200 | [diff] [blame] | 424 | mp_obj_t mp_identity(mp_obj_t self); |
Paul Sokolovsky | 557c9d5 | 2014-02-08 21:57:19 +0200 | [diff] [blame] | 425 | MP_DECLARE_CONST_FUN_OBJ(mp_identity_obj); |
Paul Sokolovsky | dff3f89 | 2014-01-20 18:37:30 +0200 | [diff] [blame] | 426 | |
Damien George | 35e2a4e | 2014-02-05 00:51:47 +0000 | [diff] [blame] | 427 | // super |
| 428 | extern const mp_obj_type_t super_type; |
| 429 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 430 | // generator |
| 431 | extern const mp_obj_type_t gen_instance_type; |
Damien | 660365e | 2013-12-17 18:27:24 +0000 | [diff] [blame] | 432 | |
Damien George | 2870862 | 2014-01-02 21:30:26 +0000 | [diff] [blame] | 433 | // module |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 434 | typedef struct _mp_obj_module_t { |
| 435 | mp_obj_base_t base; |
| 436 | qstr name; |
| 437 | struct _mp_map_t *globals; |
| 438 | } mp_obj_module_t; |
| 439 | extern const mp_obj_type_t mp_type_module; |
Damien George | 2870862 | 2014-01-02 21:30:26 +0000 | [diff] [blame] | 440 | struct _mp_map_t *mp_obj_module_get_globals(mp_obj_t self_in); |
Damien George | eae1644 | 2014-01-11 19:22:29 +0000 | [diff] [blame] | 441 | |
| 442 | // staticmethod and classmethod types; defined here so we can make const versions |
| 443 | |
| 444 | extern const mp_obj_type_t mp_type_staticmethod; |
| 445 | extern const mp_obj_type_t mp_type_classmethod; |
| 446 | |
Damien George | 64131f3 | 2014-02-06 20:31:44 +0000 | [diff] [blame] | 447 | // this structure is used for instances of both staticmethod and classmethod |
| 448 | typedef struct _mp_obj_static_class_method_t { |
Damien George | eae1644 | 2014-01-11 19:22:29 +0000 | [diff] [blame] | 449 | mp_obj_base_t base; |
| 450 | mp_obj_t fun; |
Damien George | 64131f3 | 2014-02-06 20:31:44 +0000 | [diff] [blame] | 451 | } mp_obj_static_class_method_t; |
Paul Sokolovsky | 439542f | 2014-01-21 00:19:19 +0200 | [diff] [blame] | 452 | |
| 453 | // sequence helpers |
| 454 | void mp_seq_multiply(const void *items, uint item_sz, uint len, uint times, void *dest); |
Paul Sokolovsky | 7364af2 | 2014-02-02 02:38:22 +0200 | [diff] [blame] | 455 | bool m_seq_get_fast_slice_indexes(machine_uint_t len, mp_obj_t slice, machine_uint_t *begin, machine_uint_t *end); |
Paul Sokolovsky | ee4aaf7 | 2014-02-08 23:17:51 +0200 | [diff] [blame] | 456 | #define m_seq_copy(dest, src, len, item_t) memcpy(dest, src, len * sizeof(item_t)) |
| 457 | #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)); } |
Paul Sokolovsky | 87e85b7 | 2014-02-02 08:24:07 +0200 | [diff] [blame] | 458 | bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, uint len2); |
Paul Sokolovsky | 1a996c4 | 2014-02-08 22:49:46 +0200 | [diff] [blame] | 459 | bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *items2, uint len2); |
Paul Sokolovsky | 0cd1dc0 | 2014-02-10 06:37:11 +0200 | [diff] [blame] | 460 | mp_obj_t mp_seq_index_obj(const mp_obj_t *items, uint len, uint n_args, const mp_obj_t *args); |
Paul Sokolovsky | ac0134d | 2014-02-10 07:10:55 +0200 | [diff] [blame] | 461 | mp_obj_t mp_seq_count_obj(const mp_obj_t *items, uint len, mp_obj_t value); |