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

859 lines
35 KiB
C
Raw Normal View History

Initial commit.
2013-10-04 14:53:11 -04:00
#include <stdio.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"
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
#include "objgenerator.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.
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)
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
// TODO perhaps compress this to RETURN=0, JUMP>0, with number of unwinds
// left to do encoded in the JUMP number
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
typedef enum {
UNWIND_RETURN = 1,
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
UNWIND_JUMP,
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
} mp_unwind_reason_t;
Bytecode uint varlen encoding: support arbitrary values.
2014-02-18 14:21:22 -05:00
#define DECODE_UINT { \
unum = 0; \
do { \
unum = (unum << 7) + (*ip & 0x7f); \
} while ((*ip++ & 0x80) != 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)
Bytecode uint varlen encoding: support arbitrary values.
2014-02-18 14:21:22 -05:00
#define DECODE_QSTR { \
qst = 0; \
do { \
qst = (qst << 7) + (*ip & 0x7f); \
} while ((*ip++ & 0x80) != 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
vm: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
#define PUSH_EXC_BLOCK() \
vm: Factor out exception block setup to a macro. Will be reused in WITH bytecodes.
2014-03-28 20:49:07 -04:00
DECODE_ULABEL; /* except labels are always forward */ \
++exc_sp; \
exc_sp->opcode = op; \
exc_sp->handler = ip + unum; \
exc_sp->val_sp = MP_TAGPTR_MAKE(sp, currently_in_except_block); \
currently_in_except_block = 0; /* in a try block now */
vm: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
#define POP_EXC_BLOCK() \
currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); /* restore previous state */ \
exc_sp--; /* pop back to previous exception handler */
py: Put n_state for bytecode in the bytecode prelude. Rationale: setting up the stack (state for locals and exceptions) is really part of the "code", it's the prelude of the function. For example, native code adjusts the stack pointer on entry to the function. Native code doesn't need to know n_state for any other reason. So putting the state size in the bytecode prelude is sensible. It reduced ROM usage on STM by about 30 bytes :) And makes it easier to pass information about the bytecode between functions.
2014-03-27 07:07:04 -04:00
mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret) {
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
const byte *ip = code;
// get code info size, and skip line number table
machine_uint_t code_info_size = ip[0] | (ip[1] << 8) | (ip[2] << 16) | (ip[3] << 24);
ip += code_info_size;
py: Put n_state for bytecode in the bytecode prelude. Rationale: setting up the stack (state for locals and exceptions) is really part of the "code", it's the prelude of the function. For example, native code adjusts the stack pointer on entry to the function. Native code doesn't need to know n_state for any other reason. So putting the state size in the bytecode prelude is sensible. It reduced ROM usage on STM by about 30 bytes :) And makes it easier to pass information about the bytecode between functions.
2014-03-27 07:07:04 -04:00
// bytecode prelude: state size and exception stack size; 16 bit uints
machine_uint_t n_state = ip[0] | (ip[1] << 8);
machine_uint_t n_exc_stack = ip[2] | (ip[3] << 8);
ip += 4;
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04: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
// 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;
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
// allocate state for exceptions
mp_exc_stack exc_state[4];
mp_exc_stack *exc_stack = &exc_state[0];
if (n_exc_stack > 4) {
exc_stack = m_new(mp_exc_stack, n_exc_stack);
}
mp_exc_stack *exc_sp = &exc_stack[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
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
// bytecode prelude: initialise closed over variables
for (uint n_local = *ip++; n_local > 0; n_local--) {
uint local_num = *ip++;
if (local_num < n_args + n_args2) {
state[n_state - 1 - local_num] = mp_obj_new_cell(state[n_state - 1 - local_num]);
} else {
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
objgenerator: Implement .throw() method to throw exceptions into generator.
2014-03-22 11:50:12 -04:00
mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code_2(code, &ip, &state[n_state - 1], &sp, exc_stack, &exc_sp, MP_OBJ_NULL);
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
switch (vm_return_kind) {
case MP_VM_RETURN_NORMAL:
*ret = *sp;
return MP_VM_RETURN_NORMAL;
case MP_VM_RETURN_EXCEPTION:
*ret = state[n_state - 1];
return MP_VM_RETURN_EXCEPTION;
case MP_VM_RETURN_YIELD: // byte-code shouldn't yield
default:
assert(0);
*ret = mp_const_none;
return MP_VM_RETURN_NORMAL;
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04: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
// 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
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
// returns:
// MP_VM_RETURN_NORMAL, sp valid, return value in *sp
// MP_VM_RETURN_YIELD, ip, sp valid, yielded value in *sp
// MP_VM_RETURN_EXCEPTION, exception in fastn[0]
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
mp_vm_return_kind_t mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out,
mp_obj_t *fastn, mp_obj_t **sp_in_out,
objgenerator: Implement .throw() method to throw exceptions into generator.
2014-03-22 11:50:12 -04:00
mp_exc_stack *exc_stack, mp_exc_stack **exc_sp_in_out,
volatile mp_obj_t inject_exc) {
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
vm: Abstract working with tagged pointers in VM using macro accessors. Based on issues raised during recent review and inconsistency of different implementations.
2014-03-22 17:20:07 -04:00
volatile bool currently_in_except_block = MP_TAGPTR_TAG(*exc_sp_in_out); // 0 or 1, to detect nested exceptions
mp_exc_stack *volatile exc_sp = MP_TAGPTR_PTR(*exc_sp_in_out); // 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 (;;) {
py: Add support for user-defined iterators via __iter__, __next__.
2014-03-26 14:37:06 -04:00
outer_dispatch_loop:
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
if (nlr_push(&nlr) == 0) {
objgenerator: Implement .throw() method to throw exceptions into generator.
2014-03-22 11:50:12 -04:00
// If we have exception to inject, now that we finish setting up
// execution context, raise it. This works as if RAISE_VARARGS
// bytecode was executed.
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
// Injecting exc into yield from generator is a special case,
// handled by MP_BC_YIELD_FROM itself
if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) {
objgenerator: Implement .throw() method to throw exceptions into generator.
2014-03-22 11:50:12 -04:00
mp_obj_t t = inject_exc;
inject_exc = MP_OBJ_NULL;
nlr_jump(rt_make_raise_obj(t));
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// 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:
py: Change mp_const_* objects to macros. Addresses issue #388.
2014-03-29 09:15:08 -04:00
PUSH((mp_obj_t)&mp_const_ellipsis_obj);
Add ellipsis object.
2014-01-04 13:44:46 -05:00
break;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
Bytecode int varlen encoding: support arbitrary values for signed ints too.
2014-02-19 08:47:59 -05:00
case MP_BC_LOAD_CONST_SMALL_INT: {
py: Fix type of integer in decoding int.
2014-02-19 19:00:04 -05:00
machine_int_t num = 0;
Bytecode int varlen encoding: support arbitrary values for signed ints too.
2014-02-19 08:47:59 -05:00
if ((ip[0] & 0x40) != 0) {
// Number is negative
num--;
}
do {
num = (num << 7) | (*ip & 0x7f);
} while ((*ip++ & 0x80) != 0);
PUSH(MP_OBJ_NEW_SMALL_INT(num));
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
break;
Bytecode int varlen encoding: support arbitrary values for signed ints too.
2014-02-19 08:47:59 -05:00
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
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;
py: Implement support for "except Exception as var" clause. For this, needed to implement DELETE_NAME bytecode (because var bound in except clause is automatically deleted at its end). http://docs.python.org/3/reference/compound_stmts.html#except : "When an exception has been assigned using as target, it is cleared at the end of the except clause."
2014-03-23 15:19:02 -04:00
case MP_BC_DELETE_NAME:
DECODE_QSTR;
rt_delete_name(qst);
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: Make MP_BC_SETUP_WITH use the bytecode stack for load_method. The compiler allocates 7 entries on the stack for a with statement (following CPython, but probably can be reduced). This is enough for the method load and call in SETUP_WITH.
2014-03-29 10:06:14 -04:00
case MP_BC_SETUP_WITH:
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
obj1 = TOP();
SET_TOP(rt_load_attr(obj1, MP_QSTR___exit__));
py: Make MP_BC_SETUP_WITH use the bytecode stack for load_method. The compiler allocates 7 entries on the stack for a with statement (following CPython, but probably can be reduced). This is enough for the method load and call in SETUP_WITH.
2014-03-29 10:06:14 -04:00
rt_load_method(obj1, MP_QSTR___enter__, sp + 1);
obj2 = rt_call_method_n_kw(0, 0, sp + 1);
vm: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
PUSH_EXC_BLOCK();
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
PUSH(obj2);
break;
case MP_BC_WITH_CLEANUP: {
vm: Elaborate comments for WITH_CLEANUP, other cosmetic fixes.
2014-03-29 10:49:33 -04:00
// Arriving here, there's "exception control block" on top of stack,
// and __exit__ bound method underneath it. Bytecode calls __exit__,
// and "deletes" it off stack, shifting "exception control block"
// to its place.
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
static const mp_obj_t no_exc[] = {mp_const_none, mp_const_none, mp_const_none};
if (TOP() == mp_const_none) {
sp--;
obj1 = TOP();
SET_TOP(mp_const_none);
obj2 = rt_call_function_n_kw(obj1, 3, 0, no_exc);
} else if (MP_OBJ_IS_SMALL_INT(TOP())) {
mp_obj_t cause = POP();
switch (MP_OBJ_SMALL_INT_VALUE(cause)) {
case UNWIND_RETURN: {
mp_obj_t retval = POP();
obj2 = rt_call_function_n_kw(TOP(), 3, 0, no_exc);
SET_TOP(retval);
PUSH(cause);
break;
}
case UNWIND_JUMP: {
obj2 = rt_call_function_n_kw(sp[-2], 3, 0, no_exc);
// Pop __exit__ boundmethod at sp[-2]
sp[-2] = sp[-1];
sp[-1] = sp[0];
SET_TOP(cause);
break;
}
default:
assert(0);
}
} else if (mp_obj_is_exception_type(TOP())) {
mp_obj_t args[3] = {sp[0], sp[-1], sp[-2]};
obj2 = rt_call_function_n_kw(sp[-3], 3, 0, args);
// Pop __exit__ boundmethod at sp[-3]
// TODO: Once semantics is proven, optimize for case when obj2 == True
sp[-3] = sp[-2];
sp[-2] = sp[-1];
sp[-1] = sp[0];
sp--;
if (rt_is_true(obj2)) {
// This is what CPython does
//PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_SILENCED));
// But what we need to do is - pop exception from value stack...
sp -= 3;
vm: Elaborate comments for WITH_CLEANUP, other cosmetic fixes.
2014-03-29 10:49:33 -04:00
// ... pop "with" exception handler, and signal END_FINALLY
// to just execute finally handler normally (by pushing None
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
// on value stack)
assert(exc_sp >= exc_stack);
assert(exc_sp->opcode == MP_BC_SETUP_WITH);
exc_sp--;
PUSH(mp_const_none);
}
} else {
assert(0);
}
break;
}
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
case MP_BC_UNWIND_JUMP:
DECODE_SLABEL;
PUSH((void*)(ip + unum)); // push destination ip for jump
PUSH((void*)(machine_uint_t)(*ip)); // push number of exception handlers to unwind
unwind_jump:
unum = (machine_uint_t)POP(); // get number of exception handlers to unwind
while (unum > 0) {
unum -= 1;
assert(exc_sp >= exc_stack);
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
// 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((void*)unum); // push number of exception handlers left to unwind
PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_JUMP)); // push sentinel
ip = exc_sp->handler; // get exception handler byte code address
exc_sp--; // pop exception handler
goto dispatch_loop; // run the exception handler
}
exc_sp--;
}
ip = (const byte*)POP(); // pop destination ip for jump
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
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:
vm: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
PUSH_EXC_BLOCK();
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: Make sure that exception triple is <type, instance, traceback>. This reduntant triple is one of the ugliest parts of Python, which they chickened out to fix in Python3. We really should consider passing just as single exception instance (without breaking Python-level APIs of course), but until we do, let's follow CPython layout.
2014-03-28 20:52:17 -04:00
if (mp_obj_is_exception_type(TOP())) {
nlr_jump(sp[-1]);
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 (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;
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
case UNWIND_JUMP:
goto unwind_jump;
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
}
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: Replace mp_const_stop_iteration object with MP_OBJ_NULL.
2014-03-26 15:27:58 -04:00
obj1 = rt_iternext_allow_raise(TOP());
if (obj1 == MP_OBJ_NULL) {
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
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
assert(exc_sp >= exc_stack);
vm: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
POP_EXC_BLOCK();
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
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
assert(exc_sp >= exc_stack);
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: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
POP_EXC_BLOCK();
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;
py: Tidy up BINARY_OPs; negation done by special NOT bytecode. IS_NOT and NOT_IN are now compiled to IS + NOT and IN + NOT, with a new special NOT bytecode.
2014-02-01 18:04:09 -05:00
case MP_BC_NOT:
if (TOP() == mp_const_true) {
SET_TOP(mp_const_false);
} else {
SET_TOP(mp_const_true);
}
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;
py: Free unique_code slot for outer module. Partly (very partly!) addresses issue #386. Most importantly, at the REPL command line, each invocation does not now lead to increased memory usage (unless you define a function/lambda).
2014-03-29 07:39:36 -04:00
PUSH(rt_make_function_from_id(unum, false, MP_OBJ_NULL));
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
break;
case MP_BC_MAKE_FUNCTION_DEFARGS:
DECODE_UINT;
py: Free unique_code slot for outer module. Partly (very partly!) addresses issue #386. Most importantly, at the REPL command line, each invocation does not now lead to increased memory usage (unless you define a function/lambda).
2014-03-29 07:39:36 -04:00
SET_TOP(rt_make_function_from_id(unum, false, 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: Support closures with default args.
2014-03-26 17:14:59 -04:00
SET_TOP(rt_make_closure_from_id(unum, TOP(), MP_OBJ_NULL));
break;
case MP_BC_MAKE_CLOSURE_DEFARGS:
DECODE_UINT;
obj1 = POP();
SET_TOP(rt_make_closure_from_id(unum, obj1, 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) {
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
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
// 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;
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
assert(exc_sp == exc_stack - 1);
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
return MP_VM_RETURN_NORMAL;
Implement BC & runtime support for generator/yielding.
2013-10-16 15:39:12 -04:00
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++;
vm: Implement raise statement w/o args (reraising last exception).
2014-03-26 08:42:17 -04:00
assert(unum <= 1);
if (unum == 0) {
py: Reraising exception possible only in except block.
2014-03-29 13:44:15 -04:00
if (!currently_in_except_block) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_RuntimeError, "No active exception to reraise"));
}
vm: Implement raise statement w/o args (reraising last exception).
2014-03-26 08:42:17 -04:00
// This assumes that nlr.ret_val holds last raised
// exception and is not overwritten since then.
obj1 = nlr.ret_val;
} else {
obj1 = POP();
}
Implement proper exception type hierarchy. Each built-in exception is now a type, with base type BaseException. C exceptions are created by passing a pointer to the exception type to make an instance of. When raising an exception from the VM, an instance is created automatically if an exception type is raised (as opposed to an exception instance). Exception matching (RT_BINARY_OP_EXCEPTION_MATCH) is now proper. Handling of parse error changed to match new exceptions. mp_const_type renamed to mp_type_type for consistency.
2014-02-15 11:10:44 -05:00
nlr_jump(rt_make_raise_obj(obj1));
Crude attempt to implement RAISE_VARARGS (with args=1 so far only).
2014-01-10 09:09:55 -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_YIELD_VALUE:
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
yield:
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;
vm: Abstract working with tagged pointers in VM using macro accessors. Based on issues raised during recent review and inconsistency of different implementations.
2014-03-22 17:20:07 -04:00
*exc_sp_in_out = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block);
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
return MP_VM_RETURN_YIELD;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
vm: Elaborate comments for WITH_CLEANUP, other cosmetic fixes.
2014-03-29 10:49:33 -04:00
case MP_BC_YIELD_FROM: {
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
//#define EXC_MATCH(exc, type) MP_OBJ_IS_TYPE(exc, type)
#define EXC_MATCH(exc, type) mp_obj_exception_match(exc, type)
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
#define GENERATOR_EXIT_IF_NEEDED(t) if (t != MP_OBJ_NULL && EXC_MATCH(t, &mp_type_GeneratorExit)) { nlr_jump(t); }
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
mp_vm_return_kind_t ret_kind;
obj1 = POP();
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
mp_obj_t t_exc = MP_OBJ_NULL;
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
if (inject_exc != MP_OBJ_NULL) {
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
t_exc = inject_exc;
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
inject_exc = MP_OBJ_NULL;
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
ret_kind = mp_obj_gen_resume(TOP(), mp_const_none, t_exc, &obj2);
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
} else {
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
ret_kind = mp_obj_gen_resume(TOP(), obj1, MP_OBJ_NULL, &obj2);
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
}
if (ret_kind == MP_VM_RETURN_YIELD) {
ip--;
PUSH(obj2);
goto yield;
}
if (ret_kind == MP_VM_RETURN_NORMAL) {
// Pop exhausted gen
sp--;
if (obj2 == MP_OBJ_NULL) {
// Optimize StopIteration
// TODO: get StopIteration's value
PUSH(mp_const_none);
} else {
PUSH(obj2);
}
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
// If we injected GeneratorExit downstream, then even
// if it was swallowed, we re-raise GeneratorExit
GENERATOR_EXIT_IF_NEEDED(t_exc);
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
break;
}
if (ret_kind == MP_VM_RETURN_EXCEPTION) {
// Pop exhausted gen
sp--;
if (EXC_MATCH(obj2, &mp_type_StopIteration)) {
py: yield from: Elaborate GeneratorExit (gen.close()) handling. Handling of GeneratorExit is really peculiar - it subverts normal exception propagation rules.
2014-03-26 13:24:03 -04:00
PUSH(mp_obj_exception_get_value(obj2));
// If we injected GeneratorExit downstream, then even
// if it was swallowed, we re-raise GeneratorExit
GENERATOR_EXIT_IF_NEEDED(t_exc);
py: Core "yield from" implementation.
2014-03-26 11:36:12 -04:00
break;
} else {
nlr_jump(obj2);
}
}
}
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 "from module import *" construct.
2014-02-13 17:22:06 -05:00
case MP_BC_IMPORT_STAR:
py: Fix IMPORT_STAR, needs to pop the stack.
2014-02-14 18:06:33 -05:00
rt_import_all(POP());
Implement "from module import *" construct.
2014-02-13 17:22:06 -05:00
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();
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
return MP_VM_RETURN_NORMAL;
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
py: Add support for user-defined iterators via __iter__, __next__.
2014-03-26 14:37:06 -04:00
// check if it's a StopIteration within a for block
if (*save_ip == MP_BC_FOR_ITER && mp_obj_is_subclass_fast(mp_obj_get_type(nlr.ret_val), &mp_type_StopIteration)) {
ip = save_ip + 1;
DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
--sp; // pop the exhausted iterator
ip += unum; // jump to after for-block
goto outer_dispatch_loop; // continue with 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
// 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.
py: Fix regress with GeneratorExit object becoming truly const.
2014-03-29 09:52:51 -04:00
// TODO need a better way of not adding traceback to constant objects (right now, just GeneratorExit_obj)
if (mp_obj_is_exception_instance(nlr.ret_val) && nlr.ret_val != &mp_const_GeneratorExit_obj) {
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 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
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
assert(exc_sp >= exc_stack);
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
// 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: Establish macros PUSH_EXC_BLOCK & POP_EXC_BLOCK to deal with exc stack. E.g. to handle currently_in_except_block restoring properly.
2014-03-29 17:16:27 -04:00
POP_EXC_BLOCK();
Add code in VM to handle nested exceptions correctly.
2013-12-29 11:54:59 -05:00
}
objgenerator: Keep exception stack within generator object, like value stack. This is required to properly handle exceptions across yields.
2014-03-22 07:49:31 -04:00
if (exc_sp >= exc_stack) {
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: Abstract working with tagged pointers in VM using macro accessors. Based on issues raised during recent review and inconsistency of different implementations.
2014-03-22 17:20:07 -04:00
sp = MP_TAGPTR_PTR(exc_sp->val_sp);
vm: Introduce structure for exception stack entry, record entry type. Also, handle SETUP_FINALLY opcode.
2014-01-31 12:40:09 -05:00
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);
vm: Make sure that exception triple is <type, instance, traceback>. This reduntant triple is one of the ugliest parts of Python, which they chickened out to fix in Python3. We really should consider passing just as single exception instance (without breaking Python-level APIs of course), but until we do, let's follow CPython layout.
2014-03-28 20:52:17 -04:00
PUSH(mp_obj_get_type(nlr.ret_val));
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 {
py: VM never throws an exception, instead returns a status and value. Addresses issue #290, and hopefully sets up things to allow generators throwing exceptions, etc.
2014-02-15 17:55:00 -05:00
// propagate exception to higher level
// TODO what to do about ip and sp? they don't really make sense at this point
fastn[0] = nlr.ret_val; // must put exception here because sp is invalid
return MP_VM_RETURN_EXCEPTION;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}