obj.h 24.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

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

24
#define MP_OBJ_NULL ((mp_obj_t)0)
25

26
27
28
29
30
// The SENTINEL object is used for various internal purposes where one needs
// an object which is unique from all other objects, including MP_OBJ_NULL.

#define MP_OBJ_SENTINEL ((mp_obj_t)8)

31
32
33
34
// 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
35

36
// In SMALL_INT, next-to-highest bits is used as sign, so both must match for value in range
37
38
#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)))
39
#define MP_OBJ_FITS_SMALL_INT(n) ((((n) ^ ((n) << 1)) & WORD_MSBIT_HIGH) == 0)
40
41
42
43
// these macros have now become inline functions; see below
//#define MP_OBJ_IS_SMALL_INT(o) ((((mp_small_int_t)(o)) & 1) != 0)
//#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)
44
45
46
#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
#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))
47

48
#define MP_OBJ_SMALL_INT_VALUE(o) (((mp_small_int_t)(o)) >> 1)
49
50
51
52
#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))
53
54
55
56
57

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

59
#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 = {{&mp_type_fun_native}, is_kw, n_args_min, n_args_max, (void *)fun_name}
60
61
62
63
#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)
64
#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)
65
#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)
66
#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)
67

68
69
70
71
72
// This macro is used to define constant dict objects
// You can put "static" in front of the definition to make it local

#define MP_DEFINE_CONST_DICT(dict_name, table_name) \
    const mp_obj_dict_t dict_name = { \
73
        .base = {&mp_type_dict}, \
74
75
76
77
78
79
80
81
82
        .map = { \
            .all_keys_are_qstrs = 1, \
            .table_is_fixed_array = 1, \
            .used = sizeof(table_name) / sizeof(mp_map_elem_t), \
            .alloc = sizeof(table_name) / sizeof(mp_map_elem_t), \
            .table = (mp_map_elem_t*)table_name, \
        }, \
    }

83
84
85
// 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

86
87
#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
88

89
90
#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}
91

Damien George's avatar
Damien George committed
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// 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;

// 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 {
    machine_uint_t all_keys_are_qstrs : 1;
    machine_uint_t table_is_fixed_array : 1;
    machine_uint_t used : (8 * sizeof(machine_uint_t) - 2);
    machine_uint_t alloc;
    mp_map_elem_t *table;
} mp_map_t;

112
// These can be or'd together
Damien George's avatar
Damien George committed
113
114
115
116
117
118
typedef enum _mp_map_lookup_kind_t {
    MP_MAP_LOOKUP,                    // 0
    MP_MAP_LOOKUP_ADD_IF_NOT_FOUND,   // 1
    MP_MAP_LOOKUP_REMOVE_IF_FOUND,    // 2
} mp_map_lookup_kind_t;

119
static inline bool MP_MAP_SLOT_IS_FILLED(mp_map_t *map, machine_uint_t pos) { return ((map)->table[pos].key != MP_OBJ_NULL && (map)->table[pos].key != MP_OBJ_SENTINEL); }
120

Damien George's avatar
Damien George committed
121
122
123
124
125
126
127
void mp_map_init(mp_map_t *map, int n);
void mp_map_init_fixed_table(mp_map_t *map, int n, const mp_obj_t *table);
mp_map_t *mp_map_new(int n);
void mp_map_deinit(mp_map_t *map);
void mp_map_free(mp_map_t *map);
mp_map_elem_t* mp_map_lookup(mp_map_t *map, mp_obj_t index, mp_map_lookup_kind_t lookup_kind);
void mp_map_clear(mp_map_t *map);
128
void mp_map_dump(mp_map_t *map);
Damien George's avatar
Damien George committed
129
130
131
132
133
134
135
136
137

// Underlying set implementation (not set object)

typedef struct _mp_set_t {
    machine_uint_t alloc;
    machine_uint_t used;
    mp_obj_t *table;
} mp_set_t;

138
static inline bool MP_SET_SLOT_IS_FILLED(mp_set_t *set, machine_uint_t pos) { return ((set)->table[pos] != MP_OBJ_NULL && (set)->table[pos] != MP_OBJ_SENTINEL); }
139

Damien George's avatar
Damien George committed
140
141
void mp_set_init(mp_set_t *set, int n);
mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t lookup_kind);
142
mp_obj_t mp_set_remove_first(mp_set_t *set);
Damien George's avatar
Damien George committed
143
void mp_set_clear(mp_set_t *set);
144
145
146
147
148
149

// 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);
150
typedef mp_obj_t (*mp_fun_3_t)(mp_obj_t, mp_obj_t, mp_obj_t);
151
typedef mp_obj_t (*mp_fun_t)(void);
152
typedef mp_obj_t (*mp_fun_var_t)(uint n, const mp_obj_t *);
Damien George's avatar
Damien George committed
153
typedef mp_obj_t (*mp_fun_kw_t)(uint n, const mp_obj_t *, mp_map_t *);
154

155
typedef enum {
156
157
158
    PRINT_STR,
    PRINT_REPR,
    PRINT_EXC, // Special format for printing exception in unhandled exception message
159
160
161
} 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);
162
163
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);
164
165
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);
166
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
167
168
typedef bool (*mp_store_attr_fun_t)(mp_obj_t self_in, qstr attr, mp_obj_t value); // return true if store succeeded; if value==MP_OBJ_NULL then delete
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; if value==MP_OBJ_NULL then delete
169
170

typedef struct _mp_method_t {
171
    qstr name;
172
173
174
    mp_const_obj_t fun;
} mp_method_t;

175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
// 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;
200
201
bool mp_get_buffer(mp_obj_t obj, buffer_info_t *bufinfo);
void mp_get_buffer_raise(mp_obj_t obj, buffer_info_t *bufinfo);
202
203
204
205
206
207
208
209
210
211

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

212
213
struct _mp_obj_type_t {
    mp_obj_base_t base;
214
    qstr name;
215
    mp_print_fun_t print;
216
    mp_make_new_fun_t make_new;     // to make an instance of the type
217

218
    mp_call_fun_t call;
219
220
221
    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

222
    mp_load_attr_fun_t load_attr;
223
    mp_store_attr_fun_t store_attr; // if value is MP_OBJ_NULL, then delete that attribute
224
225
226

    // Implements container[index] = val.  If val == MP_OBJ_NULL, then it's a delete.
    // Note that load_item is implemented by binary_op(RT_BINARY_OP_SUBSCR)
227
228
    mp_store_item_fun_t store_item;

229
    mp_fun_1_t getiter;
230
    mp_fun_1_t iternext; // may return MP_OBJ_NULL as an optimisation instead of raising StopIteration() (with no args)
231

232
233
234
235
    // 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;
236
    const mp_stream_p_t *stream_p;
237

238
239
240
    // these are for dynamically created types (classes)
    mp_obj_t bases_tuple;
    mp_obj_t locals_dict;
241

242
243
244
245
    /*
    What we might need to add here:

    store_subscr    list dict
246

247
248
249
250
251
252
253
254
255
    len             str tuple list map
    abs             float complex
    hash            bool int none str
    equal           int str

    unpack seq      list tuple
    */
};

ian-v's avatar
ian-v committed
256
typedef struct _mp_obj_type_t mp_obj_type_t;
257

258
259
// Constant types, globally accessible
extern const mp_obj_type_t mp_type_type;
260
261
262
263
264
265
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;
266
extern const mp_obj_type_t mp_type_bytearray;
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
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;
extern const mp_obj_type_t mp_type_dict;
extern const mp_obj_type_t mp_type_set;
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;
extern const mp_obj_type_t mp_type_gen_instance;
extern const mp_obj_type_t mp_type_fun_native;
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;
286
extern const mp_obj_type_t mp_type_property;
287
288

// Exceptions
289
extern const mp_obj_type_t mp_type_BaseException;
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
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_IOError;
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_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_RuntimeError;
308
extern const mp_obj_type_t mp_type_StopIteration;
309
310
311
312
313
314
extern const mp_obj_type_t mp_type_SyntaxError;
extern const mp_obj_type_t mp_type_SystemError;
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_ZeroDivisionError;

315
// Constant objects, globally accessible
316
317
318
319
320
321
322
323
324
325
// The macros are for convenience only
#define mp_const_none ((mp_obj_t)&mp_const_none_obj)
#define mp_const_false ((mp_obj_t)&mp_const_false_obj)
#define mp_const_true ((mp_obj_t)&mp_const_true_obj)
#define mp_const_empty_tuple ((mp_obj_t)&mp_const_empty_tuple_obj)
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;
extern const struct _mp_obj_tuple_t mp_const_empty_tuple_obj;
extern const struct _mp_obj_ellipsis_t mp_const_ellipsis_obj;
326
extern const struct _mp_obj_exception_t mp_const_MemoryError_obj;
327
extern const struct _mp_obj_exception_t mp_const_GeneratorExit_obj;
328
329
330

// General API for objects

331
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict);
332
333
mp_obj_t mp_obj_new_none(void);
mp_obj_t mp_obj_new_bool(bool value);
Damien George's avatar
Damien George committed
334
mp_obj_t mp_obj_new_cell(mp_obj_t obj);
335
mp_obj_t mp_obj_new_int(machine_int_t value);
336
337
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);
338
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)
339
mp_obj_t mp_obj_new_str(const byte* data, uint len, bool make_qstr_if_not_already);
340
mp_obj_t mp_obj_new_bytes(const byte* data, uint len);
341
#if MICROPY_ENABLE_FLOAT
342
343
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);
344
#endif
345
mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type);
346
mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, uint n_args, const mp_obj_t *args);
347
348
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!)
349
350
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);
351
mp_obj_t mp_obj_new_fun_bc(uint scope_flags, qstr *args, uint n_args, mp_obj_t def_args, const byte *code);
352
mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun);
353
mp_obj_t mp_obj_new_gen_wrap(mp_obj_t fun);
354
mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple);
355
mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items);
356
357
358
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);
359
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
360
mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj);
361
mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self);
362
mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args);
363
mp_obj_t mp_obj_new_module(qstr module_name);
364

365
mp_obj_type_t *mp_obj_get_type(mp_obj_t o_in);
366
const char *mp_obj_get_type_str(mp_obj_t o_in);
367
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo); // arguments should be type objects
368

369
370
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);
371
void mp_obj_print_exception(mp_obj_t exc);
372

Damien George's avatar
Damien George committed
373
int mp_obj_is_true(mp_obj_t arg);
374
375

// TODO make these all lower case when they have proven themselves
376
377
378
379
380
381
382
static inline bool MP_OBJ_IS_OBJ(mp_const_obj_t o) { return ((((mp_small_int_t)(o)) & 3) == 0); }
static inline bool MP_OBJ_IS_SMALL_INT(mp_const_obj_t o) { return ((((mp_small_int_t)(o)) & 1) != 0); }
//static inline bool MP_OBJ_IS_TYPE(mp_const_obj_t o, const mp_obj_type_t *t) { return (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
//static inline bool MP_OBJ_IS_INT(mp_const_obj_t o) { return (MP_OBJ_IS_SMALL_INT(o) || MP_OBJ_IS_TYPE(o, &mp_type_int)); } // returns true if o is a small int or long int
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
static inline bool MP_OBJ_IS_QSTR(mp_const_obj_t o) { return ((((mp_small_int_t)(o)) & 3) == 2); }
//static inline bool MP_OBJ_IS_STR(mp_const_obj_t o) { return (MP_OBJ_IS_QSTR(o) || MP_OBJ_IS_TYPE(o, &mp_type_str)); }
383

384
385
386
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);
387

388
machine_int_t mp_obj_get_int(mp_obj_t arg);
389
bool mp_obj_get_int_maybe(mp_obj_t arg, machine_int_t *value);
390
#if MICROPY_ENABLE_FLOAT
391
392
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);
393
#endif
394
//qstr mp_obj_get_qstr(mp_obj_t arg);
395
396
void mp_obj_get_array(mp_obj_t o, uint *len, mp_obj_t **items);
void mp_obj_get_array_fixed_n(mp_obj_t o, uint len, mp_obj_t **items);
397
uint mp_get_index(const mp_obj_type_t *type, machine_uint_t len, mp_obj_t index, bool is_slice);
398
mp_obj_t mp_obj_len_maybe(mp_obj_t o_in); /* may return MP_OBJ_NULL */
399
400

// bool
401
// TODO make lower case when it has proven itself
402
static inline mp_obj_t MP_BOOL(machine_int_t x) { return x ? mp_const_true : mp_const_false; }
403
404
405
406
407

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

408
// int
409
410
// For long int, returns value truncated to machine_int_t
machine_int_t mp_obj_int_get(mp_obj_t self_in);
411
412
413
#if MICROPY_ENABLE_FLOAT
mp_float_t mp_obj_int_as_float(mp_obj_t self_in);
#endif
414
415
// 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);
416

417
// exception
418
419
bool mp_obj_is_exception_type(mp_obj_t self_in);
bool mp_obj_is_exception_instance(mp_obj_t self_in);
420
bool mp_obj_exception_match(mp_obj_t exc, const mp_obj_type_t *exc_type);
421
void mp_obj_exception_clear_traceback(mp_obj_t self_in);
422
423
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);
424
mp_obj_t mp_obj_exception_get_value(mp_obj_t self_in);
425

426
// str
427
mp_obj_t mp_obj_str_builder_start(const mp_obj_type_t *type, uint len, byte **data);
428
429
430
431
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);
432
qstr mp_obj_str_get_qstr(mp_obj_t self_in); // use this if you will anyway convert the string to a qstr
433
const char *mp_obj_str_get_str(mp_obj_t self_in); // use this only if you need the string to be null terminated
434
const char *mp_obj_str_get_data(mp_obj_t self_in, uint *len);
435
void mp_str_print_quoted(void (*print)(void *env, const char *fmt, ...), void *env, const byte *str_data, uint str_len);
436
437
438

#if MICROPY_ENABLE_FLOAT
// float
439
440
441
442
typedef struct _mp_obj_float_t {
    mp_obj_base_t base;
    mp_float_t value;
} mp_obj_float_t;
443
mp_float_t mp_obj_float_get(mp_obj_t self_in);
444
mp_obj_t mp_obj_float_binary_op(int op, mp_float_t lhs_val, mp_obj_t rhs); // can return MP_OBJ_NULL
445
446
447

// complex
void mp_obj_complex_get(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag);
448
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); // can return MP_OBJ_NULL
449
450
451
452
#endif

// tuple
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
453
void mp_obj_tuple_del(mp_obj_t self_in);
454
machine_int_t mp_obj_tuple_hash(mp_obj_t self_in);
455
mp_obj_t mp_obj_tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args);
456
457

// list
458
459
struct _mp_obj_list_t;
void mp_obj_list_init(struct _mp_obj_list_t *o, uint n);
460
461
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);
462
void mp_obj_list_set_len(mp_obj_t self_in, uint len);
463
void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value);
Damien George's avatar
Damien George committed
464
mp_obj_t mp_obj_list_sort(uint n_args, const mp_obj_t *args, mp_map_t *kwargs);
465
466

// dict
Damien George's avatar
Damien George committed
467
468
469
470
typedef struct _mp_obj_dict_t {
    mp_obj_base_t base;
    mp_map_t map;
} mp_obj_dict_t;
471
void mp_obj_dict_init(mp_obj_dict_t *dict, int n_args);
472
uint mp_obj_dict_len(mp_obj_t self_in);
473
mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value);
474
mp_obj_t mp_obj_dict_delete(mp_obj_t self_in, mp_obj_t key);
Damien George's avatar
Damien George committed
475
mp_map_t *mp_obj_dict_get_map(mp_obj_t self_in);
476
477
478
479

// set
void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item);

480
481
482
// slice
void mp_obj_slice_get(mp_obj_t self_in, machine_int_t *start, machine_int_t *stop, machine_int_t *step);

483
// array
484
uint mp_obj_array_len(mp_obj_t self_in);
485
mp_obj_t mp_obj_new_bytearray_by_ref(uint n, void *items);
John R. Lenton's avatar
John R. Lenton committed
486

487
// functions
488
#define MP_OBJ_FUN_ARGS_MAX (0xffff) // to set maximum value in n_args_max below
489
typedef struct _mp_obj_fun_native_t { // need this so we can define const objects (to go in ROM)
490
    mp_obj_base_t base;
491
    bool is_kw : 1;
492
493
    uint n_args_min : 15; // inclusive
    uint n_args_max : 16; // inclusive
494
    void *fun;
495
496
497
    // 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
498
} mp_obj_fun_native_t;
499

500
void mp_obj_fun_bc_get(mp_obj_t self_in, int *n_args, const byte **code);
501
502
bool mp_obj_fun_prepare_simple_args(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args,
                            uint *out_args1_len, const mp_obj_t **out_args1, uint *out_args2_len, const mp_obj_t **out_args2);
503

504
mp_obj_t mp_identity(mp_obj_t self);
505
MP_DECLARE_CONST_FUN_OBJ(mp_identity_obj);
506

507
// module
508
509
510
typedef struct _mp_obj_module_t {
    mp_obj_base_t base;
    qstr name;
511
    mp_obj_dict_t *globals;
512
} mp_obj_module_t;
513
mp_obj_dict_t *mp_obj_module_get_globals(mp_obj_t self_in);
514
515

// staticmethod and classmethod types; defined here so we can make const versions
516
517
// this structure is used for instances of both staticmethod and classmethod
typedef struct _mp_obj_static_class_method_t {
518
519
    mp_obj_base_t base;
    mp_obj_t fun;
520
} mp_obj_static_class_method_t;
521

522
523
524
// property
const mp_obj_t *mp_obj_property_get(mp_obj_t self_in);

525
526
// sequence helpers
void mp_seq_multiply(const void *items, uint item_sz, uint len, uint times, void *dest);
527
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
528
#define m_seq_copy(dest, src, len, item_t) memcpy(dest, src, len * sizeof(item_t))
529
#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)); }
530
bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, uint len2);
531
bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *items2, uint len2);
532
mp_obj_t mp_seq_index_obj(const mp_obj_t *items, uint len, uint n_args, const mp_obj_t *args);
533
mp_obj_t mp_seq_count_obj(const mp_obj_t *items, uint len, mp_obj_t value);