djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Option in compile.c to emit compatible or not with CPython.

This commit is contained in:
Damien 2013-10-12 15:01:56 +01:00
parent c025ebb2dc
commit 3a205179ea
1 changed files with 102 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
py/compile.c
View File

@ -15,7 +15,6 @@
#include "emit.h"
// TODO need to mangle __attr names
// TODO add #define to enable/disable CPython compatibility
typedef enum {
PN_none = 0,
@ -250,7 +249,8 @@ void compile_generic_all_nodes(compiler_t *comp, py_parse_node_struct_t *pns) {
}
}
bool c_tuple_is_const(py_parse_node_t pn) {
#if defined(MICROPY_EMIT_ENABLE_CPYTHON)
static bool cpython_c_tuple_is_const(py_parse_node_t pn) {
if (!PY_PARSE_NODE_IS_LEAF(pn)) {
return false;
}
@ -260,7 +260,7 @@ bool c_tuple_is_const(py_parse_node_t pn) {
return true;
}
void c_tuple_emit_const(compiler_t *comp, py_parse_node_t pn) {
static void cpython_c_tuple_emit_const(compiler_t *comp, py_parse_node_t pn) {
assert(PY_PARSE_NODE_IS_LEAF(pn));
int arg = PY_PARSE_NODE_LEAF_ARG(pn);
switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
@ -282,8 +282,7 @@ void c_tuple_emit_const(compiler_t *comp, py_parse_node_t pn) {
}
}
// funnelling all tuple creations through this function and all this constant stuff is purely to agree with CPython
void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
static void cpython_c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
int n = 0;
if (pns_list != NULL) {
n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
@ -292,12 +291,12 @@ void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_l
bool is_const = true;
if (!PY_PARSE_NODE_IS_NULL(pn)) {
total += 1;
if (!c_tuple_is_const(pn)) {
if (!cpython_c_tuple_is_const(pn)) {
is_const = false;
}
}
for (int i = 0; i < n; i++) {
if (!c_tuple_is_const(pns_list->nodes[i])) {
if (!cpython_c_tuple_is_const(pns_list->nodes[i])) {
is_const = false;
break;
}
@ -307,14 +306,14 @@ void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_l
EMIT(load_const_verbatim_start);
EMIT(load_const_verbatim_str, "(");
if (!PY_PARSE_NODE_IS_NULL(pn)) {
c_tuple_emit_const(comp, pn);
cpython_c_tuple_emit_const(comp, pn);
need_comma = true;
}
for (int i = 0; i < n; i++) {
if (need_comma) {
EMIT(load_const_verbatim_str, ", ");
}
c_tuple_emit_const(comp, pns_list->nodes[i]);
cpython_c_tuple_emit_const(comp, pns_list->nodes[i]);
need_comma = true;
}
if (total == 1) {
@ -333,30 +332,46 @@ void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_l
EMIT(build_tuple, total);
}
}
#endif
// funnelling all tuple creations through this function is purely so we can optionally agree with CPython
void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
#if defined(MICROPY_EMIT_ENABLE_CPYTHON)
cpython_c_tuple(comp, pn, pns_list);
#else
int total = 0;
if (!PY_PARSE_NODE_IS_NULL(pn)) {
compile_node(comp, pn);
total += 1;
}
if (pns_list != NULL) {
int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
for (int i = 0; i < n; i++) {
compile_node(comp, pns_list->nodes[i]);
}
total += n;
}
EMIT(build_tuple, total);
#endif
}
void compile_generic_tuple(compiler_t *comp, py_parse_node_struct_t *pns) {
// a simple tuple expression
/*
int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
for (int i = 0; i < n; i++) {
compile_node(comp, pns->nodes[i]);
}
EMIT(build_tuple, n);
*/
c_tuple(comp, PY_PARSE_NODE_NULL, pns);
}
bool node_is_const_false(py_parse_node_t pn) {
static bool node_is_const_false(py_parse_node_t pn) {
return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_FALSE);
// untested: || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
}
bool node_is_const_true(py_parse_node_t pn) {
static bool node_is_const_true(py_parse_node_t pn) {
return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_TRUE) || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
}
// having c_if_cond_2 and the is_nested variable is purely to match with CPython, which doesn't fully optimise not's
void c_if_cond_2(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label, bool is_nested) {
#if defined(MICROPY_EMIT_ENABLE_CPYTHON)
// the is_nested variable is purely to match with CPython, which doesn't fully optimise not's
static void cpython_c_if_cond(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label, bool is_nested) {
if (node_is_const_false(pn)) {
if (jump_if == false) {
EMIT(jump, label);
@ -374,32 +389,32 @@ void c_if_cond_2(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label,
if (jump_if == false) {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
c_if_cond_2(comp, pns->nodes[i], true, label2, true);
cpython_c_if_cond(comp, pns->nodes[i], true, label2, true);
}
c_if_cond_2(comp, pns->nodes[n - 1], false, label, true);
cpython_c_if_cond(comp, pns->nodes[n - 1], false, label, true);
EMIT(label_assign, label2);
} else {
for (int i = 0; i < n; i++) {
c_if_cond_2(comp, pns->nodes[i], true, label, true);
cpython_c_if_cond(comp, pns->nodes[i], true, label, true);
}
}
return;
} else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
if (jump_if == false) {
for (int i = 0; i < n; i++) {
c_if_cond_2(comp, pns->nodes[i], false, label, true);
cpython_c_if_cond(comp, pns->nodes[i], false, label, true);
}
} else {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
c_if_cond_2(comp, pns->nodes[i], false, label2, true);
cpython_c_if_cond(comp, pns->nodes[i], false, label2, true);
}
c_if_cond_2(comp, pns->nodes[n - 1], true, label, true);
cpython_c_if_cond(comp, pns->nodes[n - 1], true, label, true);
EMIT(label_assign, label2);
}
return;
} else if (!is_nested && PY_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
c_if_cond_2(comp, pns->nodes[0], !jump_if, label, true);
cpython_c_if_cond(comp, pns->nodes[0], !jump_if, label, true);
return;
}
}
@ -412,9 +427,67 @@ void c_if_cond_2(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label,
EMIT(pop_jump_if_true, label);
}
}
#endif
void c_if_cond(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label) {
c_if_cond_2(comp, pn, jump_if, label, false);
static void c_if_cond(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label) {
#if defined(MICROPY_EMIT_ENABLE_CPYTHON)
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;
} else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
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;
} else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
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;
} else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
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
}
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
@ -1859,9 +1932,6 @@ void compile_comprehension(compiler_t *comp, py_parse_node_struct_t *pns, scope_
void compile_atom_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// an empty tuple
/*
EMIT(build_tuple, 0);
*/
c_tuple(comp, PY_PARSE_NODE_NULL, NULL);
} else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
pns = (py_parse_node_struct_t*)pns->nodes[0];
@ -1871,18 +1941,9 @@ void compile_atom_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
// tuple of one item, with trailing comma
assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[0]));
/*
compile_node(comp, pns->nodes[0]);
EMIT(build_tuple, 1);
*/
c_tuple(comp, pns->nodes[0], NULL);
} else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
// tuple of many items
/*
compile_node(comp, pns->nodes[0]);
compile_generic_all_nodes(comp, pns2);
EMIT(build_tuple, 1 + PY_PARSE_NODE_STRUCT_NUM_NODES(pns2));
*/
c_tuple(comp, pns->nodes[0], pns2);
} else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
// generator expression
@ -1894,11 +1955,6 @@ void compile_atom_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
} else {
// tuple with 2 items
tuple_with_2_items:
/*
compile_node(comp, pns->nodes[0]);
compile_node(comp, pns->nodes[1]);
EMIT(build_tuple, 2);
*/
c_tuple(comp, PY_PARSE_NODE_NULL, pns);
}
} else {