obj.h 20.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
// 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;

12
13
// Anything that wants to be a Micro Python object must have
// mp_obj_base_t as its first member (except NULL and small ints)
14

ian-v's avatar
ian-v committed
15
struct _mp_obj_type_t;
16
struct _mp_obj_base_t {
ian-v's avatar
ian-v committed
17
    const struct _mp_obj_type_t *type;
18
};
ian-v's avatar
ian-v committed
19
typedef struct _mp_obj_base_t mp_obj_base_t;
20
21
22
23
24
25

// 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)

26
27
28
29
// 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
30

31
// In SMALL_INT, next-to-highest bits is used as sign, so both must match for value in range
32
33
#define MP_SMALL_INT_MIN ((mp_small_int_t)(((machine_int_t)WORD_MSBIT_HIGH) >> 1))
#define MP_SMALL_INT_MAX ((mp_small_int_t)(~(MP_SMALL_INT_MIN)))
34
#define MP_OBJ_FITS_SMALL_INT(n) ((((n) ^ ((n) << 1)) & WORD_MSBIT_HIGH) == 0)
35
#define MP_OBJ_IS_SMALL_INT(o) ((((mp_small_int_t)(o)) & 1) != 0)
36
37
#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)
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
39
#define MP_OBJ_IS_INT(o) (MP_OBJ_IS_SMALL_INT(o) || MP_OBJ_IS_TYPE(o, &int_type))
40
#define MP_OBJ_IS_STR(o) (MP_OBJ_IS_QSTR(o) || MP_OBJ_IS_TYPE(o, &str_type))
41

42
#define MP_OBJ_SMALL_INT_VALUE(o) (((mp_small_int_t)(o)) >> 1)
43
44
45
46
#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))
47
48
49
50
51

// 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
52

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}
54
55
56
57
#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)
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)
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)
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)
61

62
63
64
// 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

65
66
#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
67

68
69
#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}
70

71
72
// Need to declare this here so we are not dependent on map.h
struct _mp_map_t;
73
struct _mp_map_elem_t;
74
75
76
77
78
79

// 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);
80
typedef mp_obj_t (*mp_fun_3_t)(mp_obj_t, mp_obj_t, mp_obj_t);
81
typedef mp_obj_t (*mp_fun_t)(void);
82
typedef mp_obj_t (*mp_fun_var_t)(uint n, const mp_obj_t *);
83
typedef mp_obj_t (*mp_fun_kw_t)(uint n, const mp_obj_t *, struct _mp_map_t *);
84

85
86
87
88
89
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);
90
91
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);
92
93
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);
94
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
95
typedef bool (*mp_store_attr_fun_t)(mp_obj_t self_in, qstr attr, mp_obj_t value); // return true if store succeeded
96
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
97
98

typedef struct _mp_method_t {
99
    const char *name;
100
101
102
    mp_const_obj_t fun;
} mp_method_t;

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
// 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;

138
139
struct _mp_obj_type_t {
    mp_obj_base_t base;
140
    qstr name;
141
    mp_print_fun_t print;
142
    mp_make_new_fun_t make_new;     // to make an instance of the type
143

144
    mp_call_fun_t call;
145
146
147
    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

148
149
150
151
152
153
    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;

154
155
156
    mp_fun_1_t getiter;
    mp_fun_1_t iternext;

157
158
159
160
161
162
    // 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;

ian-v's avatar
ian-v committed
163
    const mp_method_t *methods;
164

165
166
167
    // these are for dynamically created types (classes)
    mp_obj_t bases_tuple;
    mp_obj_t locals_dict;
168

169
170
171
172
    /*
    What we might need to add here:

    store_subscr    list dict
173

174
175
176
177
178
179
180
181
182
183
    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
    */
};

ian-v's avatar
ian-v committed
184
typedef struct _mp_obj_type_t mp_obj_type_t;
185

186
187
// Constant types, globally accessible
extern const mp_obj_type_t mp_type_type;
188
189

// Exceptions
190
extern const mp_obj_type_t mp_type_BaseException;
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
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_BufferError;
extern const mp_obj_type_t mp_type_BytesWarning;
extern const mp_obj_type_t mp_type_DeprecationWarning;
extern const mp_obj_type_t mp_type_EOFError;
extern const mp_obj_type_t mp_type_EnvironmentError;
extern const mp_obj_type_t mp_type_Exception;
extern const mp_obj_type_t mp_type_FloatingPointError;
extern const mp_obj_type_t mp_type_FutureWarning;
extern const mp_obj_type_t mp_type_GeneratorExit;
extern const mp_obj_type_t mp_type_IOError;
extern const mp_obj_type_t mp_type_ImportError;
extern const mp_obj_type_t mp_type_ImportWarning;
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_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;
extern const mp_obj_type_t mp_type_OverflowError;
extern const mp_obj_type_t mp_type_PendingDeprecationWarning;
extern const mp_obj_type_t mp_type_ReferenceError;
extern const mp_obj_type_t mp_type_ResourceWarning;
extern const mp_obj_type_t mp_type_RuntimeError;
extern const mp_obj_type_t mp_type_RuntimeWarning;
extern const mp_obj_type_t mp_type_SyntaxError;
extern const mp_obj_type_t mp_type_SyntaxWarning;
extern const mp_obj_type_t mp_type_SystemError;
extern const mp_obj_type_t mp_type_SystemExit;
extern const mp_obj_type_t mp_type_TabError;
extern const mp_obj_type_t mp_type_TypeError;
extern const mp_obj_type_t mp_type_UnboundLocalError;
extern const mp_obj_type_t mp_type_UserWarning;
extern const mp_obj_type_t mp_type_ValueError;
extern const mp_obj_type_t mp_type_Warning;
extern const mp_obj_type_t mp_type_ZeroDivisionError;

extern const mp_obj_type_t mp_type_StopIteration;
/*extern const mp_obj_type_t mp_type_BaseException;
234
235
236
237
238
239
240
241
242
243
244
245
246
247
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;
248
extern const mp_obj_type_t mp_type_ZeroDivisionError;*/
249

250
251
252
253
254
// 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;
255
extern const mp_obj_t mp_const_empty_tuple;
Damien George's avatar
Damien George committed
256
extern const mp_obj_t mp_const_ellipsis;
257
258
259
260
extern const mp_obj_t mp_const_stop_iteration; // special object indicating end of iteration (not StopIteration exception!)

// General API for objects

261
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict);
262
263
mp_obj_t mp_obj_new_none(void);
mp_obj_t mp_obj_new_bool(bool value);
Damien George's avatar
Damien George committed
264
mp_obj_t mp_obj_new_cell(mp_obj_t obj);
265
mp_obj_t mp_obj_new_int(machine_int_t value);
266
267
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);
268
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)
269
mp_obj_t mp_obj_new_str(const byte* data, uint len, bool make_qstr_if_not_already);
270
mp_obj_t mp_obj_new_bytes(const byte* data, uint len);
271
#if MICROPY_ENABLE_FLOAT
272
273
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);
274
#endif
275
276
277
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!)
278
279
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);
280
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);
281
mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun);
282
mp_obj_t mp_obj_new_gen_wrap(mp_obj_t fun);
283
mp_obj_t mp_obj_new_gen_instance(const byte *bytecode, uint n_state, int n_args, const mp_obj_t *args);
284
mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple);
285
mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items);
286
287
288
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);
289
mp_obj_t mp_obj_new_slice(mp_obj_t start, mp_obj_t stop, mp_obj_t step);
Damien George's avatar
Damien George committed
290
mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj);
291
mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self);
292
mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args);
293
mp_obj_t mp_obj_new_module(qstr module_name);
294

295
mp_obj_type_t *mp_obj_get_type(mp_obj_t o_in);
296
const char *mp_obj_get_type_str(mp_obj_t o_in);
297
bool mp_obj_is_subclass_fast(mp_obj_t object, mp_obj_t classinfo); // arguments should be type objects
298

299
300
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);
301
void mp_obj_print_exception(mp_obj_t exc);
302

303
304
305
306
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);
307

308
machine_int_t mp_obj_get_int(mp_obj_t arg);
309
#if MICROPY_ENABLE_FLOAT
310
311
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);
312
#endif
313
//qstr mp_obj_get_qstr(mp_obj_t arg);
314
mp_obj_t *mp_obj_get_array_fixed_n(mp_obj_t o, machine_int_t n);
315
uint mp_get_index(const mp_obj_type_t *type, machine_uint_t len, mp_obj_t index, bool is_slice);
316
mp_obj_t mp_obj_len_maybe(mp_obj_t o_in); /* may return NULL */
317
318
319
320
321
322

// none
extern const mp_obj_type_t none_type;

// bool
extern const mp_obj_type_t bool_type;
John R. Lenton's avatar
John R. Lenton committed
323
#define MP_BOOL(x) (x ? mp_const_true : mp_const_false)
324
325
326
327
328

// 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);

329
330
// int
extern const mp_obj_type_t int_type;
331
332
333
334
// 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);
335

336
// exception
337
338
339
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);
340
341
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);
342

343
344
// str
extern const mp_obj_type_t str_type;
345
mp_obj_t mp_obj_str_builder_start(const mp_obj_type_t *type, uint len, byte **data);
346
347
348
349
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);
350
qstr mp_obj_str_get_qstr(mp_obj_t self_in); // use this if you will anyway convert the string to a qstr
351
const char *mp_obj_str_get_str(mp_obj_t self_in); // use this only if you need the string to be null terminated
352
const char *mp_obj_str_get_data(mp_obj_t self_in, uint *len);
353
void mp_str_print_quoted(void (*print)(void *env, const char *fmt, ...), void *env, const byte *str_data, uint str_len);
354

355
356
357
// bytes
extern const mp_obj_type_t bytes_type;

358
359
#if MICROPY_ENABLE_FLOAT
// float
360
361
362
363
364
typedef struct _mp_obj_float_t {
    mp_obj_base_t base;
    mp_float_t value;
} mp_obj_float_t;
extern const mp_obj_type_t mp_type_float;
365
mp_float_t mp_obj_float_get(mp_obj_t self_in);
366
mp_obj_t mp_obj_float_binary_op(int op, mp_float_t lhs_val, mp_obj_t rhs);
367
368

// complex
369
extern const mp_obj_type_t mp_type_complex;
370
void mp_obj_complex_get(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag);
371
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);
372
373
374
375
376
#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);
John R. Lenton's avatar
John R. Lenton committed
377
void mp_obj_tuple_del(mp_obj_t self_in);
378
machine_int_t mp_obj_tuple_hash(mp_obj_t self_in);
379
380
381
382
383
384

// 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);
385
mp_obj_t mp_obj_list_sort(uint n_args, const mp_obj_t *args, struct _mp_map_t *kwargs);
386

John R. Lenton's avatar
John R. Lenton committed
387
388
389
// map (the python builtin, not the dict implementation detail)
extern const mp_obj_type_t map_type;

John R. Lenton's avatar
John R. Lenton committed
390
391
392
// enumerate
extern const mp_obj_type_t enumerate_type;

John R. Lenton's avatar
John R. Lenton committed
393
394
395
// filter
extern const mp_obj_type_t filter_type;

396
397
// dict
extern const mp_obj_type_t dict_type;
398
uint mp_obj_dict_len(mp_obj_t self_in);
399
mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value);
400
struct _mp_map_t *mp_obj_dict_get_map(mp_obj_t self_in);
401
402

// set
403
extern const mp_obj_type_t set_type;
404
405
void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item);

406
407
408
409
// 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);

John R. Lenton's avatar
John R. Lenton committed
410
411
412
// zip
extern const mp_obj_type_t zip_type;

413
414
// array
extern const mp_obj_type_t array_type;
415
uint mp_obj_array_len(mp_obj_t self_in);
416
mp_obj_t mp_obj_new_bytearray_by_ref(uint n, void *items);
John R. Lenton's avatar
John R. Lenton committed
417

418
// functions
419
#define MP_OBJ_FUN_ARGS_MAX (0xffff) // to set maximum value in n_args_max below
420
typedef struct _mp_obj_fun_native_t { // need this so we can define const objects (to go in ROM)
421
    mp_obj_base_t base;
422
    bool is_kw : 1;
423
424
    uint n_args_min : 15; // inclusive
    uint n_args_max : 16; // inclusive
425
    void *fun;
426
427
428
    // 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
429
} mp_obj_fun_native_t;
430

431
432
433
434
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);

435
mp_obj_t mp_identity(mp_obj_t self);
436
MP_DECLARE_CONST_FUN_OBJ(mp_identity_obj);
437

Damien George's avatar
Damien George committed
438
439
440
// super
extern const mp_obj_type_t super_type;

441
442
443
// generator
extern const mp_obj_type_t gen_instance_type;

444
// module
445
446
447
448
449
450
typedef struct _mp_obj_module_t {
    mp_obj_base_t base;
    qstr name;
    struct _mp_map_t *globals;
} mp_obj_module_t;
extern const mp_obj_type_t mp_type_module;
451
mp_obj_t mp_obj_new_module(qstr module_name);
452
mp_obj_t mp_obj_module_get(qstr module_name);
453
struct _mp_map_t *mp_obj_module_get_globals(mp_obj_t self_in);
454
455
456
457
458
459

// 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;

460
461
// this structure is used for instances of both staticmethod and classmethod
typedef struct _mp_obj_static_class_method_t {
462
463
    mp_obj_base_t base;
    mp_obj_t fun;
464
} mp_obj_static_class_method_t;
465
466
467

// sequence helpers
void mp_seq_multiply(const void *items, uint item_sz, uint len, uint times, void *dest);
468
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's avatar
Paul Sokolovsky committed
469
470
#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)); }
471
bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, uint len2);
472
bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *items2, uint len2);
473
mp_obj_t mp_seq_index_obj(const mp_obj_t *items, uint len, uint n_args, const mp_obj_t *args);
474
mp_obj_t mp_seq_count_obj(const mp_obj_t *items, uint len, mp_obj_t value);