djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
circuitpython/py/vm.c

639 lines
24 KiB
C
Raw Normal View History

Initial commit.
2013-10-04 14:53:11 -04:00
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#include "nlr.h"
Initial commit.
2013-10-04 14:53:11 -04:00
#include "misc.h"
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
#include "mpconfig.h"
Revamp qstrs: they now include length and hash. Can now have null bytes in strings. Can define ROM qstrs per port using qstrdefsport.h
2014-01-21 16:40:13 -05:00
#include "qstr.h"
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
#include "obj.h"
Initial commit.
2013-10-04 14:53:11 -04:00
#include "runtime.h"
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
#include "bc0.h"
Simplify and improve function & method calling.
2013-10-10 17:06:54 -04:00
#include "bc.h"
Initial commit.
2013-10-04 14:53:11 -04:00
Update VM stacks comments.
2014-01-31 12:45:15 -05:00
// Value stack grows up (this makes it incompatible with native C stack, but
// makes sure that arguments to functions are in natural order arg1..argN
// (Python semantics mandates left-to-right evaluation order, including for
// function arguments). Stack pointer is pre-incremented and points at the
// top element.
// Exception stack also grows up, top element is also pointed at.
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
// Exception stack entry
typedef struct _mp_exc_stack {
const byte *handler;
// bit 0 is saved currently_in_except_block value
machine_uint_t val_sp;
// We might only have 2 interesting cases here: SETUP_EXCEPT & SETUP_FINALLY,
// consider storing it in bit 1 of val_sp. TODO: SETUP_WITH?
byte opcode;
} mp_exc_stack;
Add exception stack unwind support for RETURN_VALUE. This properly implements return from try/finally block(s). TODO: Consider if we need to do any value stack unwinding for RETURN_VALUE case. Intuitively, this is "success" return, so value stack should be in good shape, and unwinding shouldn't be required.
2014-01-31 17:55:05 -05:00
// Exception stack unwind reasons (WHY_* in CPython-speak)
typedef enum {
UNWIND_RETURN = 1,
UNWIND_BREAK,
UNWIND_CONTINUE,
} mp_unwind_reason_t;
Initial commit.
2013-10-04 14:53:11 -04:00
#define DECODE_UINT do { unum = *ip++; if (unum > 127) { unum = ((unum & 0x3f) << 8) | (*ip++); } } while (0)
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
#define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
#define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
#define DECODE_QSTR do { qst = *ip++; if (qst > 127) { qst = ((qst & 0x3f) << 8) | (*ip++); } } while (0)
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
#define PUSH(val) *++sp = (val)
#define POP() (*sp--)
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
#define TOP() (*sp)
#define SET_TOP(val) *sp = (val)
Initial commit.
2013-10-04 14:53:11 -04:00
py: mp_execute_byte_code has 2 arg arrays, for more efficient default params.
2014-02-01 13:29:40 -05:00
mp_obj_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, uint n_state) {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// allocate state for locals and stack
mp_obj_t temp_state[10];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_obj_t *state = &temp_state[0];
Improve allocation of stack for byte code.
2013-11-05 17:16:22 -05:00
if (n_state > 10) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
state = m_new(mp_obj_t, n_state);
Improve allocation of stack for byte code.
2013-11-05 17:16:22 -05:00
}
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
mp_obj_t *sp = &state[0] - 1;
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
// init args
py: mp_execute_byte_code has 2 arg arrays, for more efficient default params.
2014-02-01 13:29:40 -05:00
for (uint i = 0; i < n_args; i++) {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
state[n_state - 1 - i] = args[i];
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
}
py: mp_execute_byte_code has 2 arg arrays, for more efficient default params.
2014-02-01 13:29:40 -05:00
for (uint i = 0; i < n_args2; i++) {
state[n_state - 1 - n_args - i] = args2[i];
}
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
const byte *ip = code;
py: make closures work.
2013-12-30 17:32:17 -05:00
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
// get code info size
machine_uint_t code_info_size = ip[0] | (ip[1] << 8) | (ip[2] << 16) | (ip[3] << 24);
ip += code_info_size;
py: make closures work.
2013-12-30 17:32:17 -05:00
// execute prelude to make any cells (closed over variables)
{
for (uint n_local = *ip++; n_local > 0; n_local--) {
uint local_num = *ip++;
py: mp_execute_byte_code has 2 arg arrays, for more efficient default params.
2014-02-01 13:29:40 -05:00
if (local_num < n_args + n_args2) {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
state[n_state - 1 - local_num] = mp_obj_new_cell(state[n_state - 1 - local_num]);
py: make closures work.
2013-12-30 17:32:17 -05:00
} else {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
state[n_state - 1 - local_num] = mp_obj_new_cell(MP_OBJ_NULL);
py: make closures work.
2013-12-30 17:32:17 -05:00
}
}
}
// execute the byte code
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
if (mp_execute_byte_code_2(code, &ip, &state[n_state - 1], &sp)) {
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
// it shouldn't yield
assert(0);
}
py: make closures work.
2013-12-30 17:32:17 -05:00
Implement: str.join, more float support, ROT_TWO in VM.
2013-11-02 10:33:10 -04:00
// TODO check fails if, eg, return from within for loop
//assert(sp == &state[17]);
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
return *sp;
}
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// fastn has items in reverse order (fastn[0] is local[0], fastn[-1] is local[1], etc)
// sp points to bottom of stack which grows up
Implement send() method for generators.
2014-01-26 13:50:11 -05:00
// returns true if bytecode yielded
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
bool mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out, mp_obj_t *fastn, mp_obj_t **sp_in_out) {
Crude try-except working.
2013-10-15 18:46:01 -04:00
// careful: be sure to declare volatile any variables read in the exception handler (written is ok, I think)
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
const byte *ip = *ip_in_out;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_obj_t *sp = *sp_in_out;
Initial commit.
2013-10-04 14:53:11 -04:00
machine_uint_t unum;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
qstr qst;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_obj_t obj1, obj2;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
nlr_buf_t nlr;
Initial commit.
2013-10-04 14:53:11 -04:00
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
volatile machine_uint_t currently_in_except_block = 0; // 0 or 1, to detect nested exceptions
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
mp_exc_stack exc_stack[4];
mp_exc_stack *volatile exc_sp = &exc_stack[0] - 1; // stack grows up, exc_sp points to top of stack
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
const byte *volatile save_ip = ip; // this is so we can access ip in the exception handler without making ip volatile (which means the compiler can't keep it in a register in the main loop)
Crude try-except working.
2013-10-15 18:46:01 -04:00
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// outer exception handling loop
Initial commit.
2013-10-04 14:53:11 -04:00
for (;;) {
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
if (nlr_push(&nlr) == 0) {
// loop to execute byte code
for (;;) {
Add exception stack unwind support for RETURN_VALUE. This properly implements return from try/finally block(s). TODO: Consider if we need to do any value stack unwinding for RETURN_VALUE case. Intuitively, this is "success" return, so value stack should be in good shape, and unwinding shouldn't be required.
2014-01-31 17:55:05 -05:00
dispatch_loop:
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
save_ip = ip;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
int op = *ip++;
switch (op) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_FALSE:
PUSH(mp_const_false);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_NONE:
PUSH(mp_const_none);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_TRUE:
PUSH(mp_const_true);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Add ellipsis object.
2014-01-04 13:44:46 -05:00
case MP_BC_LOAD_CONST_ELLIPSIS:
PUSH(mp_const_ellipsis);
break;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_SMALL_INT:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
unum = (ip[0] | (ip[1] << 8) | (ip[2] << 16)) - 0x800000;
Byte code for SMALL_INT uses 3 bytes for integer.
2013-11-04 18:04:50 -05:00
ip += 3;
Use constructor to create small int (avoid exposing mp_obj_t internals to VM).
2014-01-06 10:49:46 -05:00
PUSH(MP_OBJ_NEW_SMALL_INT(unum));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Implement LOAD_CONST_INT (by dispatching to int object implementation).
2014-01-17 12:51:46 -05:00
case MP_BC_LOAD_CONST_INT:
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(mp_obj_new_int_from_long_str(qstr_str(qst)));
Implement LOAD_CONST_INT (by dispatching to int object implementation).
2014-01-17 12:51:46 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_DEC:
Add basic complex number support.
2013-11-02 15:47:57 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(rt_load_const_dec(qst));
Add basic complex number support.
2013-11-02 15:47:57 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_ID:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(rt_load_const_str(qst)); // TODO
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Add quick impl for MP_BC_LOAD_CONST_BYTES which just creates qstr so far. This is based on the fact that qstr so far behaves more like byte string than like Unicode string (for example, "012"[0] returns 48 (int)).
2014-01-02 11:46:27 -05:00
case MP_BC_LOAD_CONST_BYTES:
DECODE_QSTR;
Add basic implementation of bytes type, piggybacking on str. This reuses as much str implementation as possible, from this we can make them more separate as needed.
2014-01-24 15:50:40 -05:00
PUSH(rt_load_const_bytes(qst));
Add quick impl for MP_BC_LOAD_CONST_BYTES which just creates qstr so far. This is based on the fact that qstr so far behaves more like byte string than like Unicode string (for example, "012"[0] returns 48 (int)).
2014-01-02 11:46:27 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_CONST_STRING:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(rt_load_const_str(qst));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_FAST_0:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
PUSH(fastn[0]);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_FAST_1:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
PUSH(fastn[-1]);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_FAST_2:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
PUSH(fastn[-2]);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_FAST_N:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
PUSH(fastn[-unum]);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_DEREF:
py: work towards working closures.
2013-12-10 19:41:43 -05:00
DECODE_UINT;
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
PUSH(rt_get_cell(fastn[-unum]));
py: work towards working closures.
2013-12-10 19:41:43 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_NAME:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(rt_load_name(qst));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_GLOBAL:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
PUSH(rt_load_global(qst));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_ATTR:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
SET_TOP(rt_load_attr(TOP(), qst));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_METHOD:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
rt_load_method(*sp, qst, sp);
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp += 1;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LOAD_BUILD_CLASS:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
PUSH(rt_load_build_class());
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_FAST_0:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
fastn[0] = POP();
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_FAST_1:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
fastn[-1] = POP();
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_FAST_2:
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
fastn[-2] = POP();
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_FAST_N:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
fastn[-unum] = POP();
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_DEREF:
py: work towards working closures.
2013-12-10 19:41:43 -05:00
DECODE_UINT;
py: Simplify fastn in VM; reduce size of unique code struct. We still have FAST_[0,1,2] byte codes, but they now just access the fastn array (before they had special local variables). It's now simpler, a bit faster, and uses a bit less stack space (on STM at least, which is most important). The only reason now to keep FAST_[0,1,2] byte codes is for compressed byte code size.
2014-01-29 15:30:52 -05:00
rt_set_cell(fastn[-unum], POP());
py: work towards working closures.
2013-12-10 19:41:43 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_NAME:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
rt_store_name(qst, POP());
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_GLOBAL:
Byte code for SMALL_INT uses 3 bytes for integer.
2013-11-04 18:04:50 -05:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
rt_store_global(qst, POP());
Byte code for SMALL_INT uses 3 bytes for integer.
2013-11-04 18:04:50 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_ATTR:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
rt_store_attr(sp[0], qst, sp[-1]);
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= 2;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_SUBSCR:
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
rt_store_subscr(sp[-1], sp[0], sp[-2]);
sp -= 3;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_DUP_TOP:
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
obj1 = TOP();
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
PUSH(obj1);
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_DUP_TOP_TWO:
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp += 2;
sp[0] = sp[-2];
sp[-1] = sp[-3];
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_POP_TOP:
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= 1;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_ROT_TWO:
Implement: str.join, more float support, ROT_TWO in VM.
2013-11-02 10:33:10 -04:00
obj1 = sp[0];
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp[0] = sp[-1];
sp[-1] = obj1;
Implement: str.join, more float support, ROT_TWO in VM.
2013-11-02 10:33:10 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_ROT_THREE:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
obj1 = sp[0];
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp[0] = sp[-1];
sp[-1] = sp[-2];
sp[-2] = obj1;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_JUMP:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
DECODE_SLABEL;
ip += unum;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_POP_JUMP_IF_TRUE:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
DECODE_SLABEL;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
if (rt_is_true(POP())) {
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
ip += unum;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
}
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_POP_JUMP_IF_FALSE:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
DECODE_SLABEL;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
if (!rt_is_true(POP())) {
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
ip += unum;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
}
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_JUMP_IF_TRUE_OR_POP:
Add JUMP_IF_x_OR_POP opcodes to VM.
2013-11-09 15:12:32 -05:00
DECODE_SLABEL;
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
if (rt_is_true(TOP())) {
Add JUMP_IF_x_OR_POP opcodes to VM.
2013-11-09 15:12:32 -05:00
ip += unum;
} else {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp--;
Add JUMP_IF_x_OR_POP opcodes to VM.
2013-11-09 15:12:32 -05:00
}
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_JUMP_IF_FALSE_OR_POP:
Add JUMP_IF_x_OR_POP opcodes to VM.
2013-11-09 15:12:32 -05:00
DECODE_SLABEL;
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
if (rt_is_true(TOP())) {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp--;
Add JUMP_IF_x_OR_POP opcodes to VM.
2013-11-09 15:12:32 -05:00
} else {
ip += unum;
}
break;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
/* we are trying to get away without using this opcode
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_SETUP_LOOP:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
// push_block(MP_BC_SETUP_LOOP, ip + unum, sp)
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
*/
py: Implement break and continue byte codes, and add tests. Also fixes a bug in the for-in-range optimiser. I hope to remove break and continue byte codes in the future and just use jump (if possible).
2014-01-21 18:48:04 -05:00
// TODO this might need more sophisticated handling when breaking from within an except
case MP_BC_BREAK_LOOP:
DECODE_ULABEL;
ip += unum;
break;
// TODO this might need more sophisticated handling when breaking from within an except
case MP_BC_CONTINUE_LOOP:
DECODE_ULABEL;
ip += unum;
break;
py: implement POP_BLOCK in VM.
2013-12-29 13:48:37 -05:00
// matched against: POP_BLOCK or POP_EXCEPT (anything else?)
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_SETUP_EXCEPT:
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
case MP_BC_SETUP_FINALLY:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
DECODE_ULABEL; // except labels are always forward
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
++exc_sp;
exc_sp->opcode = op;
exc_sp->handler = ip + unum;
exc_sp->val_sp = (((machine_uint_t)sp) | currently_in_except_block);
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
currently_in_except_block = 0; // in a try block now
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_END_FINALLY:
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
// not fully implemented
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// if TOS is an exception, reraises the exception (3 values on TOS)
// if TOS is None, just pops it and continues
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
// if TOS is an integer, does something else
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// else error
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
if (MP_OBJ_IS_TYPE(TOP(), &exception_type)) {
nlr_jump(TOP());
}
if (TOP() == mp_const_none) {
sp--;
Add exception stack unwind support for RETURN_VALUE. This properly implements return from try/finally block(s). TODO: Consider if we need to do any value stack unwinding for RETURN_VALUE case. Intuitively, this is "success" return, so value stack should be in good shape, and unwinding shouldn't be required.
2014-01-31 17:55:05 -05:00
} else if (MP_OBJ_IS_SMALL_INT(TOP())) {
// We finished "finally" coroutine and now dispatch back
// to our caller, based on TOS value
mp_unwind_reason_t reason = MP_OBJ_SMALL_INT_VALUE(POP());
switch (reason) {
case UNWIND_RETURN:
goto unwind_return;
// TODO
case UNWIND_BREAK:
case UNWIND_CONTINUE:
;
}
assert(0);
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
} else {
assert(0);
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_GET_ITER:
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
SET_TOP(rt_getiter(TOP()));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_FOR_ITER:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
obj1 = rt_iternext(TOP());
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (obj1 == mp_const_stop_iteration) {
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
--sp; // pop the exhausted iterator
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
ip += unum; // jump to after for-block
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
} else {
PUSH(obj1); // push the next iteration value
}
break;
py: implement POP_BLOCK in VM.
2013-12-29 13:48:37 -05:00
// matched against: SETUP_EXCEPT, SETUP_FINALLY, SETUP_WITH
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_POP_BLOCK:
py: implement POP_BLOCK in VM.
2013-12-29 13:48:37 -05:00
// we are exiting an exception handler, so pop the last one of the exception-stack
assert(exc_sp >= &exc_stack[0]);
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
currently_in_except_block = (exc_sp->val_sp & 1); // restore previous state
exc_sp--; // pop back to previous exception handler
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
py: Implement break and continue byte codes, and add tests. Also fixes a bug in the for-in-range optimiser. I hope to remove break and continue byte codes in the future and just use jump (if possible).
2014-01-21 18:48:04 -05:00
// matched against: SETUP_EXCEPT
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_POP_EXCEPT:
Crude try-except working.
2013-10-15 18:46:01 -04:00
// TODO need to work out how blocks work etc
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// pops block, checks it's an exception block, and restores the stack, saving the 3 exception values to local threadstate
Crude try-except working.
2013-10-15 18:46:01 -04:00
assert(exc_sp >= &exc_stack[0]);
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
assert(currently_in_except_block);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
//sp = (mp_obj_t*)(*exc_sp--);
Crude try-except working.
2013-10-15 18:46:01 -04:00
//exc_sp--; // discard ip
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
currently_in_except_block = (exc_sp->val_sp & 1); // restore previous state
exc_sp--; // pop back to previous exception handler
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
//sp -= 3; // pop 3 exception values
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_UNARY_OP:
Add basic complex number support.
2013-11-02 15:47:57 -04:00
unum = *ip++;
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
SET_TOP(rt_unary_op(unum, TOP()));
Add basic complex number support.
2013-11-02 15:47:57 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_BINARY_OP:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
unum = *ip++;
obj2 = POP();
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
obj1 = TOP();
SET_TOP(rt_binary_op(unum, obj1, obj2));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_BUILD_TUPLE:
Support tuples and list comprehension, albeit crude.
2013-10-16 11:12:52 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= unum - 1;
SET_TOP(rt_build_tuple(unum, sp));
Support tuples and list comprehension, albeit crude.
2013-10-16 11:12:52 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_BUILD_LIST:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= unum - 1;
SET_TOP(rt_build_list(unum, sp));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_LIST_APPEND:
Support tuples and list comprehension, albeit crude.
2013-10-16 11:12:52 -04:00
DECODE_UINT;
// I think it's guaranteed by the compiler that sp[unum] is a list
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
rt_list_append(sp[-unum], sp[0]);
sp--;
Support tuples and list comprehension, albeit crude.
2013-10-16 11:12:52 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_BUILD_MAP:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
PUSH(rt_build_map(unum));
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_STORE_MAP:
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= 2;
rt_store_map(sp[0], sp[2], sp[1]);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_MAP_ADD:
Add MAP_ADD opcode to VM.
2013-10-16 15:54:01 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// I think it's guaranteed by the compiler that sp[-unum - 1] is a map
rt_store_map(sp[-unum - 1], sp[0], sp[-1]);
sp -= 2;
Add MAP_ADD opcode to VM.
2013-10-16 15:54:01 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_BUILD_SET:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp -= unum - 1;
SET_TOP(rt_build_set(unum, sp));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_SET_ADD:
Add SET_ADD opcode to VM.
2013-10-16 15:57:49 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// I think it's guaranteed by the compiler that sp[-unum] is a set
rt_store_set(sp[-unum], sp[0]);
sp--;
Add SET_ADD opcode to VM.
2013-10-16 15:57:49 -04:00
break;
slice: Allow building with MICROPY_ENABLE_SLICE=0.
2014-01-03 18:34:23 -05:00
#if MICROPY_ENABLE_SLICE
Implement BUILD_SLICE opcode (2-arg version).
2014-01-02 19:48:56 -05:00
case MP_BC_BUILD_SLICE:
DECODE_UINT;
if (unum == 2) {
obj2 = POP();
obj1 = TOP();
SET_TOP(mp_obj_new_slice(obj1, obj2, NULL));
} else {
printf("3-argument slice is not supported\n");
assert(0);
}
break;
slice: Allow building with MICROPY_ENABLE_SLICE=0.
2014-01-03 18:34:23 -05:00
#endif
Implement BUILD_SLICE opcode (2-arg version).
2014-01-02 19:48:56 -05:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_UNPACK_SEQUENCE:
py: add UNPACK_SEQUENCE and keyword methods to VM.
2013-11-26 10:15:50 -05:00
DECODE_UINT;
py: Fix VM/runtime unpack sequence bug, Issue #193.
2014-01-18 18:42:49 -05:00
rt_unpack_sequence(sp[0], unum, sp);
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
sp += unum - 1;
py: add UNPACK_SEQUENCE and keyword methods to VM.
2013-11-26 10:15:50 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_MAKE_FUNCTION:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Implement default function arguments (for Python functions). TODO: Decide if we really need separate bytecode for creating functions with default arguments - we would need same for closures, then there're keywords arguments too. Having all combinations is a small exponential explosion, likely we need just 2 cases - simplest (no defaults, no kw), and full - defaults & kw.
2014-02-01 08:05:04 -05:00
PUSH(rt_make_function_from_id(unum, MP_OBJ_NULL));
break;
case MP_BC_MAKE_FUNCTION_DEFARGS:
DECODE_UINT;
SET_TOP(rt_make_function_from_id(unum, TOP()));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_MAKE_CLOSURE:
py: work towards working closures.
2013-12-10 19:41:43 -05:00
DECODE_UINT;
py: Fix bug with LOAD_METHOD; fix int->machine_int_t for small int. LOAD_METHOD bug was: emitbc did not correctly calculate the amount of stack usage for a LOAD_METHOD operation. small int bug was: int was being used to pass small ints, when it should have been machine_int_t.
2014-01-29 13:58:52 -05:00
SET_TOP(rt_make_closure_from_id(unum, TOP()));
py: work towards working closures.
2013-12-10 19:41:43 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_CALL_FUNCTION:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe);
SET_TOP(rt_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_CALL_METHOD:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
DECODE_UINT;
Make VM stack grow upwards, and so no reversed args arrays. Change state layout in VM so the stack starts at state[0] and grows upwards. Locals are at the top end of the state and number downwards. This cleans up a lot of the interface connecting the VM to C: now all functions that take an array of Micro Python objects are in order (ie no longer in reverse). Also clean up C API with keyword arguments (call_n and call_n_kw replaced with single call method that takes keyword arguments). And now make_new takes keyword arguments. emitnative.c has not yet been changed to comply with the new order of stack layout.
2014-01-18 09:10:48 -05:00
// unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
SET_TOP(rt_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_RETURN_VALUE:
Add exception stack unwind support for RETURN_VALUE. This properly implements return from try/finally block(s). TODO: Consider if we need to do any value stack unwinding for RETURN_VALUE case. Intuitively, this is "success" return, so value stack should be in good shape, and unwinding shouldn't be required.
2014-01-31 17:55:05 -05:00
unwind_return:
while (exc_sp >= exc_stack) {
if (exc_sp->opcode == MP_BC_SETUP_FINALLY) {
// We're going to run "finally" code as a coroutine
// (not calling it recursively). Set up a sentinel
// on a stack so it can return back to us when it is
// done (when END_FINALLY reached).
PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_RETURN));
ip = exc_sp->handler;
// We don't need to do anything with sp, finally is just
// syntactic sugar for sequential execution??
// sp =
exc_sp--;
goto dispatch_loop;
}
exc_sp--;
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
nlr_pop();
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
*sp_in_out = sp;
py: change negative array indices with array - 1.
2014-01-02 13:20:41 -05:00
assert(exc_sp == &exc_stack[0] - 1);
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
return false;
Crude attempt to implement RAISE_VARARGS (with args=1 so far only).
2014-01-10 09:09:55 -05:00
case MP_BC_RAISE_VARARGS:
unum = *ip++;
assert(unum == 1);
obj1 = POP();
nlr_jump(obj1);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_YIELD_VALUE:
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
nlr_pop();
*ip_in_out = ip;
*sp_in_out = sp;
return true;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_IMPORT_NAME:
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
DECODE_QSTR;
obj1 = POP();
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
SET_TOP(rt_import_name(qst, obj1, TOP()));
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
break;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
case MP_BC_IMPORT_FROM:
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
DECODE_QSTR;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
obj1 = rt_import_from(TOP(), qst);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
PUSH(obj1);
break;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
default:
Make byte code jumps relative.
2013-11-05 17:06:08 -05:00
printf("code %p, byte code 0x%02x not implemented\n", ip, op);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
assert(0);
nlr_pop();
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
return false;
Initial commit.
2013-10-04 14:53:11 -04:00
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
}
} else {
// exception occurred
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
// set file and line number that the exception occurred at
vm: Add basic implementation of END_FINALLY opcode. Allows to have nested try blocks with except filters. TODO: Don't add END_FINALLY's exception re-raise points to traceback.
2014-01-30 06:49:18 -05:00
// TODO: don't set traceback for exceptions re-raised by END_FINALLY.
// But consider how to handle nested exceptions.
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
if (MP_OBJ_IS_TYPE(nlr.ret_val, &exception_type)) {
machine_uint_t code_info_size = code_info[0] | (code_info[1] << 8) | (code_info[2] << 16) | (code_info[3] << 24);
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
qstr source_file = code_info[4] | (code_info[5] << 8) | (code_info[6] << 16) | (code_info[7] << 24);
qstr block_name = code_info[8] | (code_info[9] << 8) | (code_info[10] << 16) | (code_info[11] << 24);
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
machine_uint_t source_line = 1;
machine_uint_t bc = save_ip - code_info - code_info_size;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
//printf("find %lu %d %d\n", bc, code_info[12], code_info[13]);
py: Optimise generated code for working out line numbers.
2014-01-25 06:43:20 -05:00
for (const byte* ci = code_info + 12; *ci && bc >= ((*ci) & 31); ci++) {
bc -= *ci & 31;
source_line += *ci >> 5;
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
}
py: Add full traceback to exception printing.
2014-01-19 07:38:49 -05:00
mp_obj_exception_add_traceback(nlr.ret_val, source_file, source_line, block_name);
Add source file name and line number to error messages. Byte code has a map from byte-code offset to source-code line number, used to give better error messages.
2014-01-18 18:24:36 -05:00
}
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
while (currently_in_except_block) {
// nested exception
assert(exc_sp >= &exc_stack[0]);
// TODO make a proper message for nested exception
// at the moment we are just raising the very last exception (the one that caused the nested exception)
// move up to previous exception handler
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
currently_in_except_block = (exc_sp->val_sp & 1); // restore previous state
exc_sp--; // pop back to previous exception handler
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
}
Crude try-except working.
2013-10-15 18:46:01 -04:00
if (exc_sp >= &exc_stack[0]) {
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
// set flag to indicate that we are now handling an exception
currently_in_except_block = 1;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// catch exception and pass to byte code
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
sp = (mp_obj_t*)(exc_sp->val_sp & (~((machine_uint_t)1)));
ip = exc_sp->handler;
Crude try-except working.
2013-10-15 18:46:01 -04:00
// push(traceback, exc-val, exc-type)
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
PUSH(mp_const_none);
Crude try-except working.
2013-10-15 18:46:01 -04:00
PUSH(nlr.ret_val);
py: implement some basic exception matching.
2013-12-29 12:17:43 -05:00
PUSH(nlr.ret_val); // TODO should be type(nlr.ret_val), I think...
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
} else {
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
// re-raise exception to higher level
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
// TODO what to do if this is a generator??
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
nlr_jump(nlr.ret_val);
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}