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

3167 lines
121 KiB
C
Raw Normal View History

Initial commit.
2013-10-04 14:53:11 -04:00
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#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"
Initial commit.
2013-10-04 14:53:11 -04:00
#include "lexer.h"
#include "parse.h"
#include "scope.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 "runtime0.h"
Initial commit.
2013-10-04 14:53:11 -04:00
#include "emit.h"
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
#include "obj.h"
#include "compile.h"
#include "runtime.h"
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO need to mangle __attr names
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#define MICROPY_EMIT_NATIVE (MICROPY_EMIT_X64 || MICROPY_EMIT_THUMB)
Initial commit.
2013-10-04 14:53:11 -04:00
typedef enum {
PN_none = 0,
#define DEF_RULE(rule, comp, kind, arg...) PN_##rule,
#include "grammar.h"
#undef DEF_RULE
PN_maximum_number_of,
} pn_kind_t;
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
#define EMIT(fun, arg...) (comp->emit_method_table->fun(comp->emit, ##arg))
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
#define EMIT_INLINE_ASM(fun, arg...) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm, ##arg))
Initial commit.
2013-10-04 14:53:11 -04:00
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
#define EMIT_OPT_NONE (0)
#define EMIT_OPT_BYTE_CODE (1)
#define EMIT_OPT_NATIVE_PYTHON (2)
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
#define EMIT_OPT_VIPER (3)
#define EMIT_OPT_ASM_THUMB (4)
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
Initial commit.
2013-10-04 14:53:11 -04:00
typedef struct _compiler_t {
qstr qstr___class__;
qstr qstr___locals__;
qstr qstr___name__;
qstr qstr___module__;
qstr qstr___qualname__;
qstr qstr___doc__;
qstr qstr_assertion_error;
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr qstr_micropython;
Implement REPL.
2013-10-18 14:58:12 -04:00
qstr qstr_byte_code;
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr qstr_native;
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
qstr qstr_viper;
Incorporate emit_thumb into new emit framework.
2013-10-05 13:41:24 -04:00
qstr qstr_asm_thumb;
py: restrict further when for-range optimisation is done.
2013-11-28 14:12:18 -05:00
qstr qstr_range;
Initial commit.
2013-10-04 14:53:11 -04:00
Implement REPL.
2013-10-18 14:58:12 -04:00
bool is_repl;
Initial commit.
2013-10-04 14:53:11 -04:00
pass_kind_t pass;
Implement REPL.
2013-10-18 14:58:12 -04:00
bool had_error; // try to keep compiler clean from nlr
Initial commit.
2013-10-04 14:53:11 -04:00
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int next_label;
Initial commit.
2013-10-04 14:53:11 -04:00
int break_label;
int continue_label;
int except_nest_level;
int n_arg_keyword;
bool have_star_arg;
bool have_dbl_star_arg;
bool have_bare_star;
int param_pass;
int param_pass_num_dict_params;
int param_pass_num_default_params;
scope_t *scope_head;
scope_t *scope_cur;
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
emit_t *emit; // current emitter
const emit_method_table_t *emit_method_table; // current emit method table
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
emit_inline_asm_t *emit_inline_asm; // current emitter for inline asm
const emit_inline_asm_method_table_t *emit_inline_asm_method_table; // current emit method table for inline asm
Initial commit.
2013-10-04 14:53:11 -04:00
} compiler_t;
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_parse_node_t fold_constants(mp_parse_node_t pn) {
if (MP_PARSE_NODE_IS_STRUCT(pn)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
// fold arguments first
for (int i = 0; i < n; i++) {
pns->nodes[i] = fold_constants(pns->nodes[i]);
}
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
switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
Initial commit.
2013-10-04 14:53:11 -04:00
case PN_shift_expr:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
int arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
int arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_LESS)) {
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// can overflow; enabled only to compare with CPython
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
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 << arg1);
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
#endif
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_MORE)) {
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 >> arg1);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
}
}
break;
case PN_arith_expr:
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// overflow checking here relies on SMALL_INT being strictly smaller than machine_int_t
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
machine_int_t arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
machine_int_t arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
machine_int_t res;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_PLUS)) {
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
res = arg0 + arg1;
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_MINUS)) {
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
res = arg0 - arg1;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
res = 0;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_FIT_SMALL_INT(res)) {
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, res);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
break;
case PN_term:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
int arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
int arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// can overflow; enabled only to compare with CPython
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
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 * arg1);
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
#endif
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_SLASH)) {
Initial commit.
2013-10-04 14:53:11 -04:00
; // pass
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_PERCENT)) {
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// XXX implement this properly as Python's % operator acts differently to C's
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
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 % arg1);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_SLASH)) {
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// XXX implement this properly as Python's // operator acts differently to C's
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
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 / arg1);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
}
}
break;
case PN_factor_2:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[1])) {
machine_int_t arg = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, -arg);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)) {
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, ~arg);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
}
}
break;
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Initial commit.
2013-10-04 14:53:11 -04:00
case PN_power:
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
// can overflow; enabled only to compare with CPython
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_NULL(pns->nodes[1]) && !MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
mp_parse_node_struct_t* pns2 = (mp_parse_node_struct_t*)pns->nodes[2];
if (MP_PARSE_NODE_IS_SMALL_INT(pns2->nodes[0])) {
int power = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
if (power >= 0) {
int ans = 1;
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
int base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
for (; power > 0; power--) {
ans *= base;
}
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
pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, ans);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
break;
Tidy up SMALL_INT optimisations and CPython compatibility.
2013-10-12 11:16:56 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
return pn;
}
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
void compile_node(compiler_t *comp, mp_parse_node_t pn);
Initial commit.
2013-10-04 14:53:11 -04:00
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
static int comp_next_label(compiler_t *comp) {
return comp->next_label++;
}
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
static scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, mp_parse_node_t pn, uint emit_options) {
Implement REPL.
2013-10-18 14:58:12 -04:00
scope_t *scope = scope_new(kind, pn, rt_get_unique_code_id(kind == SCOPE_MODULE), emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
scope->parent = comp->scope_cur;
scope->next = NULL;
if (comp->scope_head == NULL) {
comp->scope_head = scope;
} else {
scope_t *s = comp->scope_head;
while (s->next != NULL) {
s = s->next;
}
s->next = scope;
}
return scope;
}
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
static int list_len(mp_parse_node_t pn, int pn_kind) {
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
return 0;
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
} else if (MP_PARSE_NODE_IS_LEAF(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
return 1;
} 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
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
Initial commit.
2013-10-04 14:53:11 -04:00
return 1;
} 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
return MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
static void apply_to_single_or_list(compiler_t *comp, mp_parse_node_t pn, int pn_list_kind, void (*f)(compiler_t*, mp_parse_node_t)) {
if (MP_PARSE_NODE_IS_STRUCT(pn) && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn) == pn_list_kind) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < num_nodes; i++) {
f(comp, pns->nodes[i]);
}
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
} else if (!MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
f(comp, pn);
}
}
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
static int list_get(mp_parse_node_t *pn, int pn_kind, mp_parse_node_t **nodes) {
if (MP_PARSE_NODE_IS_NULL(*pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
*nodes = NULL;
return 0;
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
} else if (MP_PARSE_NODE_IS_LEAF(*pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
*nodes = pn;
return 1;
} 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
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)(*pn);
if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
Initial commit.
2013-10-04 14:53:11 -04:00
*nodes = pn;
return 1;
} else {
*nodes = pns->nodes;
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
return MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_do_nothing(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_generic_all_nodes(compiler_t *comp, mp_parse_node_struct_t *pns) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < num_nodes; i++) {
compile_node(comp, pns->nodes[i]);
}
}
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
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
static bool cpython_c_tuple_is_const(mp_parse_node_t pn) {
if (!MP_PARSE_NODE_IS_LEAF(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
return false;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_ID(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
return false;
}
return true;
}
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
static void cpython_c_print_quoted_str(vstr_t *vstr, qstr qstr, bool bytes) {
const char *str = qstr_str(qstr);
int len = strlen(str);
bool has_single_quote = false;
bool has_double_quote = false;
for (int i = 0; i < len; i++) {
if (str[i] == '\'') {
has_single_quote = true;
} else if (str[i] == '"') {
has_double_quote = true;
}
}
if (bytes) {
vstr_printf(vstr, "b");
}
bool quote_single = false;
if (has_single_quote && !has_double_quote) {
vstr_printf(vstr, "\"");
} else {
quote_single = true;
vstr_printf(vstr, "'");
}
for (int i = 0; i < len; i++) {
if (str[i] == '\n') {
vstr_printf(vstr, "\\n");
} else if (str[i] == '\\') {
vstr_printf(vstr, "\\\\");
} else if (str[i] == '\'' && quote_single) {
vstr_printf(vstr, "\\'");
} else {
vstr_printf(vstr, "%c", str[i]);
}
}
if (has_single_quote && !has_double_quote) {
vstr_printf(vstr, "\"");
} else {
vstr_printf(vstr, "'");
}
}
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
static void cpython_c_tuple_emit_const(compiler_t *comp, mp_parse_node_t pn, vstr_t *vstr) {
assert(MP_PARSE_NODE_IS_LEAF(pn));
int arg = MP_PARSE_NODE_LEAF_ARG(pn);
switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
case MP_PARSE_NODE_ID: assert(0);
case MP_PARSE_NODE_SMALL_INT: vstr_printf(vstr, "%d", arg); break;
case MP_PARSE_NODE_INTEGER: vstr_printf(vstr, "%s", qstr_str(arg)); break;
case MP_PARSE_NODE_DECIMAL: vstr_printf(vstr, "%s", qstr_str(arg)); break;
case MP_PARSE_NODE_STRING: cpython_c_print_quoted_str(vstr, arg, false); break;
case MP_PARSE_NODE_BYTES: cpython_c_print_quoted_str(vstr, arg, true); break;
case MP_PARSE_NODE_TOKEN:
Initial commit.
2013-10-04 14:53:11 -04:00
switch (arg) {
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_TOKEN_KW_FALSE: vstr_printf(vstr, "False"); break;
case MP_TOKEN_KW_NONE: vstr_printf(vstr, "None"); break;
case MP_TOKEN_KW_TRUE: vstr_printf(vstr, "True"); break;
Initial commit.
2013-10-04 14:53:11 -04:00
default: assert(0);
}
break;
default: assert(0);
}
}
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
static void cpython_c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
Initial commit.
2013-10-04 14:53:11 -04:00
int n = 0;
if (pns_list != NULL) {
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
n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
Initial commit.
2013-10-04 14:53:11 -04:00
}
int total = n;
bool is_const = true;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
total += 1;
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (!cpython_c_tuple_is_const(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
is_const = false;
}
}
for (int i = 0; i < n; i++) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (!cpython_c_tuple_is_const(pns_list->nodes[i])) {
Initial commit.
2013-10-04 14:53:11 -04:00
is_const = false;
break;
}
}
if (total > 0 && is_const) {
bool need_comma = false;
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
vstr_t *vstr = vstr_new();
vstr_printf(vstr, "(");
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pn)) {
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
cpython_c_tuple_emit_const(comp, pn, vstr);
Initial commit.
2013-10-04 14:53:11 -04:00
need_comma = true;
}
for (int i = 0; i < n; i++) {
if (need_comma) {
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
vstr_printf(vstr, ", ");
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
cpython_c_tuple_emit_const(comp, pns_list->nodes[i], vstr);
Initial commit.
2013-10-04 14:53:11 -04:00
need_comma = true;
}
if (total == 1) {
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
vstr_printf(vstr, ",)");
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
vstr_printf(vstr, ")");
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
EMIT(load_const_verbatim_str, vstr_str(vstr));
vstr_free(vstr);
Initial commit.
2013-10-04 14:53:11 -04:00
} 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
if (!MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn);
}
for (int i = 0; i < n; i++) {
compile_node(comp, pns_list->nodes[i]);
}
EMIT(build_tuple, total);
}
}
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
#endif
// funnelling all tuple creations through this function is purely so we can optionally agree with CPython
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
void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_tuple(comp, pn, pns_list);
#else
int total = 0;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pn)) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
compile_node(comp, pn);
total += 1;
}
if (pns_list != NULL) {
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
for (int i = 0; i < n; i++) {
compile_node(comp, pns_list->nodes[i]);
}
total += n;
}
EMIT(build_tuple, total);
#endif
}
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a simple tuple expression
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
c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
static bool node_is_const_false(mp_parse_node_t pn) {
return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_FALSE);
// untested: || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_ARG(pn) == 1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
static bool node_is_const_true(mp_parse_node_t pn) {
return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_TRUE) || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_ARG(pn) == 1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
// the is_nested variable is purely to match with CPython, which doesn't fully optimise not's
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
static void cpython_c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label, bool is_nested) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (node_is_const_false(pn)) {
if (jump_if == false) {
EMIT(jump, label);
}
return;
} else if (node_is_const_true(pn)) {
if (jump_if == true) {
EMIT(jump, label);
}
return;
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
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (jump_if == false) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int label2 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n - 1; i++) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[i], true, label2, true);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[n - 1], false, label, true);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, label2);
} else {
for (int i = 0; i < n; i++) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[i], true, label, true);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
return;
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (jump_if == false) {
for (int i = 0; i < n; i++) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[i], false, label, true);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int label2 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n - 1; i++) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[i], false, label2, true);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[n - 1], true, label, true);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, label2);
}
return;
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
} else if (!is_nested && MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pns->nodes[0], !jump_if, label, true);
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
}
// nothing special, fall back to default compiling for node and jump
compile_node(comp, pn);
if (jump_if == false) {
EMIT(pop_jump_if_false, label);
} else {
EMIT(pop_jump_if_true, label);
}
}
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
static void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
cpython_c_if_cond(comp, pn, jump_if, label, false);
#else
if (node_is_const_false(pn)) {
if (jump_if == false) {
EMIT(jump, label);
}
return;
} else if (node_is_const_true(pn)) {
if (jump_if == true) {
EMIT(jump, label);
}
return;
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
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == false) {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
c_if_cond(comp, pns->nodes[i], true, label2);
}
c_if_cond(comp, pns->nodes[n - 1], false, label);
EMIT(label_assign, label2);
} else {
for (int i = 0; i < n; i++) {
c_if_cond(comp, pns->nodes[i], true, label);
}
}
return;
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == false) {
for (int i = 0; i < n; i++) {
c_if_cond(comp, pns->nodes[i], false, label);
}
} else {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
c_if_cond(comp, pns->nodes[i], false, label2);
}
c_if_cond(comp, pns->nodes[n - 1], true, label);
EMIT(label_assign, label2);
}
return;
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
c_if_cond(comp, pns->nodes[0], !jump_if, label);
return;
}
}
// nothing special, fall back to default compiling for node and jump
compile_node(comp, pn);
if (jump_if == false) {
EMIT(pop_jump_if_false, label);
} else {
EMIT(pop_jump_if_true, label);
}
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
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
void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void c_assign_power(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t assign_kind) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind != ASSIGN_AUG_STORE) {
compile_node(comp, pns->nodes[0]);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind != ASSIGN_AUG_STORE) {
for (int i = 0; i < n - 1; i++) {
compile_node(comp, pns1->nodes[i]);
}
}
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
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
Initial commit.
2013-10-04 14:53:11 -04:00
printf("SyntaxError: can't assign to function call\n");
return;
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_three);
EMIT(store_subscr);
} else {
compile_node(comp, pns1->nodes[0]);
if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top_two);
EMIT(binary_op, RT_BINARY_OP_SUBSCR);
} else {
EMIT(store_subscr);
}
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_two);
}
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
EMIT(store_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// shouldn't happen
assert(0);
}
} else {
// shouldn't happen
assert(0);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// SyntaxError, cannot assign
assert(0);
}
}
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
void c_assign_tuple(compiler_t *comp, int n, mp_parse_node_t *nodes) {
Initial commit.
2013-10-04 14:53:11 -04:00
assert(n >= 0);
int have_star_index = -1;
for (int i = 0; i < n; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_star_expr)) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (have_star_index < 0) {
EMIT(unpack_ex, i, n - i - 1);
have_star_index = i;
} else {
printf("SyntaxError: two starred expressions in assignment\n");
return;
}
}
}
if (have_star_index < 0) {
EMIT(unpack_sequence, n);
}
for (int i = 0; i < n; i++) {
if (i == have_star_index) {
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
c_assign(comp, ((mp_parse_node_struct_t*)nodes[i])->nodes[0], ASSIGN_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
c_assign(comp, nodes[i], ASSIGN_STORE);
}
}
}
// assigns top of stack to pn
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
void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {
Initial commit.
2013-10-04 14:53:11 -04:00
tail_recursion:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
assert(0);
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
} else if (MP_PARSE_NODE_IS_LEAF(pn)) {
if (MP_PARSE_NODE_IS_ID(pn)) {
int arg = MP_PARSE_NODE_LEAF_ARG(pn);
Initial commit.
2013-10-04 14:53:11 -04:00
switch (assign_kind) {
case ASSIGN_STORE:
case ASSIGN_AUG_STORE:
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, arg);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
case ASSIGN_AUG_LOAD:
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(load_id, arg);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
}
} else {
printf("SyntaxError: can't assign to literal\n");
return;
}
} 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
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
Initial commit.
2013-10-04 14:53:11 -04:00
case PN_power:
// lhs is an index or attribute
c_assign_power(comp, pns, assign_kind);
break;
case PN_testlist_star_expr:
case PN_exprlist:
// lhs is a tuple
if (assign_kind != ASSIGN_STORE) {
goto bad_aug;
}
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
c_assign_tuple(comp, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
case PN_atom_paren:
// lhs is something in parenthesis
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty tuple
printf("SyntaxError: can't assign to ()\n");
return;
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
pns = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
goto testlist_comp;
} else {
// parenthesis around 1 item, is just that item
pn = pns->nodes[0];
goto tail_recursion;
}
break;
case PN_atom_bracket:
// lhs is something in brackets
if (assign_kind != ASSIGN_STORE) {
goto bad_aug;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty list, assignment allowed
c_assign_tuple(comp, 0, NULL);
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
pns = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
goto testlist_comp;
} else {
// brackets around 1 item
c_assign_tuple(comp, 1, &pns->nodes[0]);
}
break;
default:
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
printf("unknown assign, %u\n", (uint)MP_PARSE_NODE_STRUCT_KIND(pns));
Initial commit.
2013-10-04 14:53:11 -04:00
assert(0);
}
return;
testlist_comp:
// lhs is a sequence
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of one item, with trailing comma
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
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
c_assign_tuple(comp, 1, &pns->nodes[0]);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of many items
// TODO call c_assign_tuple instead
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns2);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(unpack_sequence, 1 + n);
c_assign(comp, pns->nodes[0], ASSIGN_STORE);
for (int i = 0; i < n; i++) {
c_assign(comp, pns2->nodes[i], ASSIGN_STORE);
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO not implemented
assert(0);
} else {
// sequence with 2 items
goto sequence_with_2_items;
}
} else {
// sequence with 2 items
sequence_with_2_items:
c_assign_tuple(comp, 2, pns->nodes);
}
return;
}
return;
bad_aug:
printf("SyntaxError: illegal expression for augmented assignment\n");
}
// stuff for lambda and comprehensions and generators
void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_dict_params, int n_default_params) {
// make closed over variables, if any
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
// ensure they are closed over in the order defined in the outer scope (mainly to agree with CPython)
Initial commit.
2013-10-04 14:53:11 -04:00
int nfree = 0;
if (comp->scope_cur->kind != SCOPE_MODULE) {
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
for (int i = 0; i < comp->scope_cur->id_info_len; i++) {
id_info_t *id = &comp->scope_cur->id_info[i];
if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
for (int j = 0; j < this_scope->id_info_len; j++) {
id_info_t *id2 = &this_scope->id_info[j];
if (id2->kind == ID_INFO_KIND_FREE && id->qstr == id2->qstr) {
py: make closures work.
2013-12-30 17:32:17 -05:00
#if MICROPY_EMIT_CPYTHON
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
EMIT(load_closure, id->qstr, id->local_num);
py: make closures work.
2013-12-30 17:32:17 -05:00
#else
// in Micro Python we load closures using LOAD_FAST
EMIT(load_fast, id->qstr, id->local_num);
#endif
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
nfree += 1;
}
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
if (nfree > 0) {
EMIT(build_tuple, nfree);
}
// make the function/closure
if (nfree == 0) {
EMIT(make_function, this_scope, n_dict_params, n_default_params);
} else {
EMIT(make_closure, this_scope, n_dict_params, n_default_params);
}
}
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
void compile_funcdef_param(compiler_t *comp, mp_parse_node_t pn) {
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_name)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this parameter has a default value
// in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why
if (comp->have_bare_star) {
comp->param_pass_num_dict_params += 1;
if (comp->param_pass == 1) {
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
EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[2]);
}
} else {
comp->param_pass_num_default_params += 1;
if (comp->param_pass == 2) {
compile_node(comp, pns->nodes[2]);
}
}
}
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_star)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// bare star
comp->have_bare_star = true;
}
}
}
// leaves function object on stack
// returns function name
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
qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
// create a new scope for this function
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
scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (mp_parse_node_t)pns, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the function scope so the compiling function can use it at each pass
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
pns->nodes[4] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// save variables (probably don't need to do this, since we can't have nested definitions..?)
bool old_have_bare_star = comp->have_bare_star;
int old_param_pass = comp->param_pass;
int old_param_pass_num_dict_params = comp->param_pass_num_dict_params;
int old_param_pass_num_default_params = comp->param_pass_num_default_params;
// compile default parameters
comp->have_bare_star = false;
comp->param_pass = 1; // pass 1 does any default parameters after bare star
comp->param_pass_num_dict_params = 0;
comp->param_pass_num_default_params = 0;
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_funcdef_param);
comp->have_bare_star = false;
comp->param_pass = 2; // pass 2 does any default parameters before bare star
comp->param_pass_num_dict_params = 0;
comp->param_pass_num_default_params = 0;
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_funcdef_param);
// get the scope for this function
scope_t *fscope = (scope_t*)pns->nodes[4];
// make the function
close_over_variables_etc(comp, fscope, comp->param_pass_num_dict_params, comp->param_pass_num_default_params);
// restore variables
comp->have_bare_star = old_have_bare_star;
comp->param_pass = old_param_pass;
comp->param_pass_num_dict_params = old_param_pass_num_dict_params;
comp->param_pass_num_default_params = old_param_pass_num_default_params;
// return its name (the 'f' in "def f(...):")
return fscope->simple_name;
}
// leaves class object on stack
// returns class name
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
qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
// create a new scope for this class
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
scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (mp_parse_node_t)pns, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the class scope so the compiling function can use it at each pass
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
pns->nodes[3] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(load_build_class);
// scope for this class
scope_t *cscope = (scope_t*)pns->nodes[3];
// compile the class
close_over_variables_etc(comp, cscope, 0, 0);
// get its name
EMIT(load_const_id, cscope->simple_name);
// nodes[1] has parent classes, if any
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// no parent classes
EMIT(call_function, 2, 0, false, false);
} else {
// have a parent class or classes
// TODO what if we have, eg, *a or **a in the parent list?
compile_node(comp, pns->nodes[1]);
EMIT(call_function, 2 + list_len(pns->nodes[1], PN_arglist), 0, false, false);
}
// return its name (the 'C' in class C(...):")
return cscope->simple_name;
}
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// returns true if it was a built-in decorator (even if the built-in had an error)
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
static bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != comp->qstr_micropython) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
return false;
}
if (name_len != 2) {
printf("SyntaxError: invalid micropython decorator\n");
return true;
}
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
qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
Implement REPL.
2013-10-18 14:58:12 -04:00
if (attr == comp->qstr_byte_code) {
*emit_options = EMIT_OPT_BYTE_CODE;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#if MICROPY_EMIT_NATIVE
} else if (attr == comp->qstr_native) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
*emit_options = EMIT_OPT_NATIVE_PYTHON;
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
} else if (attr == comp->qstr_viper) {
*emit_options = EMIT_OPT_VIPER;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#endif
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_INLINE_THUMB
Incorporate emit_thumb into new emit framework.
2013-10-05 13:41:24 -04:00
} else if (attr == comp->qstr_asm_thumb) {
*emit_options = EMIT_OPT_ASM_THUMB;
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
} else {
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
printf("SyntaxError: invalid micropython decorator '%s'\n", qstr_str(attr));
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
return true;
}
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
void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// get the list of decorators
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_parse_node_t *nodes;
Initial commit.
2013-10-04 14:53:11 -04:00
int n = list_get(&pns->nodes[0], PN_decorators, &nodes);
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// inherit emit options for this function/class definition
uint emit_options = comp->scope_cur->emit_options;
// compile each decorator
int num_built_in_decorators = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t*)nodes[i];
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// nodes[0] contains the decorator function, which is a dotted name
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_parse_node_t *name_nodes;
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
int name_len = list_get(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
// check for built-in decorators
if (compile_built_in_decorator(comp, name_len, name_nodes, &emit_options)) {
// this was a built-in
num_built_in_decorators += 1;
} else {
// not a built-in, compile normally
// compile the decorator function
compile_node(comp, name_nodes[0]);
for (int i = 1; i < name_len; i++) {
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
assert(MP_PARSE_NODE_IS_ID(name_nodes[i])); // should be
EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[i]));
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
// nodes[1] contains arguments to the decorator function, if any
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// call the decorator function with the arguments in nodes[1]
compile_node(comp, pns_decorator->nodes[1]);
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
// compile the body (funcdef or classdef) and get its name
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_parse_node_struct_t *pns_body = (mp_parse_node_struct_t*)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
qstr body_name = 0;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
body_name = compile_funcdef_helper(comp, pns_body, emit_options);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
body_name = compile_classdef_helper(comp, pns_body, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
}
// call each decorator
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
for (int i = 0; i < n - num_built_in_decorators; i++) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(call_function, 1, 0, false, false);
}
// store func/class object into name
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, body_name);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_funcdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr fname = compile_funcdef_helper(comp, pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store function object into function name
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, fname);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
if (MP_PARSE_NODE_IS_ID(pn)) {
EMIT(delete_id, MP_PARSE_NODE_LEAF_ARG(pn));
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]); // base of the power node
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n - 1; i++) {
compile_node(comp, pns1->nodes[i]);
}
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
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
Initial commit.
2013-10-04 14:53:11 -04:00
// SyntaxError: can't delete a function call
assert(0);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns1->nodes[0]);
EMIT(delete_subscr);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
EMIT(delete_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// shouldn't happen
assert(0);
}
} else {
// shouldn't happen
assert(0);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// SyntaxError, cannot delete
assert(0);
}
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of one item, with trailing comma
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
assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
c_del_stmt(comp, pns->nodes[0]);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of many items
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
c_del_stmt(comp, pns->nodes[0]);
for (int i = 0; i < n; i++) {
c_del_stmt(comp, pns1->nodes[i]);
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO not implemented; can't del comprehension?
assert(0);
} else {
// sequence with 2 items
goto sequence_with_2_items;
}
} else {
// sequence with 2 items
sequence_with_2_items:
c_del_stmt(comp, pns->nodes[0]);
c_del_stmt(comp, pns->nodes[1]);
}
} else {
// tuple with 1 element
c_del_stmt(comp, pn);
}
} else {
// not implemented
assert(0);
}
}
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
void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
}
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
void compile_break_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->break_label == 0) {
printf("ERROR: cannot break from here\n");
}
EMIT(break_loop, comp->break_label);
}
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
void compile_continue_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->continue_label == 0) {
printf("ERROR: cannot continue from here\n");
}
if (comp->except_nest_level > 0) {
EMIT(continue_loop, comp->continue_label);
} else {
EMIT(jump, comp->continue_label);
}
}
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
void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
printf("SyntaxError: 'return' outside function\n");
comp->had_error = true;
return;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Implement REPL.
2013-10-18 14:58:12 -04:00
// no argument to 'return', so return None
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// special case when returning an if-expression; to match CPython optimisation
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_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t*)pns->nodes[0];
mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns_test_if_expr->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
compile_node(comp, pns_test_if_expr->nodes[0]); // success value
EMIT(return_value);
EMIT(label_assign, l_fail);
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
} else {
compile_node(comp, pns->nodes[0]);
}
EMIT(return_value);
}
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
void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(pop_top);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// raise
EMIT(raise_varargs, 0);
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// raise x from y
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
pns = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
compile_node(comp, pns->nodes[1]);
EMIT(raise_varargs, 2);
} else {
// raise x
compile_node(comp, pns->nodes[0]);
EMIT(raise_varargs, 1);
}
}
// q1 holds the base, q2 the full name
// eg a -> q1=q2=a
// a.b.c -> q1=a, q2=a.b.c
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
void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q1, qstr *q2) {
Initial commit.
2013-10-04 14:53:11 -04:00
bool is_as = false;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
// a name of the form x as y; unwrap it
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
*q1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
Initial commit.
2013-10-04 14:53:11 -04:00
pn = pns->nodes[0];
is_as = true;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_ID(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// just a simple name
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
*q2 = MP_PARSE_NODE_LEAF_ARG(pn);
Initial commit.
2013-10-04 14:53:11 -04:00
if (!is_as) {
*q1 = *q2;
}
EMIT(import_name, *q2);
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
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dotted_name) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a name of the form a.b.c
if (!is_as) {
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
*q1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
int len = n - 1;
for (int i = 0; i < n; i++) {
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
len += strlen(qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
Initial commit.
2013-10-04 14:53:11 -04:00
}
char *str = m_new(char, len + 1);
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
char *str_dest = str;
Initial commit.
2013-10-04 14:53:11 -04:00
str[0] = 0;
for (int i = 0; i < n; i++) {
if (i > 0) {
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
*str_dest++ = '.';
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
const char *str_src = qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
size_t str_src_len = strlen(str_src);
memcpy(str_dest, str_src, str_src_len);
str_dest += str_src_len;
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
*str_dest = '\0';
Change memory allocation API to require size for free and realloc.
2013-12-29 14:33:23 -05:00
*q2 = qstr_from_str_take(str, len + 1);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(import_name, *q2);
if (is_as) {
for (int i = 1; i < n; i++) {
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
EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
} else {
// TODO not implemented
assert(0);
}
} else {
// TODO not implemented
assert(0);
}
}
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
void compile_dotted_as_name(compiler_t *comp, mp_parse_node_t pn) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(load_const_small_int, 0); // ??
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
qstr q1, q2;
do_import_name(comp, pn, &q1, &q2);
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, q1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_import_name(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
}
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
void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
EMIT(load_const_small_int, 0); // level 0 for __import__
// build the "fromlist" tuple
#if MICROPY_EMIT_CPYTHON
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(load_const_verbatim_str, "('*',)");
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
#else
EMIT(load_const_str, qstr_from_str_static("*"), false);
EMIT(build_tuple, 1);
#endif
// do the import
Initial commit.
2013-10-04 14:53:11 -04:00
qstr dummy_q, id1;
do_import_name(comp, pns->nodes[0], &dummy_q, &id1);
EMIT(import_star);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
EMIT(load_const_small_int, 0); // level 0 for __import__
// build the "fromlist" tuple
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_parse_node_t *pn_nodes;
Initial commit.
2013-10-04 14:53:11 -04:00
int n = list_get(&pns->nodes[1], PN_import_as_names, &pn_nodes);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
#if MICROPY_EMIT_CPYTHON
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
{
vstr_t *vstr = vstr_new();
vstr_printf(vstr, "(");
for (int i = 0; i < n; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
if (i > 0) {
vstr_printf(vstr, ", ");
}
vstr_printf(vstr, "'");
vstr_printf(vstr, qstr_str(id2));
vstr_printf(vstr, "'");
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: reduce use of emit_verbatim calls to minimum.
2013-12-12 10:13:36 -05:00
if (n == 1) {
vstr_printf(vstr, ",");
}
vstr_printf(vstr, ")");
EMIT(load_const_verbatim_str, vstr_str(vstr));
vstr_free(vstr);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
#else
for (int i = 0; i < n; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
EMIT(load_const_str, id2, false);
}
EMIT(build_tuple, n);
#endif
// do the import
Initial commit.
2013-10-04 14:53:11 -04:00
qstr dummy_q, id1;
do_import_name(comp, pns->nodes[0], &dummy_q, &id1);
for (int i = 0; i < n; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(import_from, id2);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, id2);
Initial commit.
2013-10-04 14:53:11 -04:00
} 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
EMIT(store_id, MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
EMIT(pop_top);
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_global_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (comp->pass == PASS_1) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
scope_declare_global(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
} 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
pns = (mp_parse_node_struct_t*)pns->nodes[0];
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
for (int i = 0; i < num_nodes; i++) {
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
scope_declare_global(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (comp->pass == PASS_1) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
scope_declare_nonlocal(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
} 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
pns = (mp_parse_node_struct_t*)pns->nodes[0];
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
for (int i = 0; i < num_nodes; i++) {
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
scope_declare_nonlocal(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_assert_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns->nodes[0], true, l_end);
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(load_id, comp->qstr_assertion_error);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// assertion message
compile_node(comp, pns->nodes[1]);
EMIT(call_function, 1, 0, false, false);
}
EMIT(raise_varargs, 1);
EMIT(label_assign, l_end);
}
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
void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO proper and/or short circuiting
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
compile_node(comp, pns->nodes[1]); // if 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
//if (!(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython
Initial commit.
2013-10-04 14:53:11 -04:00
// jump over elif/else blocks if they exist
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, l_end);
}
//}
EMIT(label_assign, l_fail);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// compile elif blocks
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_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t*)pns->nodes[2];
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns_elif) == PN_if_stmt_elif_list) {
Initial commit.
2013-10-04 14:53:11 -04:00
// multiple elif blocks
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_elif);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
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_parse_node_struct_t *pns_elif2 = (mp_parse_node_struct_t*)pns_elif->nodes[i];
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_elif2->nodes[0], false, l_fail); // elif condition
compile_node(comp, pns_elif2->nodes[1]); // elif block
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, l_end);
}
EMIT(label_assign, l_fail);
}
} else {
// a single elif block
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
compile_node(comp, pns_elif->nodes[1]); // elif block
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, l_end);
}
EMIT(label_assign, l_fail);
}
}
// compile else block
compile_node(comp, pns->nodes[3]); // can be null
EMIT(label_assign, l_end);
}
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
void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
int old_break_label = comp->break_label;
int old_continue_label = comp->continue_label;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int break_label = comp_next_label(comp);
int continue_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
comp->break_label = break_label;
comp->continue_label = continue_label;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// compared to CPython, we have an optimised version of while loops
#if MICROPY_EMIT_CPYTHON
int done_label = comp_next_label(comp);
EMIT(setup_loop, break_label);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, continue_label);
c_if_cond(comp, pns->nodes[0], false, done_label); // condition
compile_node(comp, pns->nodes[1]); // body
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, continue_label);
}
EMIT(label_assign, done_label);
// CPython does not emit POP_BLOCK if the condition was a constant; don't undertand why
// this is a small hack to agree with CPython
if (!node_is_const_true(pns->nodes[0])) {
EMIT(pop_block);
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#else
int top_label = comp_next_label(comp);
EMIT(jump, continue_label);
EMIT(label_assign, top_label);
compile_node(comp, pns->nodes[1]); // body
EMIT(label_assign, continue_label);
c_if_cond(comp, pns->nodes[0], true, top_label); // condition
#endif
// break/continue apply to outer loop (if any) in the else block
comp->break_label = old_break_label;
comp->continue_label = old_continue_label;
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[2]); // else
EMIT(label_assign, break_label);
}
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
// TODO preload end and step onto stack if they are not constants
// TODO check if step is negative and do opposite test
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
void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t pn_var, mp_parse_node_t pn_start, mp_parse_node_t pn_end, mp_parse_node_t pn_step, mp_parse_node_t pn_body, mp_parse_node_t pn_else) {
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
int old_break_label = comp->break_label;
int old_continue_label = comp->continue_label;
int break_label = comp_next_label(comp);
int continue_label = comp_next_label(comp);
comp->break_label = break_label;
comp->continue_label = continue_label;
int top_label = comp_next_label(comp);
// compile: var = start
compile_node(comp, pn_start);
c_assign(comp, pn_var, ASSIGN_STORE);
EMIT(jump, continue_label);
EMIT(label_assign, top_label);
Fix but with optimised range being 1 over.
2013-11-09 15:12:03 -05:00
// compile body
compile_node(comp, pn_body);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
// compile: var += step
c_assign(comp, pn_var, ASSIGN_AUG_LOAD);
compile_node(comp, pn_step);
EMIT(binary_op, RT_BINARY_OP_INPLACE_ADD);
c_assign(comp, pn_var, ASSIGN_AUG_STORE);
EMIT(label_assign, continue_label);
// compile: if var < end: goto top
compile_node(comp, pn_var);
compile_node(comp, pn_end);
EMIT(compare_op, RT_COMPARE_OP_LESS);
EMIT(pop_jump_if_true, top_label);
// break/continue apply to outer loop (if any) in the else block
comp->break_label = old_break_label;
comp->continue_label = old_continue_label;
compile_node(comp, pn_else);
EMIT(label_assign, break_label);
}
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
void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
#if !MICROPY_EMIT_CPYTHON
// this bit optimises: for <x> in range(...), turning it into an explicitly incremented variable
// this is actually slower, but uses no heap memory
// for viper it will be much, much faster
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (/*comp->scope_cur->emit_options == EMIT_OPT_VIPER &&*/ MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_power)) {
mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0]) && MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == comp->qstr_range && MP_PARSE_NODE_IS_STRUCT_KIND(pns_it->nodes[1], PN_trailer_paren) && MP_PARSE_NODE_IS_NULL(pns_it->nodes[2])) {
mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t*)pns_it->nodes[1])->nodes[0];
mp_parse_node_t *args;
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
int n_args = list_get(&pn_range_args, PN_arglist, &args);
if (1 <= n_args && n_args <= 3) {
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_parse_node_t pn_range_start;
mp_parse_node_t pn_range_end;
mp_parse_node_t pn_range_step;
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
if (n_args == 1) {
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
pn_range_start = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 0);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
pn_range_end = args[0];
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
pn_range_step = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 1);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
} else if (n_args == 2) {
pn_range_start = args[0];
pn_range_end = args[1];
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
pn_range_step = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 1);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
} else {
pn_range_start = args[0];
pn_range_end = args[1];
pn_range_step = args[2];
}
compile_for_stmt_optimised_range(comp, pns->nodes[0], pn_range_start, pn_range_end, pn_range_step, pns->nodes[2], pns->nodes[3]);
return;
}
}
}
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
int old_break_label = comp->break_label;
int old_continue_label = comp->continue_label;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int for_label = comp_next_label(comp);
int pop_label = comp_next_label(comp);
int end_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int break_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
comp->continue_label = for_label;
comp->break_label = break_label;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// I don't think our implementation needs SETUP_LOOP/POP_BLOCK for for-statements
#if MICROPY_EMIT_CPYTHON
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(setup_loop, end_label);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[1]); // iterator
EMIT(get_iter);
EMIT(label_assign, for_label);
EMIT(for_iter, pop_label);
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
compile_node(comp, pns->nodes[2]); // body
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, for_label);
}
EMIT(label_assign, pop_label);
EMIT(for_iter_end);
// break/continue apply to outer loop (if any) in the else block
comp->break_label = old_break_label;
comp->continue_label = old_continue_label;
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#if MICROPY_EMIT_CPYTHON
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(pop_block);
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[3]); // else (not tested)
EMIT(label_assign, break_label);
EMIT(label_assign, end_label);
}
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
void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_excepts, mp_parse_node_t pn_else) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this function is a bit of a hack at the moment
// don't understand how the stack works with exceptions, so we force it to return to the correct value
// setup code
int stack_size = EMIT(get_stack_size);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l1 = comp_next_label(comp);
int success_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
comp->except_nest_level += 1; // for correct handling of continue
EMIT(setup_except, l1);
compile_node(comp, pn_body); // body
EMIT(pop_block);
EMIT(jump, success_label);
EMIT(label_assign, l1);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l2 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n_except; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t*)pn_excepts[i];
Initial commit.
2013-10-04 14:53:11 -04:00
qstr qstr_exception_local = 0;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int end_finally_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this is a catch all exception handler
if (i + 1 != n_except) {
printf("SyntaxError: default 'except:' must be last\n");
return;
}
} else {
// this exception handler requires a match to a certain type of exception
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_parse_node_t pns_exception_expr = pns_except->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns_exception_expr;
if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
Initial commit.
2013-10-04 14:53:11 -04:00
// handler binds the exception to a local
pns_exception_expr = pns3->nodes[0];
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
qstr_exception_local = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
EMIT(dup_top);
compile_node(comp, pns_exception_expr);
EMIT(compare_op, RT_COMPARE_OP_EXCEPTION_MATCH);
EMIT(pop_jump_if_false, end_finally_label);
}
EMIT(pop_top);
if (qstr_exception_local == 0) {
EMIT(pop_top);
} else {
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, qstr_exception_local);
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(pop_top);
Fix a few compiler warnings.
2013-12-20 09:22:59 -05:00
int l3 = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
if (qstr_exception_local != 0) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l3 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(setup_finally, l3);
}
compile_node(comp, pns_except->nodes[1]);
if (qstr_exception_local != 0) {
EMIT(pop_block);
}
EMIT(pop_except);
if (qstr_exception_local != 0) {
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, l3);
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, qstr_exception_local);
EMIT(delete_id, qstr_exception_local);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(end_finally);
}
EMIT(jump, l2);
EMIT(label_assign, end_finally_label);
}
EMIT(end_finally);
EMIT(label_assign, success_label);
comp->except_nest_level -= 1;
compile_node(comp, pn_else); // else block, can be null
EMIT(label_assign, l2);
EMIT(set_stack_size, stack_size);
}
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
void compile_try_finally(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_except, mp_parse_node_t pn_else, mp_parse_node_t pn_finally) {
Initial commit.
2013-10-04 14:53:11 -04:00
// don't understand how the stack works with exceptions, so we force it to return to the correct value
int stack_size = EMIT(get_stack_size);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_finally_block = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(setup_finally, l_finally_block);
if (n_except == 0) {
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
assert(MP_PARSE_NODE_IS_NULL(pn_else));
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn_body);
} else {
compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
}
EMIT(pop_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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, l_finally_block);
compile_node(comp, pn_finally);
EMIT(end_finally);
EMIT(set_stack_size, stack_size);
}
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
void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
Initial commit.
2013-10-04 14:53:11 -04:00
// just try-finally
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
compile_try_finally(comp, pns->nodes[0], 0, NULL, MP_PARSE_NODE_NULL, pns2->nodes[0]);
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
Initial commit.
2013-10-04 14:53:11 -04:00
// try-except and possibly else and/or finally
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_parse_node_t *pn_excepts;
Initial commit.
2013-10-04 14:53:11 -04:00
int n_except = list_get(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// no finally
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
} else {
// have finally
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
compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// just try-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
mp_parse_node_t *pn_excepts;
Initial commit.
2013-10-04 14:53:11 -04:00
int n_except = list_get(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
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
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// shouldn't happen
assert(0);
}
}
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
void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (n == 0) {
// no more pre-bits, compile the body of the with
compile_node(comp, body);
} else {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this pre-bit is of the form "a as b"
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_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(setup_with, l_end);
c_assign(comp, pns->nodes[1], ASSIGN_STORE);
} else {
// this pre-bit is just an expression
compile_node(comp, nodes[0]);
EMIT(setup_with, l_end);
EMIT(pop_top);
}
// compile additional pre-bits and the body
compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
// finish this with block
EMIT(pop_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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, l_end);
EMIT(with_cleanup);
EMIT(end_finally);
}
}
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
void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
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_parse_node_t *nodes;
Initial commit.
2013-10-04 14:53:11 -04:00
int n = list_get(&pns->nodes[0], PN_with_stmt_list, &nodes);
assert(n > 0);
// compile in a nested fashion
compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
}
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
void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (comp->is_repl && comp->scope_cur->kind == SCOPE_MODULE) {
// for REPL, evaluate then print the expression
EMIT(load_id, qstr_from_str_static("__repl_print__"));
compile_node(comp, pns->nodes[0]);
EMIT(call_function, 1, 0, false, false);
EMIT(pop_top);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
Implement REPL.
2013-10-18 14:58:12 -04:00
// for non-REPL, evaluate then discard the expression
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
Implement REPL.
2013-10-18 14:58:12 -04:00
// do nothing with a lonely constant
} else {
compile_node(comp, pns->nodes[0]); // just an expression
EMIT(pop_top); // discard last result since this is a statement and leaves nothing on the stack
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
} 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
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
if (kind == PN_expr_stmt_augassign) {
c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
compile_node(comp, pns1->nodes[1]); // rhs
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
assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
// note that we don't really need to implement separate inplace ops, just normal binary ops will suffice
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
switch (MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
case MP_TOKEN_DEL_PIPE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_OR); break;
case MP_TOKEN_DEL_CARET_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_XOR); break;
case MP_TOKEN_DEL_AMPERSAND_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_AND); break;
case MP_TOKEN_DEL_DBL_LESS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_LSHIFT); break;
case MP_TOKEN_DEL_DBL_MORE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_RSHIFT); break;
case MP_TOKEN_DEL_PLUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_ADD); break;
case MP_TOKEN_DEL_MINUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_SUBTRACT); break;
case MP_TOKEN_DEL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MULTIPLY); break;
case MP_TOKEN_DEL_DBL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_FLOOR_DIVIDE); break;
case MP_TOKEN_DEL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_TRUE_DIVIDE); break;
case MP_TOKEN_DEL_PERCENT_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MODULO); break;
case MP_TOKEN_DEL_DBL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_POWER); break;
Initial commit.
2013-10-04 14:53:11 -04:00
default: assert(0); // shouldn't happen
}
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
} else if (kind == PN_expr_stmt_assign_list) {
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
int rhs = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
compile_node(comp, ((mp_parse_node_struct_t*)pns1->nodes[rhs])->nodes[0]); // rhs
Initial commit.
2013-10-04 14:53:11 -04:00
// following CPython, we store left-most first
if (rhs > 0) {
EMIT(dup_top);
}
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
for (int i = 0; i < rhs; i++) {
if (i + 1 < rhs) {
EMIT(dup_top);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
c_assign(comp, ((mp_parse_node_struct_t*)pns1->nodes[i])->nodes[0], ASSIGN_STORE); // middle store
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else if (kind == PN_expr_stmt_assign) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns1->nodes[0]) == 2
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 2) {
Initial commit.
2013-10-04 14:53:11 -04:00
// optimisation for a, b = c, d; to match CPython's optimisation
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_parse_node_struct_t* pns10 = (mp_parse_node_struct_t*)pns1->nodes[0];
mp_parse_node_struct_t* pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns10->nodes[0]); // rhs
compile_node(comp, pns10->nodes[1]); // rhs
EMIT(rot_two);
c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns1->nodes[0]) == 3
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 3) {
Initial commit.
2013-10-04 14:53:11 -04:00
// optimisation for a, b, c = d, e, f; to match CPython's optimisation
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_parse_node_struct_t* pns10 = (mp_parse_node_struct_t*)pns1->nodes[0];
mp_parse_node_struct_t* pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns10->nodes[0]); // rhs
compile_node(comp, pns10->nodes[1]); // rhs
compile_node(comp, pns10->nodes[2]); // rhs
EMIT(rot_three);
EMIT(rot_two);
c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
c_assign(comp, pns0->nodes[2], ASSIGN_STORE); // lhs store
} else {
compile_node(comp, pns1->nodes[0]); // rhs
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
}
} else {
// shouldn't happen
assert(0);
}
}
}
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
void c_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns, rt_binary_op_t binary_op) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
for (int i = 1; i < num_nodes; i += 1) {
compile_node(comp, pns->nodes[i]);
EMIT(binary_op, binary_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
void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
int stack_size = EMIT(get_stack_size);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_fail = comp_next_label(comp);
int l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
compile_node(comp, pns->nodes[0]); // success value
EMIT(jump, l_end);
EMIT(label_assign, l_fail);
EMIT(set_stack_size, stack_size); // force stack size reset
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
EMIT(label_assign, l_end);
}
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
void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO default params etc for lambda; possibly just use funcdef code
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_parse_node_t pn_params = pns->nodes[0];
//mp_parse_node_t pn_body = pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
// create a new scope for this lambda
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
scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the lambda scope so the compiling function (this one) can use it at each pass
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
pns->nodes[2] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// get the scope for this lambda
scope_t *this_scope = (scope_t*)pns->nodes[2];
// make the lambda
close_over_variables_etc(comp, this_scope, 0, 0);
}
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
void compile_or_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i += 1) {
compile_node(comp, pns->nodes[i]);
if (i + 1 < n) {
EMIT(jump_if_true_or_pop, l_end);
}
}
EMIT(label_assign, l_end);
}
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
void compile_and_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i += 1) {
compile_node(comp, pns->nodes[i]);
if (i + 1 < n) {
EMIT(jump_if_false_or_pop, l_end);
}
}
EMIT(label_assign, l_end);
}
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
void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(unary_op, RT_UNARY_OP_NOT);
}
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
void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
int stack_size = EMIT(get_stack_size);
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
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
bool multi = (num_nodes > 3);
int l_fail = 0;
if (multi) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
}
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
if (i + 2 < num_nodes) {
EMIT(dup_top);
EMIT(rot_three);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_LESS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_LESS);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MORE)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_MORE);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_EQUAL)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_EQUAL);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_LESS_EQUAL)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_LESS_EQUAL);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MORE_EQUAL)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_MORE_EQUAL);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_NOT_EQUAL)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_NOT_EQUAL);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_KW_IN)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_IN);
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
} else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[i];
int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
Initial commit.
2013-10-04 14:53:11 -04:00
if (kind == PN_comp_op_not_in) {
EMIT(compare_op, RT_COMPARE_OP_NOT_IN);
} else if (kind == PN_comp_op_is) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(compare_op, RT_COMPARE_OP_IS);
} else {
EMIT(compare_op, RT_COMPARE_OP_IS_NOT);
}
} else {
// shouldn't happen
assert(0);
}
} else {
// shouldn't happen
assert(0);
}
if (i + 2 < num_nodes) {
EMIT(jump_if_false_or_pop, l_fail);
}
}
if (multi) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(jump, l_end);
EMIT(label_assign, l_fail);
EMIT(rot_two);
EMIT(pop_top);
EMIT(label_assign, l_end);
EMIT(set_stack_size, stack_size + 1); // force stack size
}
}
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
void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO
assert(0);
compile_node(comp, pns->nodes[0]);
//EMIT(unary_op, "UNARY_STAR");
}
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
void compile_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
c_binary_op(comp, pns, RT_BINARY_OP_OR);
}
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
void compile_xor_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
c_binary_op(comp, pns, RT_BINARY_OP_XOR);
}
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
void compile_and_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
c_binary_op(comp, pns, RT_BINARY_OP_AND);
}
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
void compile_shift_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_LESS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_LSHIFT);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_MORE)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_RSHIFT);
} else {
// shouldn't happen
assert(0);
}
}
}
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
void compile_arith_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PLUS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_ADD);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MINUS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_SUBTRACT);
} else {
// shouldn't happen
assert(0);
}
}
}
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
void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_STAR)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_MULTIPLY);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_SLASH)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_FLOOR_DIVIDE);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_SLASH)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_TRUE_DIVIDE);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PERCENT)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(binary_op, RT_BINARY_OP_MODULO);
} else {
// shouldn't happen
assert(0);
}
}
}
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
void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[1]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(unary_op, RT_UNARY_OP_POSITIVE);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(unary_op, RT_UNARY_OP_NEGATIVE);
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
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)) {
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(unary_op, RT_UNARY_OP_INVERT);
} else {
// shouldn't happen
assert(0);
}
}
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
void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool is_method_call) {
Initial commit.
2013-10-04 14:53:11 -04:00
// function to call is on top of stack
int old_n_arg_keyword = comp->n_arg_keyword;
bool old_have_star_arg = comp->have_star_arg;
bool old_have_dbl_star_arg = comp->have_dbl_star_arg;
comp->n_arg_keyword = 0;
comp->have_star_arg = false;
comp->have_dbl_star_arg = false;
compile_node(comp, pns->nodes[0]); // arguments to function call; can be null
// compute number of positional arguments
int n_positional = list_len(pns->nodes[0], PN_arglist) - comp->n_arg_keyword;
if (comp->have_star_arg) {
n_positional -= 1;
}
if (comp->have_dbl_star_arg) {
n_positional -= 1;
}
if (is_method_call) {
EMIT(call_method, n_positional, comp->n_arg_keyword, comp->have_star_arg, comp->have_dbl_star_arg);
} else {
EMIT(call_function, n_positional, comp->n_arg_keyword, comp->have_star_arg, comp->have_dbl_star_arg);
}
comp->n_arg_keyword = old_n_arg_keyword;
comp->have_star_arg = old_have_star_arg;
comp->have_dbl_star_arg = old_have_dbl_star_arg;
}
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
void compile_power_trailers(compiler_t *comp, mp_parse_node_struct_t *pns) {
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < num_nodes; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (i + 1 < num_nodes && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i], PN_trailer_period) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i + 1], PN_trailer_paren)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// optimisation for method calls a.f(...), following PyPy
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_parse_node_struct_t *pns_period = (mp_parse_node_struct_t*)pns->nodes[i];
mp_parse_node_struct_t *pns_paren = (mp_parse_node_struct_t*)pns->nodes[i + 1];
EMIT(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0])); // get the method
Initial commit.
2013-10-04 14:53:11 -04:00
compile_trailer_paren_helper(comp, pns_paren, true);
i += 1;
} else {
compile_node(comp, pns->nodes[i]);
}
}
}
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
void compile_power_dbl_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(binary_op, RT_BINARY_OP_POWER);
}
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
void compile_atom_string(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a list of strings
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
// check type of list (string or bytes) and count total number of bytes
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
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
int n_bytes = 0;
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
int string_kind = MP_PARSE_NODE_NULL;
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
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
assert(MP_PARSE_NODE_IS_LEAF(pns->nodes[i]));
int pn_kind = MP_PARSE_NODE_LEAF_KIND(pns->nodes[i]);
assert(pn_kind == MP_PARSE_NODE_STRING || pn_kind == MP_PARSE_NODE_BYTES);
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
if (i == 0) {
string_kind = pn_kind;
} else if (pn_kind != string_kind) {
printf("SyntaxError: cannot mix bytes and nonbytes literals\n");
return;
}
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
const char *str = qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
n_bytes += strlen(str);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
// allocate memory for concatenated string/bytes
char *cat_str = m_new(char, n_bytes + 1);
// concatenate string/bytes
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
char *s_dest = cat_str;
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
for (int i = 0; i < n; i++) {
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
const char *s = qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
size_t s_len = strlen(s);
memcpy(s_dest, s, s_len);
s_dest += s_len;
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
}
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
*s_dest = '\0';
py: compiler supports string juxtaposition=concatenation.
2013-12-10 12:41:49 -05:00
Change memory allocation API to require size for free and realloc.
2013-12-29 14:33:23 -05:00
EMIT(load_const_str, qstr_from_str_take(cat_str, n_bytes + 1), string_kind == MP_PARSE_NODE_BYTES);
Initial commit.
2013-10-04 14:53:11 -04:00
}
// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
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
void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
// create a new scope for this comprehension
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
scope_t *s = scope_new_and_link(comp, kind, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the comprehension scope so the compiling function (this one) can use it at each pass
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
pns_comp_for->nodes[3] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// get the scope for this comprehension
scope_t *this_scope = (scope_t*)pns_comp_for->nodes[3];
// compile the comprehension
close_over_variables_etc(comp, this_scope, 0, 0);
compile_node(comp, pns_comp_for->nodes[1]); // source of the iterator
EMIT(get_iter);
EMIT(call_function, 1, 0, false, false);
}
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
void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// an empty tuple
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
c_tuple(comp, MP_PARSE_NODE_NULL, NULL);
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
pns = (mp_parse_node_struct_t*)pns->nodes[0];
assert(!MP_PARSE_NODE_IS_NULL(pns->nodes[1]));
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// tuple of one item, with trailing comma
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
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
c_tuple(comp, pns->nodes[0], NULL);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// tuple of many items
c_tuple(comp, pns->nodes[0], pns2);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// generator expression
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
} else {
// tuple with 2 items
goto tuple_with_2_items;
}
} else {
// tuple with 2 items
tuple_with_2_items:
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
c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// parenthesis around a single item, is just that item
compile_node(comp, pns->nodes[0]);
}
}
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
void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty list
EMIT(build_list, 0);
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns2->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list of one item, with trailing comma
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
assert(MP_PARSE_NODE_IS_NULL(pns3->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns2->nodes[0]);
EMIT(build_list, 1);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list of many items
compile_node(comp, pns2->nodes[0]);
compile_generic_all_nodes(comp, pns3);
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
EMIT(build_list, 1 + MP_PARSE_NODE_STRUCT_NUM_NODES(pns3));
} else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list comprehension
compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
} else {
// list with 2 items
goto list_with_2_items;
}
} else {
// list with 2 items
list_with_2_items:
compile_node(comp, pns2->nodes[0]);
compile_node(comp, pns2->nodes[1]);
EMIT(build_list, 2);
}
} else {
// list with 1 item
compile_node(comp, pns->nodes[0]);
EMIT(build_list, 1);
}
}
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
void compile_atom_brace(compiler_t *comp, mp_parse_node_struct_t *pns) {
mp_parse_node_t pn = pns->nodes[0];
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty dict
EMIT(build_map, 0);
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
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
Initial commit.
2013-10-04 14:53:11 -04:00
// dict with one element
EMIT(build_map, 1);
compile_node(comp, pn);
EMIT(store_map);
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
Initial commit.
2013-10-04 14:53:11 -04:00
// dict/set with multiple elements
// get tail elements (2nd, 3rd, ...)
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_parse_node_t *nodes;
Initial commit.
2013-10-04 14:53:11 -04:00
int n = list_get(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
// first element sets whether it's a dict or set
bool is_dict;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a dictionary
EMIT(build_map, 1 + n);
compile_node(comp, pns->nodes[0]);
EMIT(store_map);
is_dict = true;
} else {
// a set
compile_node(comp, pns->nodes[0]); // 1st value of set
is_dict = false;
}
// process rest of elements
for (int i = 0; i < n; i++) {
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_parse_node_t pn = nodes[i];
bool is_key_value = MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dictorsetmaker_item);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn);
if (is_dict) {
if (!is_key_value) {
printf("SyntaxError?: expecting key:value for dictionary");
return;
}
EMIT(store_map);
} else {
if (is_key_value) {
printf("SyntaxError?: expecting just a value for set");
return;
}
}
}
// if it's a set, build it
if (!is_dict) {
EMIT(build_set, 1 + n);
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// dict/set comprehension
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a dictionary comprehension
compile_comprehension(comp, pns, SCOPE_DICT_COMP);
} else {
// a set comprehension
compile_comprehension(comp, pns, SCOPE_SET_COMP);
}
} else {
// shouldn't happen
assert(0);
}
} else {
// set with one element
goto set_with_one_element;
}
} else {
// set with one element
set_with_one_element:
compile_node(comp, pn);
EMIT(build_set, 1);
}
}
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
void compile_trailer_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_trailer_paren_helper(comp, pns, false);
}
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
void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// object who's index we want is on top of stack
compile_node(comp, pns->nodes[0]); // the index
EMIT(binary_op, RT_BINARY_OP_SUBSCR);
}
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
void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// object who's attribute we want is on top of stack
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
EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // attribute to get
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_subscript_3_helper(compiler_t *comp, mp_parse_node_struct_t *pns) {
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
mp_parse_node_t pn = pns->nodes[0];
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?:]
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(build_slice, 2);
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
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
pn = pns->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?::]
EMIT(build_slice, 2);
} else {
// [?::x]
compile_node(comp, pn);
EMIT(build_slice, 3);
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
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
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
pns = (mp_parse_node_struct_t*)pns->nodes[1];
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?:x:]
EMIT(build_slice, 2);
} else {
// [?:x:x]
compile_node(comp, pns->nodes[0]);
EMIT(build_slice, 3);
}
} else {
// [?:x]
compile_node(comp, pn);
EMIT(build_slice, 2);
}
} else {
// [?:x]
compile_node(comp, pn);
EMIT(build_slice, 2);
}
}
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
void compile_subscript_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]); // start of slice
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
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
compile_subscript_3_helper(comp, (mp_parse_node_struct_t*)pns->nodes[1]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_subscript_3(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_subscript_3_helper(comp, pns);
}
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
void compile_dictorsetmaker_item(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// if this is called then we are compiling a dict key:value pair
compile_node(comp, pns->nodes[1]); // value
compile_node(comp, pns->nodes[0]); // key
}
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
void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr cname = compile_classdef_helper(comp, pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store class object into class name
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, cname);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
void compile_arglist_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->have_star_arg) {
printf("SyntaxError?: can't have multiple *x\n");
return;
}
comp->have_star_arg = true;
compile_node(comp, pns->nodes[0]);
}
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
void compile_arglist_dbl_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->have_dbl_star_arg) {
printf("SyntaxError?: can't have multiple **x\n");
return;
}
comp->have_dbl_star_arg = true;
compile_node(comp, pns->nodes[0]);
}
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
void compile_argument(compiler_t *comp, mp_parse_node_struct_t *pns) {
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_argument_3) {
if (!MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
printf("SyntaxError?: lhs of keyword argument must be an id\n");
return;
}
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
EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns2->nodes[0]);
comp->n_arg_keyword += 1;
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
} else {
// shouldn't happen
assert(0);
}
}
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
void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
printf("SyntaxError: 'yield' outside function\n");
return;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(yield_value);
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
pns = (mp_parse_node_struct_t*)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(get_iter);
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(yield_from);
} else {
compile_node(comp, pns->nodes[0]);
EMIT(yield_value);
}
}
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
typedef void (*compile_function_t)(compiler_t*, mp_parse_node_struct_t*);
Initial commit.
2013-10-04 14:53:11 -04:00
static compile_function_t compile_function[] = {
NULL,
#define nc NULL
#define c(f) compile_##f
#define DEF_RULE(rule, comp, kind, arg...) comp,
#include "grammar.h"
#undef nc
#undef c
#undef DEF_RULE
};
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
void compile_node(compiler_t *comp, mp_parse_node_t pn) {
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// pass
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
} else if (MP_PARSE_NODE_IS_LEAF(pn)) {
int arg = MP_PARSE_NODE_LEAF_ARG(pn);
switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
case MP_PARSE_NODE_ID: EMIT(load_id, arg); break;
case MP_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break;
case MP_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break;
case MP_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break;
case MP_PARSE_NODE_STRING: EMIT(load_const_str, arg, false); break;
case MP_PARSE_NODE_BYTES: EMIT(load_const_str, arg, true); break;
case MP_PARSE_NODE_TOKEN:
if (arg == MP_TOKEN_NEWLINE) {
Improve indent/dedent error checking and reporting.
2013-10-09 10:09:52 -04:00
// this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
Implement REPL.
2013-10-18 14:58:12 -04:00
// or when single_input lets through a NEWLINE (user enters a blank line)
Improve indent/dedent error checking and reporting.
2013-10-09 10:09:52 -04:00
// do nothing
} else {
EMIT(load_const_tok, arg);
}
break;
Initial commit.
2013-10-04 14:53:11 -04:00
default: assert(0);
}
} 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
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
Initial commit.
2013-10-04 14:53:11 -04:00
if (f == NULL) {
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
printf("node %u cannot be compiled\n", (uint)MP_PARSE_NODE_STRUCT_KIND(pns));
mp_parse_node_show(pn, 0);
Initial commit.
2013-10-04 14:53:11 -04:00
assert(0);
} else {
f(comp, pns);
}
}
}
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
void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_name, pn_kind_t pn_star, pn_kind_t pn_dbl_star, bool allow_annotations) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO verify that *k and **k are last etc
qstr param_name = 0;
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_parse_node_t pn_annotation = MP_PARSE_NODE_NULL;
if (MP_PARSE_NODE_IS_ID(pn)) {
param_name = MP_PARSE_NODE_LEAF_ARG(pn);
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->have_bare_star) {
// comes after a bare star, so doesn't count as a parameter
} else {
comp->scope_cur->num_params += 1;
}
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
} 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
assert(MP_PARSE_NODE_IS_STRUCT(pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
//int node_index = 1; unused
if (allow_annotations) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// this parameter has an annotation
pn_annotation = pns->nodes[1];
}
//node_index = 2; unused
}
/* this is obsolete now that num dict/default params are calculated in compile_funcdef_param
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[node_index])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// this parameter has a default value
if (comp->have_bare_star) {
comp->scope_cur->num_dict_params += 1;
} else {
comp->scope_cur->num_default_params += 1;
}
}
*/
if (comp->have_bare_star) {
// comes after a bare star, so doesn't count as a parameter
} else {
comp->scope_cur->num_params += 1;
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// bare star
// TODO see http://www.python.org/dev/peps/pep-3102/
comp->have_bare_star = true;
//assert(comp->scope_cur->num_dict_params == 0);
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
} else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// named star
comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
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
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
} else if (allow_annotations && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// named star with annotation
comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
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
pns = (mp_parse_node_struct_t*)pns->nodes[0];
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
pn_annotation = pns->nodes[1];
} else {
// shouldn't happen
assert(0);
}
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
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star) {
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
if (allow_annotations && !MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// this parameter has an annotation
pn_annotation = pns->nodes[1];
}
comp->scope_cur->flags |= SCOPE_FLAG_VARKEYWORDS;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// TODO anything to implement?
Initial commit.
2013-10-04 14:53:11 -04:00
assert(0);
}
}
if (param_name != 0) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO this parameter has an annotation
}
bool added;
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, &added);
if (!added) {
printf("SyntaxError?: same name used for parameter; %s\n", qstr_str(param_name));
return;
}
id_info->param = true;
id_info->kind = ID_INFO_KIND_LOCAL;
}
}
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
void compile_scope_func_param(compiler_t *comp, mp_parse_node_t pn) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star, true);
}
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
void compile_scope_lambda_param(compiler_t *comp, mp_parse_node_t pn) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star, false);
}
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
void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_t pn_iter, mp_parse_node_t pn_inner_expr, int l_top, int for_depth) {
Initial commit.
2013-10-04 14:53:11 -04:00
tail_recursion:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// no more nested if/for; compile inner expression
compile_node(comp, pn_inner_expr);
if (comp->scope_cur->kind == SCOPE_LIST_COMP) {
EMIT(list_append, for_depth + 2);
} else if (comp->scope_cur->kind == SCOPE_DICT_COMP) {
EMIT(map_add, for_depth + 2);
} else if (comp->scope_cur->kind == SCOPE_SET_COMP) {
EMIT(set_add, for_depth + 2);
} else {
EMIT(yield_value);
EMIT(pop_top);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_if)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// if condition
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_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t*)pn_iter;
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
pn_iter = pns_comp_if->nodes[1];
goto tail_recursion;
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_for)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// for loop
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_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t*)pn_iter;
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns_comp_for2->nodes[1]);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end2 = comp_next_label(comp);
int l_top2 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(get_iter);
EMIT(label_assign, l_top2);
EMIT(for_iter, l_end2);
c_assign(comp, pns_comp_for2->nodes[0], ASSIGN_STORE);
compile_scope_comp_iter(comp, pns_comp_for2->nodes[2], pn_inner_expr, l_top2, for_depth + 1);
EMIT(jump, l_top2);
EMIT(label_assign, l_end2);
EMIT(for_iter_end);
} else {
// shouldn't happen
assert(0);
}
}
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
void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
Initial commit.
2013-10-04 14:53:11 -04:00
// see http://www.python.org/dev/peps/pep-0257/
// look for the first statement
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// a statement; fall through
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// file input; find the first non-newline node
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_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
for (int i = 0; i < num_nodes; i++) {
pn = pns->nodes[i];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!(MP_PARSE_NODE_IS_LEAF(pn) && MP_PARSE_NODE_LEAF_KIND(pn) == MP_PARSE_NODE_TOKEN && MP_PARSE_NODE_LEAF_ARG(pn) == MP_TOKEN_NEWLINE)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// not a newline, so this is the first statement; finish search
break;
}
}
// if we didn't find a non-newline then it's okay to fall through; pn will be a newline and so doc-string test below will fail gracefully
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
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// a list of statements; get the first one
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
pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
return;
}
// check the first statement for a doc string
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
mp_parse_node_struct_t* pns = (mp_parse_node_struct_t*)pn;
if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
int kind = MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]);
if (kind == MP_PARSE_NODE_STRING) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]); // a doc string
// store doc string
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, comp->qstr___doc__);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
}
void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
comp->pass = pass;
comp->scope_cur = scope;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
comp->next_label = 1;
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
EMIT(start_pass, pass, scope);
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
scope->stack_size = 0;
}
Implement REPL.
2013-10-18 14:58:12 -04:00
#if MICROPY_EMIT_CPYTHON
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_3) {
scope_print_info(scope);
}
Implement REPL.
2013-10-18 14:58:12 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
// compile
if (scope->kind == SCOPE_MODULE) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (!comp->is_repl) {
check_for_doc_string(comp, scope->pn);
}
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, scope->pn);
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(return_value);
} else if (scope->kind == SCOPE_FUNCTION) {
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
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Initial commit.
2013-10-04 14:53:11 -04:00
// work out number of parameters, keywords and default parameters, and add them to the id_info array
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
comp->have_bare_star = false;
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
}
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
assert(MP_PARSE_NODE_IS_NULL(pns->nodes[2])); // 2 is something...
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[3]); // 3 is function body
// emit return if it wasn't the last opcode
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) {
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(return_value);
}
} else if (scope->kind == SCOPE_LAMBDA) {
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
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
Initial commit.
2013-10-04 14:53:11 -04:00
// work out number of parameters, keywords and default parameters, and add them to the id_info array
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
comp->have_bare_star = false;
apply_to_single_or_list(comp, pns->nodes[0], PN_varargslist, compile_scope_lambda_param);
}
compile_node(comp, pns->nodes[1]); // 1 is lambda body
EMIT(return_value);
} else if (scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
// a bit of a hack at the moment
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
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr qstr_arg = qstr_from_str_static(".0");
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
bool added;
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qstr_arg, &added);
assert(added);
id_info->kind = ID_INFO_KIND_LOCAL;
scope->num_params = 1;
}
if (scope->kind == SCOPE_LIST_COMP) {
EMIT(build_list, 0);
} else if (scope->kind == SCOPE_DICT_COMP) {
EMIT(build_map, 0);
} else if (scope->kind == SCOPE_SET_COMP) {
EMIT(build_set, 0);
}
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
int l_end = comp_next_label(comp);
int l_top = comp_next_label(comp);
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(load_id, qstr_arg);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(label_assign, l_top);
EMIT(for_iter, l_end);
c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
compile_scope_comp_iter(comp, pns_comp_for->nodes[2], pns->nodes[0], l_top, 0);
EMIT(jump, l_top);
EMIT(label_assign, l_end);
EMIT(for_iter_end);
if (scope->kind == SCOPE_GEN_EXPR) {
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(return_value);
} else {
assert(scope->kind == SCOPE_CLASS);
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
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
Initial commit.
2013-10-04 14:53:11 -04:00
if (comp->pass == PASS_1) {
bool added;
id_info_t *id_info = scope_find_or_add_id(scope, comp->qstr___class__, &added);
assert(added);
id_info->kind = ID_INFO_KIND_LOCAL;
id_info = scope_find_or_add_id(scope, comp->qstr___locals__, &added);
assert(added);
id_info->kind = ID_INFO_KIND_LOCAL;
id_info->param = true;
scope->num_params = 1; // __locals__ is the parameter
}
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(load_id, comp->qstr___locals__);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(store_locals);
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(load_id, comp->qstr___name__);
EMIT(store_id, comp->qstr___module__);
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
EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
Factorise EMIT_COMMON calls, mostly into emit_pass1.
2013-10-05 09:17:09 -04:00
EMIT(store_id, comp->qstr___qualname__);
Initial commit.
2013-10-04 14:53:11 -04:00
check_for_doc_string(comp, pns->nodes[2]);
compile_node(comp, pns->nodes[2]); // 2 is class body
id_info_t *id = scope_find(scope, comp->qstr___class__);
assert(id != NULL);
if (id->kind == ID_INFO_KIND_LOCAL) {
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
EMIT(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: make closures work.
2013-12-30 17:32:17 -05:00
#if MICROPY_EMIT_CPYTHON
Add local_num skeleton framework to deref/closure emit calls.
2013-10-20 10:07:49 -04:00
EMIT(load_closure, comp->qstr___class__, 0); // XXX check this is the correct local num
py: make closures work.
2013-12-30 17:32:17 -05:00
#else
EMIT(load_fast, comp->qstr___class__, 0); // XXX check this is the correct local num
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(return_value);
}
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
EMIT(end_pass);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
comp->pass = pass;
comp->scope_cur = scope;
comp->next_label = 1;
if (scope->kind != SCOPE_FUNCTION) {
printf("Error: inline assembler must be a function\n");
return;
}
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
if (comp->pass > PASS_1) {
EMIT_INLINE_ASM(start_pass, comp->pass, comp->scope_cur);
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// get the function definition parse node
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
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
//qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
// parameters are in pns->nodes[1]
if (comp->pass == PASS_2) {
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_parse_node_t *pn_params;
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
int n_params = list_get(&pns->nodes[1], PN_typedargslist, &pn_params);
scope->num_params = EMIT_INLINE_ASM(count_params, n_params, pn_params);
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pns->nodes[2])); // type
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t pn_body = pns->nodes[3]; // body
mp_parse_node_t *nodes;
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
int num = list_get(&pn_body, PN_suite_block_stmts, &nodes);
if (comp->pass == PASS_3) {
//printf("----\n");
scope_print_info(scope);
}
for (int i = 0; i < num; i++) {
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
assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)nodes[i];
assert(MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_expr_stmt);
assert(MP_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[1]));
pns2 = (mp_parse_node_struct_t*)pns2->nodes[0];
assert(MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_power);
assert(MP_PARSE_NODE_IS_ID(pns2->nodes[0]));
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns2->nodes[1], PN_trailer_paren));
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[2]));
qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
pns2 = (mp_parse_node_struct_t*)pns2->nodes[1]; // PN_trailer_paren
mp_parse_node_t *pn_arg;
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
int n_args = list_get(&pns2->nodes[0], PN_arglist, &pn_arg);
// emit instructions
if (strcmp(qstr_str(op), "label") == 0) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
printf("SyntaxError: inline assembler 'label' requires 1 argument\n");
return;
}
int lab = comp_next_label(comp);
if (pass > PASS_1) {
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
EMIT_INLINE_ASM(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]));
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
} else {
if (pass > PASS_1) {
EMIT_INLINE_ASM(op, op, n_args, pn_arg);
}
}
}
if (comp->pass > PASS_1) {
EMIT_INLINE_ASM(end_pass);
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
void compile_scope_compute_things(compiler_t *comp, scope_t *scope) {
// in functions, turn implicit globals into explicit globals
py: make closures work.
2013-12-30 17:32:17 -05:00
// compute the index of each local
Initial commit.
2013-10-04 14:53:11 -04:00
scope->num_locals = 0;
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
if (scope->kind == SCOPE_CLASS && id->qstr == comp->qstr___class__) {
// __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL
continue;
}
if (scope->kind >= SCOPE_FUNCTION && scope->kind <= SCOPE_GEN_EXPR && id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
}
py: work towards working closures.
2013-12-10 19:41:43 -05:00
// note: params always count for 1 local, even if they are a cell
Initial commit.
2013-10-04 14:53:11 -04:00
if (id->param || id->kind == ID_INFO_KIND_LOCAL) {
id->local_num = scope->num_locals;
scope->num_locals += 1;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
}
}
// compute the index of cell vars (freevars[idx] in CPython)
py: make closures work.
2013-12-30 17:32:17 -05:00
#if MICROPY_EMIT_CPYTHON
int num_cell = 0;
#endif
py: work towards working closures.
2013-12-10 19:41:43 -05:00
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
py: make closures work.
2013-12-30 17:32:17 -05:00
#if MICROPY_EMIT_CPYTHON
// in CPython the cells are numbered starting from 0
py: work towards working closures.
2013-12-10 19:41:43 -05:00
if (id->kind == ID_INFO_KIND_CELL) {
py: make closures work.
2013-12-30 17:32:17 -05:00
id->local_num = num_cell;
num_cell += 1;
}
#else
// in Micro Python the cells come right after the fast locals
// parameters are not counted here, since they remain at the start
// of the locals, even if they are cell vars
if (!id->param && id->kind == ID_INFO_KIND_CELL) {
id->local_num = scope->num_locals;
scope->num_locals += 1;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
}
py: make closures work.
2013-12-30 17:32:17 -05:00
#endif
py: work towards working closures.
2013-12-10 19:41:43 -05:00
}
// compute the index of free vars (freevars[idx] in CPython)
// make sure they are in the order of the parent scope
if (scope->parent != NULL) {
int num_free = 0;
for (int i = 0; i < scope->parent->id_info_len; i++) {
id_info_t *id = &scope->parent->id_info[i];
if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
for (int j = 0; j < scope->id_info_len; j++) {
id_info_t *id2 = &scope->id_info[j];
if (id2->kind == ID_INFO_KIND_FREE && id->qstr == id2->qstr) {
py: make closures work.
2013-12-30 17:32:17 -05:00
assert(!id2->param); // free vars should not be params
#if MICROPY_EMIT_CPYTHON
// in CPython the frees are numbered after the cells
id2->local_num = num_cell + num_free;
#else
// in Micro Python the frees come first, before the params
id2->local_num = num_free;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
#endif
num_free += 1;
}
}
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: make closures work.
2013-12-30 17:32:17 -05:00
#if !MICROPY_EMIT_CPYTHON
// in Micro Python shift all other locals after the free locals
if (num_free > 0) {
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
if (id->param || id->kind != ID_INFO_KIND_FREE) {
id->local_num += num_free;
}
}
scope->num_params += num_free; // free vars are counted as params for passing them into the function
scope->num_locals += num_free;
}
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
// compute flags
//scope->flags = 0; since we set some things in parameters
if (scope->kind != SCOPE_MODULE) {
scope->flags |= SCOPE_FLAG_NEWLOCALS;
}
if (scope->kind == SCOPE_FUNCTION || scope->kind == SCOPE_LAMBDA || scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
assert(scope->parent != NULL);
scope->flags |= SCOPE_FLAG_OPTIMISED;
// TODO possibly other ways it can be nested
if (scope->parent->kind == SCOPE_FUNCTION || (scope->parent->kind == SCOPE_CLASS && scope->parent->parent->kind == SCOPE_FUNCTION)) {
scope->flags |= SCOPE_FLAG_NESTED;
}
}
int num_free = 0;
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
num_free += 1;
}
}
if (num_free == 0) {
scope->flags |= SCOPE_FLAG_NOFREE;
}
}
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
mp_obj_t mp_compile(mp_parse_node_t pn, bool is_repl) {
Initial commit.
2013-10-04 14:53:11 -04:00
compiler_t *comp = m_new(compiler_t, 1);
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
comp->qstr___class__ = qstr_from_str_static("__class__");
comp->qstr___locals__ = qstr_from_str_static("__locals__");
comp->qstr___name__ = qstr_from_str_static("__name__");
comp->qstr___module__ = qstr_from_str_static("__module__");
comp->qstr___qualname__ = qstr_from_str_static("__qualname__");
comp->qstr___doc__ = qstr_from_str_static("__doc__");
comp->qstr_assertion_error = qstr_from_str_static("AssertionError");
comp->qstr_micropython = qstr_from_str_static("micropython");
Implement REPL.
2013-10-18 14:58:12 -04:00
comp->qstr_byte_code = qstr_from_str_static("byte_code");
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
comp->qstr_native = qstr_from_str_static("native");
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
comp->qstr_viper = qstr_from_str_static("viper");
Incorporate emit_thumb into new emit framework.
2013-10-05 13:41:24 -04:00
comp->qstr_asm_thumb = qstr_from_str_static("asm_thumb");
py: restrict further when for-range optimisation is done.
2013-11-28 14:12:18 -05:00
comp->qstr_range = qstr_from_str_static("range");
Initial commit.
2013-10-04 14:53:11 -04:00
Implement REPL.
2013-10-18 14:58:12 -04:00
comp->is_repl = is_repl;
comp->had_error = false;
Initial commit.
2013-10-04 14:53:11 -04:00
comp->break_label = 0;
comp->continue_label = 0;
comp->except_nest_level = 0;
comp->scope_head = NULL;
comp->scope_cur = NULL;
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// optimise constants
Initial commit.
2013-10-04 14:53:11 -04:00
pn = fold_constants(pn);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// set the outer scope
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
scope_new_and_link(comp, SCOPE_MODULE, pn, EMIT_OPT_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compile pass 1
comp->emit = emit_pass1_new(comp->qstr___class__);
comp->emit_method_table = &emit_pass1_method_table;
comp->emit_inline_asm = NULL;
comp->emit_inline_asm_method_table = NULL;
uint max_num_labels = 0;
Implement REPL.
2013-10-18 14:58:12 -04:00
for (scope_t *s = comp->scope_head; s != NULL && !comp->had_error; s = s->next) {
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
if (false) {
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_INLINE_THUMB
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
} else if (s->emit_options == EMIT_OPT_ASM_THUMB) {
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
compile_scope_inline_asm(comp, s, PASS_1);
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
} else {
compile_scope(comp, s, PASS_1);
}
// update maximim number of labels needed
if (comp->next_label > max_num_labels) {
max_num_labels = comp->next_label;
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compute some things related to scope and identifiers
Implement REPL.
2013-10-18 14:58:12 -04:00
for (scope_t *s = comp->scope_head; s != NULL && !comp->had_error; s = s->next) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_scope_compute_things(comp, s);
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// finish with pass 1
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
emit_pass1_free(comp->emit);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compile pass 2 and 3
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if !MICROPY_EMIT_CPYTHON
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
emit_t *emit_bc = NULL;
Make runtime able to call inline asm with 1 argument.
2013-10-05 20:01:01 -04:00
emit_t *emit_native = NULL;
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_INLINE_THUMB
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
emit_inline_asm_t *emit_inline_thumb = NULL;
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
Implement REPL.
2013-10-18 14:58:12 -04:00
for (scope_t *s = comp->scope_head; s != NULL && !comp->had_error; s = s->next) {
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
if (false) {
// dummy
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_INLINE_THUMB
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
} else if (s->emit_options == EMIT_OPT_ASM_THUMB) {
// inline assembly for thumb
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
if (emit_inline_thumb == NULL) {
emit_inline_thumb = emit_inline_thumb_new(max_num_labels);
}
comp->emit = NULL;
comp->emit_method_table = NULL;
comp->emit_inline_asm = emit_inline_thumb;
comp->emit_inline_asm_method_table = &emit_inline_thumb_method_table;
compile_scope_inline_asm(comp, s, PASS_2);
compile_scope_inline_asm(comp, s, PASS_3);
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
} else {
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
// choose the emit type
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_CPYTHON
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
comp->emit = emit_cpython_new(max_num_labels);
comp->emit_method_table = &emit_cpython_method_table;
#else
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
switch (s->emit_options) {
case EMIT_OPT_NATIVE_PYTHON:
Merge viper types with standard native emitter.
2013-10-07 18:09:10 -04:00
case EMIT_OPT_VIPER:
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#if MICROPY_EMIT_X64
Make runtime able to call inline asm with 1 argument.
2013-10-05 20:01:01 -04:00
if (emit_native == NULL) {
Native Python and Viper support for x64 and thumb all together.
2013-10-08 04:05:10 -04:00
emit_native = emit_native_x64_new(max_num_labels);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
Native Python and Viper support for x64 and thumb all together.
2013-10-08 04:05:10 -04:00
comp->emit_method_table = &emit_native_x64_method_table;
Change ifdef/if defined to simple if's.
2013-10-12 11:53:13 -04:00
#elif MICROPY_EMIT_THUMB
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
if (emit_native == NULL) {
emit_native = emit_native_thumb_new(max_num_labels);
}
comp->emit_method_table = &emit_native_thumb_method_table;
#endif
comp->emit = emit_native;
Merge viper types with standard native emitter.
2013-10-07 18:09:10 -04:00
comp->emit_method_table->set_native_types(comp->emit, s->emit_options == EMIT_OPT_VIPER);
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
break;
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
default:
if (emit_bc == NULL) {
emit_bc = emit_bc_new(max_num_labels);
}
comp->emit = emit_bc;
comp->emit_method_table = &emit_bc_method_table;
break;
}
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
#endif
// compile pass 2 and pass 3
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
compile_scope(comp, s, PASS_2);
compile_scope(comp, s, PASS_3);
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
bool had_error = comp->had_error;
Change memory allocation API to require size for free and realloc.
2013-12-29 14:33:23 -05:00
m_del_obj(compiler_t, comp);
Implement REPL.
2013-10-18 14:58:12 -04:00
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
if (had_error) {
// TODO return a proper error message
return mp_const_none;
} else {
#if MICROPY_EMIT_CPYTHON
// can't create code, so just return true
return mp_const_true;
#else
// return function that executes the outer module
return rt_make_function_from_id(1);
#endif
}
Initial commit.
2013-10-04 14:53:11 -04:00
}