Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 1 | #include <stdlib.h> |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 2 | #include <assert.h> |
| 3 | |
| 4 | #include "nlr.h" |
| 5 | #include "misc.h" |
| 6 | #include "mpconfig.h" |
Damien George | 55baff4 | 2014-01-21 21:40:13 +0000 | [diff] [blame] | 7 | #include "qstr.h" |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 8 | #include "obj.h" |
| 9 | #include "runtime.h" |
| 10 | #include "bc.h" |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 11 | #include "objgenerator.h" |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 12 | #include "objfun.h" |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 13 | |
| 14 | /******************************************************************************/ |
| 15 | /* generator wrapper */ |
| 16 | |
| 17 | typedef struct _mp_obj_gen_wrap_t { |
| 18 | mp_obj_base_t base; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 19 | mp_obj_t *fun; |
| 20 | } mp_obj_gen_wrap_t; |
| 21 | |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 22 | mp_obj_t mp_obj_new_gen_instance(mp_obj_dict_t *globals, const byte *bytecode, uint n_args, const mp_obj_t *args, |
| 23 | uint n_args2, const mp_obj_t *args2); |
Paul Sokolovsky | 7fafb28 | 2014-03-30 20:21:28 +0300 | [diff] [blame] | 24 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 25 | STATIC mp_obj_t gen_wrap_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) { |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 26 | mp_obj_gen_wrap_t *self = self_in; |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 27 | mp_obj_fun_bc_t *self_fun = (mp_obj_fun_bc_t*)self->fun; |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 28 | assert(MP_OBJ_IS_TYPE(self_fun, &mp_type_fun_bc)); |
Damien George | 6baf76e | 2013-12-30 22:32:17 +0000 | [diff] [blame] | 29 | |
Paul Sokolovsky | 7fafb28 | 2014-03-30 20:21:28 +0300 | [diff] [blame] | 30 | const mp_obj_t *args1, *args2; |
| 31 | uint len1, len2; |
Damien George | 0997af9 | 2014-03-30 21:55:28 +0100 | [diff] [blame] | 32 | if (!mp_obj_fun_prepare_simple_args(self_fun, n_args, n_kw, args, &len1, &args1, &len2, &args2)) { |
| 33 | assert(0); |
| 34 | } |
Paul Sokolovsky | 7fafb28 | 2014-03-30 20:21:28 +0300 | [diff] [blame] | 35 | |
Damien George | de7c425 | 2014-04-17 19:16:11 +0100 | [diff] [blame] | 36 | return mp_obj_new_gen_instance(self_fun->globals, self_fun->bytecode, len1, args1, len2, args2); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 37 | } |
| 38 | |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 39 | const mp_obj_type_t mp_type_gen_wrap = { |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 40 | { &mp_type_type }, |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 41 | .name = MP_QSTR_generator, |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 42 | .call = gen_wrap_call, |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 43 | }; |
| 44 | |
Damien George | d0691cc | 2014-01-29 20:30:52 +0000 | [diff] [blame] | 45 | mp_obj_t mp_obj_new_gen_wrap(mp_obj_t fun) { |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 46 | mp_obj_gen_wrap_t *o = m_new_obj(mp_obj_gen_wrap_t); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 47 | o->base.type = &mp_type_gen_wrap; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 48 | o->fun = fun; |
| 49 | return o; |
| 50 | } |
| 51 | |
| 52 | /******************************************************************************/ |
| 53 | /* generator instance */ |
| 54 | |
| 55 | typedef struct _mp_obj_gen_instance_t { |
| 56 | mp_obj_base_t base; |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 57 | mp_obj_dict_t *globals; |
Damien George | 0833500 | 2014-01-18 23:24:36 +0000 | [diff] [blame] | 58 | const byte *code_info; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 59 | const byte *ip; |
| 60 | mp_obj_t *sp; |
Paul Sokolovsky | 8dc768b | 2014-03-22 22:53:53 +0200 | [diff] [blame] | 61 | // bit 0 is saved currently_in_except_block value |
Damien George | 89f94b5 | 2014-03-30 00:57:09 +0000 | [diff] [blame] | 62 | mp_exc_stack_t *exc_sp; |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 63 | uint n_state; |
Paul Sokolovsky | 8dc768b | 2014-03-22 22:53:53 +0200 | [diff] [blame] | 64 | // Variable-length |
| 65 | mp_obj_t state[0]; |
| 66 | // Variable-length, never accessed by name, only as (void*)(state + n_state) |
Damien George | 89f94b5 | 2014-03-30 00:57:09 +0000 | [diff] [blame] | 67 | mp_exc_stack_t exc_state[0]; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 68 | } mp_obj_gen_instance_t; |
| 69 | |
Paul Sokolovsky | 76d982e | 2014-01-13 19:19:16 +0200 | [diff] [blame] | 70 | void gen_instance_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 71 | print(env, "<generator object 'fun-name' at %p>", self_in); |
| 72 | } |
| 73 | |
| 74 | mp_obj_t gen_instance_getiter(mp_obj_t self_in) { |
| 75 | return self_in; |
| 76 | } |
| 77 | |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 78 | mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t throw_value, mp_obj_t *ret_val) { |
Paul Sokolovsky | aaff716 | 2014-03-30 02:32:30 +0200 | [diff] [blame] | 79 | assert(MP_OBJ_IS_TYPE(self_in, &mp_type_gen_instance)); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 80 | mp_obj_gen_instance_t *self = self_in; |
Paul Sokolovsky | 14d28be | 2014-01-27 01:01:37 +0200 | [diff] [blame] | 81 | if (self->ip == 0) { |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 82 | *ret_val = MP_OBJ_STOP_ITERATION; |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 83 | return MP_VM_RETURN_NORMAL; |
Paul Sokolovsky | 14d28be | 2014-01-27 01:01:37 +0200 | [diff] [blame] | 84 | } |
Paul Sokolovsky | bf38e2a | 2014-01-26 20:50:11 +0200 | [diff] [blame] | 85 | if (self->sp == self->state - 1) { |
| 86 | if (send_value != mp_const_none) { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 87 | nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "can't send non-None value to a just-started generator")); |
Paul Sokolovsky | bf38e2a | 2014-01-26 20:50:11 +0200 | [diff] [blame] | 88 | } |
| 89 | } else { |
| 90 | *self->sp = send_value; |
| 91 | } |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 92 | mp_obj_dict_t *old_globals = mp_globals_get(); |
| 93 | mp_globals_set(self->globals); |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 94 | mp_vm_return_kind_t ret_kind = mp_execute_byte_code_2(self->code_info, &self->ip, |
Damien George | 89f94b5 | 2014-03-30 00:57:09 +0000 | [diff] [blame] | 95 | &self->state[self->n_state - 1], &self->sp, (mp_exc_stack_t*)(self->state + self->n_state), |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 96 | &self->exc_sp, throw_value); |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 97 | mp_globals_set(old_globals); |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 98 | |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 99 | switch (ret_kind) { |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 100 | case MP_VM_RETURN_NORMAL: |
| 101 | // Explicitly mark generator as completed. If we don't do this, |
| 102 | // subsequent next() may re-execute statements after last yield |
| 103 | // again and again, leading to side effects. |
| 104 | // TODO: check how return with value behaves under such conditions |
| 105 | // in CPython. |
| 106 | self->ip = 0; |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 107 | *ret_val = *self->sp; |
| 108 | break; |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 109 | |
| 110 | case MP_VM_RETURN_YIELD: |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 111 | *ret_val = *self->sp; |
| 112 | break; |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 113 | |
| 114 | case MP_VM_RETURN_EXCEPTION: |
Paul Sokolovsky | 61fd20f | 2014-03-22 16:44:58 +0200 | [diff] [blame] | 115 | self->ip = 0; |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 116 | *ret_val = self->state[self->n_state - 1]; |
| 117 | break; |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 118 | |
| 119 | default: |
| 120 | assert(0); |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 121 | *ret_val = mp_const_none; |
| 122 | break; |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 123 | } |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 124 | |
| 125 | return ret_kind; |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | STATIC mp_obj_t gen_resume_and_raise(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t throw_value) { |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 129 | mp_obj_t ret; |
| 130 | switch (mp_obj_gen_resume(self_in, send_value, throw_value, &ret)) { |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 131 | case MP_VM_RETURN_NORMAL: |
| 132 | // Optimize return w/o value in case generator is used in for loop |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 133 | if (ret == mp_const_none || ret == MP_OBJ_STOP_ITERATION) { |
| 134 | return MP_OBJ_STOP_ITERATION; |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 135 | } else { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 136 | nlr_raise(mp_obj_new_exception_args(&mp_type_StopIteration, 1, &ret)); |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | case MP_VM_RETURN_YIELD: |
Paul Sokolovsky | 817e76a | 2014-03-31 04:09:53 +0300 | [diff] [blame] | 140 | if (throw_value != MP_OBJ_NULL && mp_obj_is_subclass_fast(mp_obj_get_type(throw_value), &mp_type_GeneratorExit)) { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 141 | nlr_raise(mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator ignored GeneratorExit")); |
Paul Sokolovsky | 817e76a | 2014-03-31 04:09:53 +0300 | [diff] [blame] | 142 | } |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 143 | return ret; |
| 144 | |
| 145 | case MP_VM_RETURN_EXCEPTION: |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 146 | // TODO: Optimization of returning MP_OBJ_STOP_ITERATION is really part |
Paul Sokolovsky | f39d3b9 | 2014-03-30 23:14:55 +0300 | [diff] [blame] | 147 | // of mp_iternext() protocol, but this function is called by other methods |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 148 | // too, which may not handled MP_OBJ_STOP_ITERATION. |
Paul Sokolovsky | f39d3b9 | 2014-03-30 23:14:55 +0300 | [diff] [blame] | 149 | if (mp_obj_is_subclass_fast(mp_obj_get_type(ret), &mp_type_StopIteration)) { |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 150 | return MP_OBJ_STOP_ITERATION; |
Paul Sokolovsky | f39d3b9 | 2014-03-30 23:14:55 +0300 | [diff] [blame] | 151 | } else { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 152 | nlr_raise(ret); |
Paul Sokolovsky | f39d3b9 | 2014-03-30 23:14:55 +0300 | [diff] [blame] | 153 | } |
Paul Sokolovsky | 61fd20f | 2014-03-22 16:44:58 +0200 | [diff] [blame] | 154 | |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 155 | default: |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 156 | assert(0); |
| 157 | return mp_const_none; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 158 | } |
| 159 | } |
Paul Sokolovsky | bf38e2a | 2014-01-26 20:50:11 +0200 | [diff] [blame] | 160 | |
| 161 | mp_obj_t gen_instance_iternext(mp_obj_t self_in) { |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 162 | return gen_resume_and_raise(self_in, mp_const_none, MP_OBJ_NULL); |
Paul Sokolovsky | bf38e2a | 2014-01-26 20:50:11 +0200 | [diff] [blame] | 163 | } |
| 164 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 165 | STATIC mp_obj_t gen_instance_send(mp_obj_t self_in, mp_obj_t send_value) { |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 166 | mp_obj_t ret = gen_resume_and_raise(self_in, send_value, MP_OBJ_NULL); |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 167 | if (ret == MP_OBJ_STOP_ITERATION) { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 168 | nlr_raise(mp_obj_new_exception(&mp_type_StopIteration)); |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 169 | } else { |
| 170 | return ret; |
Paul Sokolovsky | 14d28be | 2014-01-27 01:01:37 +0200 | [diff] [blame] | 171 | } |
Paul Sokolovsky | 14d28be | 2014-01-27 01:01:37 +0200 | [diff] [blame] | 172 | } |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 173 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 174 | STATIC MP_DEFINE_CONST_FUN_OBJ_2(gen_instance_send_obj, gen_instance_send); |
Paul Sokolovsky | 14d28be | 2014-01-27 01:01:37 +0200 | [diff] [blame] | 175 | |
Paul Sokolovsky | 9a54a22 | 2014-03-30 13:13:12 +0300 | [diff] [blame] | 176 | STATIC mp_obj_t gen_instance_close(mp_obj_t self_in); |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 177 | STATIC mp_obj_t gen_instance_throw(uint n_args, const mp_obj_t *args) { |
Paul Sokolovsky | 9a54a22 | 2014-03-30 13:13:12 +0300 | [diff] [blame] | 178 | mp_obj_t exc = (n_args == 2) ? args[1] : args[2]; |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 179 | exc = mp_make_raise_obj(exc); |
Paul Sokolovsky | 9a54a22 | 2014-03-30 13:13:12 +0300 | [diff] [blame] | 180 | |
| 181 | mp_obj_t ret = gen_resume_and_raise(args[0], mp_const_none, exc); |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 182 | if (ret == MP_OBJ_STOP_ITERATION) { |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 183 | nlr_raise(mp_obj_new_exception(&mp_type_StopIteration)); |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 184 | } else { |
| 185 | return ret; |
| 186 | } |
| 187 | } |
| 188 | |
| 189 | STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gen_instance_throw_obj, 2, 4, gen_instance_throw); |
| 190 | |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 191 | STATIC mp_obj_t gen_instance_close(mp_obj_t self_in) { |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 192 | mp_obj_t ret; |
Damien George | 07ddab5 | 2014-03-29 13:15:08 +0000 | [diff] [blame] | 193 | switch (mp_obj_gen_resume(self_in, mp_const_none, (mp_obj_t)&mp_const_GeneratorExit_obj, &ret)) { |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 194 | case MP_VM_RETURN_YIELD: |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 195 | nlr_raise(mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator ignored GeneratorExit")); |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 196 | |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 197 | // Swallow StopIteration & GeneratorExit (== successful close), and re-raise any other |
| 198 | case MP_VM_RETURN_EXCEPTION: |
| 199 | // ret should always be an instance of an exception class |
| 200 | if (mp_obj_is_subclass_fast(mp_obj_get_type(ret), &mp_type_GeneratorExit) || |
| 201 | mp_obj_is_subclass_fast(mp_obj_get_type(ret), &mp_type_StopIteration)) { |
| 202 | return mp_const_none; |
| 203 | } |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 204 | nlr_raise(ret); |
Damien George | 69b3ba0 | 2014-03-26 19:33:23 +0000 | [diff] [blame] | 205 | |
| 206 | default: |
| 207 | // The only choice left is MP_VM_RETURN_NORMAL which is successful close |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 208 | return mp_const_none; |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 209 | } |
Paul Sokolovsky | 962b1cd | 2014-03-23 21:48:29 +0200 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | STATIC MP_DEFINE_CONST_FUN_OBJ_1(gen_instance_close_obj, gen_instance_close); |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 213 | |
Damien George | 9b196cd | 2014-03-26 21:47:19 +0000 | [diff] [blame] | 214 | STATIC const mp_map_elem_t gen_instance_locals_dict_table[] = { |
| 215 | { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t)&gen_instance_close_obj }, |
| 216 | { MP_OBJ_NEW_QSTR(MP_QSTR_send), (mp_obj_t)&gen_instance_send_obj }, |
| 217 | { MP_OBJ_NEW_QSTR(MP_QSTR_throw), (mp_obj_t)&gen_instance_throw_obj }, |
Paul Sokolovsky | bf38e2a | 2014-01-26 20:50:11 +0200 | [diff] [blame] | 218 | }; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 219 | |
Damien George | 9b196cd | 2014-03-26 21:47:19 +0000 | [diff] [blame] | 220 | STATIC MP_DEFINE_CONST_DICT(gen_instance_locals_dict, gen_instance_locals_dict_table); |
| 221 | |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 222 | const mp_obj_type_t mp_type_gen_instance = { |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 223 | { &mp_type_type }, |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 224 | .name = MP_QSTR_generator, |
Damien George | 97209d3 | 2014-01-07 15:58:30 +0000 | [diff] [blame] | 225 | .print = gen_instance_print, |
| 226 | .getiter = gen_instance_getiter, |
| 227 | .iternext = gen_instance_iternext, |
Damien George | 9b196cd | 2014-03-26 21:47:19 +0000 | [diff] [blame] | 228 | .locals_dict = (mp_obj_t)&gen_instance_locals_dict, |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 229 | }; |
| 230 | |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 231 | mp_obj_t mp_obj_new_gen_instance(mp_obj_dict_t *globals, const byte *bytecode, uint n_args, const mp_obj_t *args, |
| 232 | uint n_args2, const mp_obj_t *args2) { |
Paul Sokolovsky | 6ae237d | 2014-03-30 02:33:08 +0200 | [diff] [blame] | 233 | const byte *code_info = bytecode; |
Damien George | 8dcc0c7 | 2014-03-27 10:55:21 +0000 | [diff] [blame] | 234 | // get code info size, and skip the line number table |
| 235 | machine_uint_t code_info_size = bytecode[0] | (bytecode[1] << 8) | (bytecode[2] << 16) | (bytecode[3] << 24); |
| 236 | bytecode += code_info_size; |
| 237 | |
Damien George | bee17b0 | 2014-03-27 11:07:04 +0000 | [diff] [blame] | 238 | // bytecode prelude: get state size and exception stack size |
| 239 | machine_uint_t n_state = bytecode[0] | (bytecode[1] << 8); |
| 240 | machine_uint_t n_exc_stack = bytecode[2] | (bytecode[3] << 8); |
| 241 | bytecode += 4; |
Damien George | 8dcc0c7 | 2014-03-27 10:55:21 +0000 | [diff] [blame] | 242 | |
Damien George | 13d6739 | 2014-04-09 19:01:45 +0100 | [diff] [blame] | 243 | // allocate the generator object, with room for local stack and exception stack |
Damien George | 89f94b5 | 2014-03-30 00:57:09 +0000 | [diff] [blame] | 244 | mp_obj_gen_instance_t *o = m_new_obj_var(mp_obj_gen_instance_t, byte, n_state * sizeof(mp_obj_t) + n_exc_stack * sizeof(mp_exc_stack_t)); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 245 | o->base.type = &mp_type_gen_instance; |
Paul Sokolovsky | b7e90ea | 2014-04-17 05:49:47 +0300 | [diff] [blame] | 246 | o->globals = globals; |
Paul Sokolovsky | 6ae237d | 2014-03-30 02:33:08 +0200 | [diff] [blame] | 247 | o->code_info = code_info; |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 248 | o->sp = &o->state[0] - 1; // sp points to top of stack, which starts off 1 below the state |
Damien George | 89f94b5 | 2014-03-30 00:57:09 +0000 | [diff] [blame] | 249 | o->exc_sp = (mp_exc_stack_t*)(o->state + n_state) - 1; |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 250 | o->n_state = n_state; |
Damien George | 0ff8839 | 2014-01-02 20:57:05 +0000 | [diff] [blame] | 251 | |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 252 | // copy args to end of state array, in reverse (that's how mp_execute_byte_code_2 needs it) |
Paul Sokolovsky | 7fafb28 | 2014-03-30 20:21:28 +0300 | [diff] [blame] | 253 | for (uint i = 0; i < n_args; i++) { |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 254 | o->state[n_state - 1 - i] = args[i]; |
Damien George | 0ff8839 | 2014-01-02 20:57:05 +0000 | [diff] [blame] | 255 | } |
Paul Sokolovsky | 7fafb28 | 2014-03-30 20:21:28 +0300 | [diff] [blame] | 256 | for (uint i = 0; i < n_args2; i++) { |
| 257 | o->state[n_state - 1 - n_args - i] = args2[i]; |
| 258 | } |
Damien George | 0ff8839 | 2014-01-02 20:57:05 +0000 | [diff] [blame] | 259 | |
Damien George | d99944a | 2014-04-09 19:53:31 +0100 | [diff] [blame] | 260 | // set rest of state to MP_OBJ_NULL |
| 261 | for (uint i = 0; i < n_state - n_args - n_args2; i++) { |
| 262 | o->state[i] = MP_OBJ_NULL; |
| 263 | } |
| 264 | |
Damien George | 13d6739 | 2014-04-09 19:01:45 +0100 | [diff] [blame] | 265 | // bytecode prelude: initialise closed over variables |
| 266 | for (uint n_local = *bytecode++; n_local > 0; n_local--) { |
| 267 | uint local_num = *bytecode++; |
Damien George | d99944a | 2014-04-09 19:53:31 +0100 | [diff] [blame] | 268 | o->state[n_state - 1 - local_num] = mp_obj_new_cell(o->state[n_state - 1 - local_num]); |
Damien George | 13d6739 | 2014-04-09 19:01:45 +0100 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | // set ip to start of actual byte code |
| 272 | o->ip = bytecode; |
| 273 | |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 274 | return o; |
| 275 | } |