From 97d929faaf6294ad6ea96801c1562fffbdabd8cc Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 15:41:18 +0000 Subject: [PATCH 01/93] compiler_setup returns SUCCESS/ERROR --- Python/compile.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index d6ed6941ac1ecd..7a15c2e7483848 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -55,6 +55,19 @@ */ #define STACK_USE_GUIDELINE 30 +#define SUCCESS 0 +#define ERROR -1 + +#define RETURN_IF_ERROR(X) \ + if ((X) == -1) { \ + return -1; \ + } + +#define RETURN_NULL_IF_ERROR(X) \ + if ((X) == -1) { \ + return NULL; \ + } + /* If we exceed this limit, it should * be considered a compiler bug. * Currently it should be impossible @@ -610,18 +623,18 @@ compiler_setup(struct compiler *c, mod_ty mod, PyObject *filename, { c->c_const_cache = PyDict_New(); if (!c->c_const_cache) { - return 0; + return ERROR; } c->c_stack = PyList_New(0); if (!c->c_stack) { - return 0; + return ERROR; } c->c_filename = Py_NewRef(filename); c->c_arena = arena; if (!_PyFuture_FromAST(mod, filename, &c->c_future)) { - return 0; + return ERROR; } int merged = c->c_future.ff_features | flags.cf_flags; c->c_future.ff_features = merged; @@ -635,16 +648,16 @@ compiler_setup(struct compiler *c, mod_ty mod, PyObject *filename, state.ff_features = merged; if (!_PyAST_Optimize(mod, arena, &state)) { - return 0; + return ERROR; } c->c_st = _PySymtable_Build(mod, filename, &c->c_future); if (c->c_st == NULL) { if (!PyErr_Occurred()) { PyErr_SetString(PyExc_SystemError, "no symtable"); } - return 0; + return ERROR; } - return 1; + return SUCCESS; } static struct compiler* @@ -656,7 +669,7 @@ new_compiler(mod_ty mod, PyObject *filename, PyCompilerFlags *pflags, if (c == NULL) { return NULL; } - if (!compiler_setup(c, mod, filename, flags, optimize, arena)) { + if (compiler_setup(c, mod, filename, flags, optimize, arena) < 0) { compiler_free(c); return NULL; } From 0e1414158bd7b62132678bbde9952478583d7e79 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 15:56:37 +0000 Subject: [PATCH 02/93] cfg_builder_init returns SUCCESS/ERROR --- Python/compile.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7a15c2e7483848..7ab315400171c3 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -813,11 +813,12 @@ cfg_builder_init(cfg_builder *g) { g->g_block_list = NULL; basicblock *block = cfg_builder_new_block(g); - if (block == NULL) - return 0; + if (block == NULL) { + return ERROR; + } g->g_curblock = g->g_entryblock = block; g->g_current_label = NO_LABEL; - return 1; + return SUCCESS; } static void @@ -1800,7 +1801,7 @@ compiler_enter_scope(struct compiler *c, identifier name, c->c_nestlevel++; cfg_builder *g = CFG_BUILDER(c); - if (!cfg_builder_init(g)) { + if (cfg_builder_init(g) < 0) { return 0; } From 5d81ad09fba57bbd338c1a40877776f4c24d0d29 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:00:36 +0000 Subject: [PATCH 03/93] compiler_set_qualname returns SUCCESS/ERROR --- Python/compile.c | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7ab315400171c3..1d96131d0ec6ee 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -876,8 +876,10 @@ compiler_set_qualname(struct compiler *c) || u->u_scope_type == COMPILER_SCOPE_CLASS) { assert(u->u_name); mangled = _Py_Mangle(parent->u_private, u->u_name); - if (!mangled) - return 0; + if (!mangled) { + return ERROR; + } + scope = _PyST_GetScope(parent->u_ste, mangled); Py_DECREF(mangled); assert(scope != GLOBAL_IMPLICIT); @@ -893,8 +895,9 @@ compiler_set_qualname(struct compiler *c) _Py_DECLARE_STR(dot_locals, "."); base = PyUnicode_Concat(parent->u_qualname, &_Py_STR(dot_locals)); - if (base == NULL) - return 0; + if (base == NULL) { + return ERROR; + } } else { base = Py_NewRef(parent->u_qualname); @@ -906,18 +909,20 @@ compiler_set_qualname(struct compiler *c) _Py_DECLARE_STR(dot, "."); name = PyUnicode_Concat(base, &_Py_STR(dot)); Py_DECREF(base); - if (name == NULL) - return 0; + if (name == NULL) { + return ERROR; + } PyUnicode_Append(&name, u->u_name); - if (name == NULL) - return 0; + if (name == NULL) { + return ERROR; + } } else { name = Py_NewRef(u->u_name); } u->u_qualname = name; - return 1; + return SUCCESS; } static jump_target_label @@ -1809,8 +1814,9 @@ compiler_enter_scope(struct compiler *c, identifier name, loc.lineno = 0; } else { - if (!compiler_set_qualname(c)) + if (compiler_set_qualname(c) < 0){ return 0; + } } ADDOP_I(c, loc, RESUME, 0); From 6d56a1b153d0662075b19967d65db2ef80dd16b7 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:06:25 +0000 Subject: [PATCH 04/93] basicblock_addop returns SUCCESS/ERROR --- Python/compile.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 1d96131d0ec6ee..3b3675d759d2d1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1337,7 +1337,7 @@ basicblock_addop(basicblock *b, int opcode, int oparg, location loc) int off = basicblock_next_instr(b); if (off < 0) { - return 0; + return ERROR; } struct instr *i = &b->b_instr[off]; i->i_opcode = opcode; @@ -1345,7 +1345,7 @@ basicblock_addop(basicblock *b, int opcode, int oparg, location loc) i->i_target = NULL; i->i_loc = loc; - return 1; + return SUCCESS; } static bool @@ -1379,7 +1379,7 @@ cfg_builder_addop(cfg_builder *g, int opcode, int oparg, location loc) if (cfg_builder_maybe_start_new_block(g) != 0) { return -1; } - return basicblock_addop(g->g_curblock, opcode, oparg, loc); + return basicblock_addop(g->g_curblock, opcode, oparg, loc) == SUCCESS ? 1 : 0; } static int From 3b872153b8cb80494b523d5d9dcbef47416df605 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:10:03 +0000 Subject: [PATCH 05/93] cfg_builder_addop returns SUCCESS/ERROR --- Python/compile.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 3b3675d759d2d1..a46868389bfb3f 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1379,14 +1379,14 @@ cfg_builder_addop(cfg_builder *g, int opcode, int oparg, location loc) if (cfg_builder_maybe_start_new_block(g) != 0) { return -1; } - return basicblock_addop(g->g_curblock, opcode, oparg, loc) == SUCCESS ? 1 : 0; + return basicblock_addop(g->g_curblock, opcode, oparg, loc); } static int cfg_builder_addop_noarg(cfg_builder *g, int opcode, location loc) { assert(!HAS_ARG(opcode)); - return cfg_builder_addop(g, opcode, 0, loc); + return cfg_builder_addop(g, opcode, 0, loc) == SUCCESS ? 1 : 0; } static Py_ssize_t @@ -1595,7 +1595,7 @@ cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, location loc) EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */ int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int); - return cfg_builder_addop(g, opcode, oparg_, loc); + return cfg_builder_addop(g, opcode, oparg_, loc) == SUCCESS ? 1 : 0; } static int @@ -1604,7 +1604,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, { assert(IS_LABEL(target)); assert(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode)); - return cfg_builder_addop(g, opcode, target.id, loc); + return cfg_builder_addop(g, opcode, target.id, loc) == SUCCESS ? 1 : 0; } @@ -10012,7 +10012,7 @@ instructions_to_cfg(PyObject *instructions, cfg_builder *g) if (PyErr_Occurred()) { return -1; } - if (!cfg_builder_addop(g, opcode, oparg, loc)) { + if (cfg_builder_addop(g, opcode, oparg, loc) < 0) { return -1; } } From 829ed2dd47c26ebd4bd5734496de4900830563b3 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:12:55 +0000 Subject: [PATCH 06/93] cfg_builder_addop_noarg returns SUCCESS/ERROR --- Python/compile.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a46868389bfb3f..de19082689afab 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1386,7 +1386,7 @@ static int cfg_builder_addop_noarg(cfg_builder *g, int opcode, location loc) { assert(!HAS_ARG(opcode)); - return cfg_builder_addop(g, opcode, 0, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop(g, opcode, 0, loc); } static Py_ssize_t @@ -1609,12 +1609,12 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define ADDOP(C, LOC, OP) { \ - if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))) \ + if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) \ return 0; \ } #define ADDOP_IN_SCOPE(C, LOC, OP) { \ - if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))) { \ + if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \ compiler_exit_scope(c); \ return 0; \ } \ @@ -6396,7 +6396,7 @@ emit_and_reset_fail_pop(struct compiler *c, location loc, } while (--pc->fail_pop_size) { USE_LABEL(c, pc->fail_pop[pc->fail_pop_size]); - if (!cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, loc)) { + if (cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, loc) < 0) { pc->fail_pop_size = 0; PyObject_Free(pc->fail_pop); pc->fail_pop = NULL; @@ -6908,7 +6908,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) // Need to NULL this for the PyObject_Free call in the error block. old_pc.fail_pop = NULL; // No match. Pop the remaining copy of the subject and fail: - if (!cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, LOC(p)) || + if ((cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, LOC(p)) < 0) || !jump_to_fail_pop(c, LOC(p), pc, JUMP)) { goto error; } From 8be8f0b2511f4588040591cd8da59eabc43d44f9 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:16:25 +0000 Subject: [PATCH 07/93] cfg_builder_addop_i returns SUCCESS/ERROR --- Python/compile.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index de19082689afab..bdddc38865ed02 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1541,9 +1541,10 @@ static int compiler_addop_load_const(struct compiler *c, location loc, PyObject *o) { Py_ssize_t arg = compiler_add_const(c, o); - if (arg < 0) + if (arg < 0) { return 0; - return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, loc); + } + return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, loc) == SUCCESS ? 1 : 0; } static int @@ -1553,7 +1554,7 @@ compiler_addop_o(struct compiler *c, location loc, Py_ssize_t arg = dict_add_o(dict, o); if (arg < 0) return 0; - return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc); + return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc) == SUCCESS ? 1 : 0; } static int @@ -1577,7 +1578,7 @@ compiler_addop_name(struct compiler *c, location loc, arg <<= 1; arg |= 1; } - return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc); + return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc) == SUCCESS ? 1 : 0; } /* Add an opcode with an integer argument. @@ -1595,7 +1596,7 @@ cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, location loc) EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */ int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int); - return cfg_builder_addop(g, opcode, oparg_, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop(g, opcode, oparg_, loc); } static int @@ -1653,7 +1654,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_I(C, LOC, OP, O) { \ - if (!cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC))) \ + if (cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC)) < 0) \ return 0; \ } @@ -4343,7 +4344,7 @@ compiler_nameop(struct compiler *c, location loc, if (op == LOAD_GLOBAL) { arg <<= 1; } - return cfg_builder_addop_i(CFG_BUILDER(c), op, arg, loc); + return cfg_builder_addop_i(CFG_BUILDER(c), op, arg, loc) == SUCCESS ? 1 : 0; } static int @@ -6833,7 +6834,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) pc->fail_pop = NULL; pc->fail_pop_size = 0; pc->on_top = 0; - if (!cfg_builder_addop_i(CFG_BUILDER(c), COPY, 1, LOC(alt)) || + if ((cfg_builder_addop_i(CFG_BUILDER(c), COPY, 1, LOC(alt)) < 0) || !compiler_pattern(c, alt, pc)) { goto error; } From 9374ac03d65176521b8755a388b3d272f6ef8974 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:19:56 +0000 Subject: [PATCH 08/93] compiler_addop_name returns SUCCESS/ERROR --- Python/compile.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index bdddc38865ed02..7b671667855839 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1564,12 +1564,14 @@ compiler_addop_name(struct compiler *c, location loc, Py_ssize_t arg; PyObject *mangled = _Py_Mangle(c->u->u_private, o); - if (!mangled) - return 0; + if (!mangled) { + return ERROR; + } arg = dict_add_o(dict, mangled); Py_DECREF(mangled); - if (arg < 0) - return 0; + if (arg < 0) { + return ERROR; + } if (opcode == LOAD_ATTR) { arg <<= 1; } @@ -1578,12 +1580,10 @@ compiler_addop_name(struct compiler *c, location loc, arg <<= 1; arg |= 1; } - return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc); } -/* Add an opcode with an integer argument. - Returns 0 on failure, 1 on success. -*/ +/* Add an opcode with an integer argument */ static int cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, location loc) { @@ -1649,7 +1649,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_NAME(C, LOC, OP, O, TYPE) { \ - if (!compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))) \ + if (compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) \ return 0; \ } From 9d21d49e17541fbf2f2c60b3dd13c54581e67ca0 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:23:29 +0000 Subject: [PATCH 09/93] compiler_addop_o and compiler_addop_load_const returns SUCCESS/ERROR --- Python/compile.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7b671667855839..f46c2d23eff049 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1542,9 +1542,9 @@ compiler_addop_load_const(struct compiler *c, location loc, PyObject *o) { Py_ssize_t arg = compiler_add_const(c, o); if (arg < 0) { - return 0; + return ERROR; } - return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, loc); } static int @@ -1552,9 +1552,10 @@ compiler_addop_o(struct compiler *c, location loc, int opcode, PyObject *dict, PyObject *o) { Py_ssize_t arg = dict_add_o(dict, o); - if (arg < 0) - return 0; - return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc) == SUCCESS ? 1 : 0; + if (arg < 0) { + return ERROR; + } + return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc); } static int @@ -1622,7 +1623,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_LOAD_CONST(C, LOC, O) { \ - if (!compiler_addop_load_const((C), (LOC), (O))) \ + if (compiler_addop_load_const((C), (LOC), (O)) < 0) \ return 0; \ } @@ -1632,7 +1633,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, if (__new_const == NULL) { \ return 0; \ } \ - if (!compiler_addop_load_const((C), (LOC), __new_const)) { \ + if (compiler_addop_load_const((C), (LOC), __new_const) < 0) { \ Py_DECREF(__new_const); \ return 0; \ } \ @@ -1641,7 +1642,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define ADDOP_N(C, LOC, OP, O, TYPE) { \ assert(!HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \ - if (!compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))) { \ + if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \ Py_DECREF((O)); \ return 0; \ } \ From a67c6128757da39e178869bd928df3893fff2fd8 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 16:43:36 +0000 Subject: [PATCH 10/93] cfg_builder_addop_j returns SUCCESS/ERROR --- Python/compile.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index f46c2d23eff049..4ab3f07526111c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1606,7 +1606,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, { assert(IS_LABEL(target)); assert(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode)); - return cfg_builder_addop(g, opcode, target.id, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop(g, opcode, target.id, loc); } @@ -1660,7 +1660,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_JUMP(C, LOC, OP, O) { \ - if (!cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))) \ + if (cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O)) < 0) \ return 0; \ } @@ -6898,7 +6898,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) } } assert(control); - if (!cfg_builder_addop_j(CFG_BUILDER(c), LOC(alt), JUMP, end) || + if ((cfg_builder_addop_j(CFG_BUILDER(c), LOC(alt), JUMP, end) < 0) || !emit_and_reset_fail_pop(c, LOC(alt), pc)) { goto error; From 844b78fb8b8b088d2df4dc898794b3bb3a486ac0 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:16:55 +0000 Subject: [PATCH 11/93] prepend macros with _ --- Python/compile.c | 1176 +++++++++++++++++++++++----------------------- 1 file changed, 588 insertions(+), 588 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 4ab3f07526111c..27efd2740aede5 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1610,25 +1610,25 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } -#define ADDOP(C, LOC, OP) { \ +#define _ADDOP(C, LOC, OP) { \ if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) \ return 0; \ } -#define ADDOP_IN_SCOPE(C, LOC, OP) { \ +#define _ADDOP_IN_SCOPE(C, LOC, OP) { \ if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \ compiler_exit_scope(c); \ return 0; \ } \ } -#define ADDOP_LOAD_CONST(C, LOC, O) { \ +#define _ADDOP_LOAD_CONST(C, LOC, O) { \ if (compiler_addop_load_const((C), (LOC), (O)) < 0) \ return 0; \ } -/* Same as ADDOP_LOAD_CONST, but steals a reference. */ -#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \ +/* Same as _ADDOP_LOAD_CONST, but steals a reference. */ +#define _ADDOP_LOAD_CONST_NEW(C, LOC, O) { \ PyObject *__new_const = (O); \ if (__new_const == NULL) { \ return 0; \ @@ -1640,8 +1640,8 @@ cfg_builder_addop_j(cfg_builder *g, location loc, Py_DECREF(__new_const); \ } -#define ADDOP_N(C, LOC, OP, O, TYPE) { \ - assert(!HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \ +#define _ADDOP_N(C, LOC, OP, O, TYPE) { \ + assert(!HAS_CONST(OP)); /* use _ADDOP_LOAD_CONST_NEW */ \ if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \ Py_DECREF((O)); \ return 0; \ @@ -1649,58 +1649,58 @@ cfg_builder_addop_j(cfg_builder *g, location loc, Py_DECREF((O)); \ } -#define ADDOP_NAME(C, LOC, OP, O, TYPE) { \ +#define _ADDOP_NAME(C, LOC, OP, O, TYPE) { \ if (compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) \ return 0; \ } -#define ADDOP_I(C, LOC, OP, O) { \ +#define _ADDOP_I(C, LOC, OP, O) { \ if (cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC)) < 0) \ return 0; \ } -#define ADDOP_JUMP(C, LOC, OP, O) { \ +#define _ADDOP_JUMP(C, LOC, OP, O) { \ if (cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O)) < 0) \ return 0; \ } -#define ADDOP_COMPARE(C, LOC, CMP) { \ +#define _ADDOP_COMPARE(C, LOC, CMP) { \ if (!compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))) \ return 0; \ } -#define ADDOP_BINARY(C, LOC, BINOP) \ +#define _ADDOP_BINARY(C, LOC, BINOP) \ RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), false)) -#define ADDOP_INPLACE(C, LOC, BINOP) \ +#define _ADDOP_INPLACE(C, LOC, BINOP) \ RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), true)) -#define ADD_YIELD_FROM(C, LOC, await) \ +#define _ADD_YIELD_FROM(C, LOC, await) \ RETURN_IF_FALSE(compiler_add_yield_from((C), (LOC), (await))) -#define POP_EXCEPT_AND_RERAISE(C, LOC) \ +#define _POP_EXCEPT_AND_RERAISE(C, LOC) \ RETURN_IF_FALSE(compiler_pop_except_and_reraise((C), (LOC))) -#define ADDOP_YIELD(C, LOC) \ +#define _ADDOP_YIELD(C, LOC) \ RETURN_IF_FALSE(addop_yield((C), (LOC))) -/* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use +/* _VISIT and _VISIT_SEQ takes an ASDL type as their second argument. They use the ASDL name to synthesize the name of the C type and the visit function. */ -#define VISIT(C, TYPE, V) {\ +#define _VISIT(C, TYPE, V) {\ if (!compiler_visit_ ## TYPE((C), (V))) \ return 0; \ } -#define VISIT_IN_SCOPE(C, TYPE, V) {\ +#define _VISIT_IN_SCOPE(C, TYPE, V) {\ if (!compiler_visit_ ## TYPE((C), (V))) { \ compiler_exit_scope(c); \ return 0; \ } \ } -#define VISIT_SEQ(C, TYPE, SEQ) { \ +#define _VISIT_SEQ(C, TYPE, SEQ) { \ int _i; \ asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ @@ -1710,7 +1710,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } \ } -#define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ +#define _VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ int _i; \ asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ @@ -1820,7 +1820,7 @@ compiler_enter_scope(struct compiler *c, identifier name, return 0; } } - ADDOP_I(c, loc, RESUME, 0); + _ADDOP_I(c, loc, RESUME, 0); if (u->u_scope_type == COMPILER_SCOPE_MODULE) { loc.lineno = -1; @@ -1960,10 +1960,10 @@ compiler_pop_fblock(struct compiler *c, enum fblocktype t, jump_target_label blo static int compiler_call_exit_with_nones(struct compiler *c, location loc) { - ADDOP_LOAD_CONST(c, loc, Py_None); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADDOP_I(c, loc, CALL, 2); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_I(c, loc, CALL, 2); return 1; } @@ -1975,17 +1975,17 @@ compiler_add_yield_from(struct compiler *c, location loc, int await) NEW_JUMP_TARGET_LABEL(c, exit); USE_LABEL(c, send); - ADDOP_JUMP(c, loc, SEND, exit); + _ADDOP_JUMP(c, loc, SEND, exit); // Set up a virtual try/except to handle when StopIteration is raised during // a close or throw call. The only way YIELD_VALUE raises if they do! - ADDOP_JUMP(c, loc, SETUP_FINALLY, fail); - ADDOP_I(c, loc, YIELD_VALUE, 0); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP_I(c, loc, RESUME, await ? 3 : 2); - ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, fail); + _ADDOP_I(c, loc, YIELD_VALUE, 0); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP_I(c, loc, RESUME, await ? 3 : 2); + _ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send); USE_LABEL(c, fail); - ADDOP(c, loc, CLEANUP_THROW); + _ADDOP(c, loc, CLEANUP_THROW); USE_LABEL(c, exit); return 1; @@ -2001,9 +2001,9 @@ compiler_pop_except_and_reraise(struct compiler *c, location loc) * (exception_unwind clears the stack) */ - ADDOP_I(c, loc, COPY, 3); - ADDOP(c, loc, POP_EXCEPT); - ADDOP_I(c, loc, RERAISE, 1); + _ADDOP_I(c, loc, COPY, 3); + _ADDOP(c, loc, POP_EXCEPT); + _ADDOP_I(c, loc, RERAISE, 1); return 1; } @@ -2026,25 +2026,25 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, case FOR_LOOP: /* Pop the iterator */ if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } - ADDOP(c, *ploc, POP_TOP); + _ADDOP(c, *ploc, POP_TOP); return 1; case TRY_EXCEPT: - ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_BLOCK); return 1; case FINALLY_TRY: /* This POP_BLOCK gets the line number of the unwinding statement */ - ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { if (!compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL)) { return 0; } } /* Emit the finally block */ - VISIT_SEQ(c, stmt, info->fb_datum); + _VISIT_SEQ(c, stmt, info->fb_datum); if (preserve_tos) { compiler_pop_fblock(c, POP_VALUE, NO_LABEL); } @@ -2056,32 +2056,32 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, case FINALLY_END: if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } - ADDOP(c, *ploc, POP_TOP); /* exc_value */ + _ADDOP(c, *ploc, POP_TOP); /* exc_value */ if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } - ADDOP(c, *ploc, POP_BLOCK); - ADDOP(c, *ploc, POP_EXCEPT); + _ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_EXCEPT); return 1; case WITH: case ASYNC_WITH: *ploc = LOC((stmt_ty)info->fb_datum); - ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } if(!compiler_call_exit_with_nones(c, *ploc)) { return 0; } if (info->fb_type == ASYNC_WITH) { - ADDOP_I(c, *ploc, GET_AWAITABLE, 2); - ADDOP_LOAD_CONST(c, *ploc, Py_None); - ADD_YIELD_FROM(c, *ploc, 1); + _ADDOP_I(c, *ploc, GET_AWAITABLE, 2); + _ADDOP_LOAD_CONST(c, *ploc, Py_None); + _ADD_YIELD_FROM(c, *ploc, 1); } - ADDOP(c, *ploc, POP_TOP); + _ADDOP(c, *ploc, POP_TOP); /* The exit block should appear to execute after the * statement causing the unwinding, so make the unwinding * instruction artificial */ @@ -2090,15 +2090,15 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, case HANDLER_CLEANUP: { if (info->fb_datum) { - ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_BLOCK); } if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } - ADDOP(c, *ploc, POP_BLOCK); - ADDOP(c, *ploc, POP_EXCEPT); + _ADDOP(c, *ploc, POP_BLOCK); + _ADDOP(c, *ploc, POP_EXCEPT); if (info->fb_datum) { - ADDOP_LOAD_CONST(c, *ploc, Py_None); + _ADDOP_LOAD_CONST(c, *ploc, Py_None); compiler_nameop(c, *ploc, info->fb_datum, Store); compiler_nameop(c, *ploc, info->fb_datum, Del); } @@ -2106,9 +2106,9 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, } case POP_VALUE: { if (preserve_tos) { - ADDOP_I(c, *ploc, SWAP, 2); + _ADDOP_I(c, *ploc, SWAP, 2); } - ADDOP(c, *ploc, POP_TOP); + _ADDOP(c, *ploc, POP_TOP); return 1; } } @@ -2165,7 +2165,7 @@ compiler_body(struct compiler *c, location loc, asdl_stmt_seq *stmts) } /* Every annotated class and module should have __annotations__. */ if (find_ann(stmts)) { - ADDOP(c, loc, SETUP_ANNOTATIONS); + _ADDOP(c, loc, SETUP_ANNOTATIONS); } if (!asdl_seq_LEN(stmts)) return 1; @@ -2176,13 +2176,13 @@ compiler_body(struct compiler *c, location loc, asdl_stmt_seq *stmts) i = 1; st = (stmt_ty)asdl_seq_GET(stmts, 0); assert(st->kind == Expr_kind); - VISIT(c, expr, st->v.Expr.value); + _VISIT(c, expr, st->v.Expr.value); if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store)) return 0; } } for (; i < asdl_seq_LEN(stmts); i++) - VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); + _VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); return 1; } @@ -2204,13 +2204,13 @@ compiler_codegen(struct compiler *c, mod_ty mod) break; case Interactive_kind: if (find_ann(mod->v.Interactive.body)) { - ADDOP(c, loc, SETUP_ANNOTATIONS); + _ADDOP(c, loc, SETUP_ANNOTATIONS); } c->c_interactive = 1; - VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body); + _VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body); break; case Expression_kind: - VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); + _VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); break; default: PyErr_Format(PyExc_SystemError, @@ -2317,13 +2317,13 @@ compiler_make_closure(struct compiler *c, location loc, Py_DECREF(freevars); return 0; } - ADDOP_I(c, loc, LOAD_CLOSURE, arg); + _ADDOP_I(c, loc, LOAD_CLOSURE, arg); } flags |= 0x08; - ADDOP_I(c, loc, BUILD_TUPLE, co->co_nfreevars); + _ADDOP_I(c, loc, BUILD_TUPLE, co->co_nfreevars); } - ADDOP_LOAD_CONST(c, loc, (PyObject*)co); - ADDOP_I(c, loc, MAKE_FUNCTION, flags); + _ADDOP_LOAD_CONST(c, loc, (PyObject*)co); + _ADDOP_I(c, loc, MAKE_FUNCTION, flags); return 1; } @@ -2336,7 +2336,7 @@ compiler_decorators(struct compiler *c, asdl_expr_seq* decos) return 1; for (i = 0; i < asdl_seq_LEN(decos); i++) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); } return 1; } @@ -2349,7 +2349,7 @@ compiler_apply_decorators(struct compiler *c, asdl_expr_seq* decos) for (Py_ssize_t i = asdl_seq_LEN(decos) - 1; i > -1; i--) { location loc = LOC((expr_ty)asdl_seq_GET(decos, i)); - ADDOP_I(c, loc, CALL, 0); + _ADDOP_I(c, loc, CALL, 0); } return 1; } @@ -2397,8 +2397,8 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, Py_ssize_t default_count = PyList_GET_SIZE(keys); PyObject *keys_tuple = PyList_AsTuple(keys); Py_DECREF(keys); - ADDOP_LOAD_CONST_NEW(c, loc, keys_tuple); - ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, default_count); + _ADDOP_LOAD_CONST_NEW(c, loc, keys_tuple); + _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, default_count); assert(default_count > 0); return 1; } @@ -2415,7 +2415,7 @@ static int compiler_visit_annexpr(struct compiler *c, expr_ty annotation) { location loc = LOC(annotation); - ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation)); + _ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation)); return 1; } @@ -2430,11 +2430,11 @@ compiler_visit_argannotation(struct compiler *c, identifier id, if (!mangled) { return 0; } - ADDOP_LOAD_CONST(c, loc, mangled); + _ADDOP_LOAD_CONST(c, loc, mangled); Py_DECREF(mangled); if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) { - VISIT(c, annexpr, annotation); + _VISIT(c, annexpr, annotation); } else { if (annotation->kind == Starred_kind) { @@ -2442,11 +2442,11 @@ compiler_visit_argannotation(struct compiler *c, identifier id, // Do [annotation_value] = [*Ts]. // (Note that in theory we could end up here even for an argument // other than *args, but in practice the grammar doesn't allow it.) - VISIT(c, expr, annotation->v.Starred.value); - ADDOP_I(c, loc, UNPACK_SEQUENCE, (Py_ssize_t) 1); + _VISIT(c, expr, annotation->v.Starred.value); + _ADDOP_I(c, loc, UNPACK_SEQUENCE, (Py_ssize_t) 1); } else { - VISIT(c, expr, annotation); + _VISIT(c, expr, annotation); } } *annotations_len += 2; @@ -2503,7 +2503,7 @@ compiler_visit_annotations(struct compiler *c, location loc, } if (annotations_len) { - ADDOP_I(c, loc, BUILD_TUPLE, annotations_len); + _ADDOP_I(c, loc, BUILD_TUPLE, annotations_len); return 1; } @@ -2514,8 +2514,8 @@ static int compiler_visit_defaults(struct compiler *c, arguments_ty args, location loc) { - VISIT_SEQ(c, expr, args->defaults); - ADDOP_I(c, loc, BUILD_TUPLE, asdl_seq_LEN(args->defaults)); + _VISIT_SEQ(c, expr, args->defaults); + _ADDOP_I(c, loc, BUILD_TUPLE, asdl_seq_LEN(args->defaults)); return 1; } @@ -2624,11 +2624,11 @@ wrap_in_stopiteration_handler(struct compiler *c) return 0; } - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - ADDOP(c, NO_LOCATION, RETURN_VALUE); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP(c, NO_LOCATION, RETURN_VALUE); USE_LABEL(c, handler); - ADDOP(c, NO_LOCATION, STOPITERATION_ERROR); - ADDOP_I(c, NO_LOCATION, RERAISE, 1); + _ADDOP(c, NO_LOCATION, STOPITERATION_ERROR); + _ADDOP_I(c, NO_LOCATION, RERAISE, 1); return 1; } @@ -2710,7 +2710,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs); c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); for (i = docstring ? 1 : 0; i < asdl_seq_LEN(body); i++) { - VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i)); + _VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i)); } if (c->u->u_ste->ste_coroutine || c->u->u_ste->ste_generator) { if (!wrap_in_stopiteration_handler(c)) { @@ -2785,7 +2785,7 @@ compiler_class(struct compiler *c, stmt_ty s) return 0; } assert(c->u->u_qualname); - ADDOP_LOAD_CONST(c, loc, c->u->u_qualname); + _ADDOP_LOAD_CONST(c, loc, c->u->u_qualname); if (!compiler_nameop(c, loc, &_Py_ID(__qualname__), Store)) { compiler_exit_scope(c); return 0; @@ -2805,8 +2805,8 @@ compiler_class(struct compiler *c, stmt_ty s) return 0; } assert(i == 0); - ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i); - ADDOP_I(c, NO_LOCATION, COPY, 1); + _ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i); + _ADDOP_I(c, NO_LOCATION, COPY, 1); if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store)) { compiler_exit_scope(c); return 0; @@ -2815,9 +2815,9 @@ compiler_class(struct compiler *c, stmt_ty s) else { /* No methods referenced __class__, so just return None */ assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0); - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); } - ADDOP_IN_SCOPE(c, NO_LOCATION, RETURN_VALUE); + _ADDOP_IN_SCOPE(c, NO_LOCATION, RETURN_VALUE); /* create the code object */ co = assemble(c, 1); } @@ -2828,8 +2828,8 @@ compiler_class(struct compiler *c, stmt_ty s) location loc = LOC(s); /* 2. load the 'build_class' function */ - ADDOP(c, loc, PUSH_NULL); - ADDOP(c, loc, LOAD_BUILD_CLASS); + _ADDOP(c, loc, PUSH_NULL); + _ADDOP(c, loc, LOAD_BUILD_CLASS); /* 3. load a function (or closure) made from the code object */ if (!compiler_make_closure(c, loc, co, 0, NULL)) { @@ -2839,7 +2839,7 @@ compiler_class(struct compiler *c, stmt_ty s) Py_DECREF(co); /* 4. load class name */ - ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name); + _ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name); /* 5. generate the rest of the code for the call */ if (!compiler_call_helper(c, loc, 2, @@ -2921,21 +2921,21 @@ static int compiler_addcompare(struct compiler *c, location loc, cmp = Py_GE; break; case Is: - ADDOP_I(c, loc, IS_OP, 0); + _ADDOP_I(c, loc, IS_OP, 0); return 1; case IsNot: - ADDOP_I(c, loc, IS_OP, 1); + _ADDOP_I(c, loc, IS_OP, 1); return 1; case In: - ADDOP_I(c, loc, CONTAINS_OP, 0); + _ADDOP_I(c, loc, CONTAINS_OP, 0); return 1; case NotIn: - ADDOP_I(c, loc, CONTAINS_OP, 1); + _ADDOP_I(c, loc, CONTAINS_OP, 1); return 1; default: Py_UNREACHABLE(); } - ADDOP_I(c, loc, COMPARE_OP, cmp); + _ADDOP_I(c, loc, COMPARE_OP, cmp); return 1; } @@ -2984,7 +2984,7 @@ compiler_jump_if(struct compiler *c, location loc, if (!compiler_jump_if(c, loc, e->v.IfExp.body, next, cond)) { return 0; } - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next2); if (!compiler_jump_if(c, loc, e->v.IfExp.orelse, next, cond)) { @@ -3001,25 +3001,25 @@ compiler_jump_if(struct compiler *c, location loc, return 0; } NEW_JUMP_TARGET_LABEL(c, cleanup); - VISIT(c, expr, e->v.Compare.left); + _VISIT(c, expr, e->v.Compare.left); for (Py_ssize_t i = 0; i < n; i++) { - VISIT(c, expr, + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); - ADDOP_I(c, LOC(e), SWAP, 2); - ADDOP_I(c, LOC(e), COPY, 2); - ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, i)); - ADDOP_JUMP(c, LOC(e), POP_JUMP_IF_FALSE, cleanup); - } - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); - ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, n)); - ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); + _ADDOP_I(c, LOC(e), SWAP, 2); + _ADDOP_I(c, LOC(e), COPY, 2); + _ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, i)); + _ADDOP_JUMP(c, LOC(e), POP_JUMP_IF_FALSE, cleanup); + } + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); + _ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, n)); + _ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); NEW_JUMP_TARGET_LABEL(c, end); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, cleanup); - ADDOP(c, LOC(e), POP_TOP); + _ADDOP(c, LOC(e), POP_TOP); if (!cond) { - ADDOP_JUMP(c, NO_LOCATION, JUMP, next); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, next); } USE_LABEL(c, end); @@ -3034,8 +3034,8 @@ compiler_jump_if(struct compiler *c, location loc, } /* general implementation */ - VISIT(c, expr, e); - ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); + _VISIT(c, expr, e); + _ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); return 1; } @@ -3049,11 +3049,11 @@ compiler_ifexp(struct compiler *c, expr_ty e) if (!compiler_jump_if(c, LOC(e), e->v.IfExp.test, next, 0)) { return 0; } - VISIT(c, expr, e->v.IfExp.body); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _VISIT(c, expr, e->v.IfExp.body); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next); - VISIT(c, expr, e->v.IfExp.orelse); + _VISIT(c, expr, e->v.IfExp.orelse); USE_LABEL(c, end); return 1; @@ -3090,13 +3090,13 @@ compiler_lambda(struct compiler *c, expr_ty e) c->u->u_argcount = asdl_seq_LEN(args->args); c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs); c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); - VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); + _VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); if (c->u->u_ste->ste_generator) { co = assemble(c, 0); } else { location loc = LOCATION(e->lineno, e->lineno, 0, 0); - ADDOP_IN_SCOPE(c, loc, RETURN_VALUE); + _ADDOP_IN_SCOPE(c, loc, RETURN_VALUE); co = assemble(c, 1); } qualname = Py_NewRef(c->u->u_qualname); @@ -3133,12 +3133,12 @@ compiler_if(struct compiler *c, stmt_ty s) if (!compiler_jump_if(c, LOC(s), s->v.If.test, next, 0)) { return 0; } - VISIT_SEQ(c, stmt, s->v.If.body); + _VISIT_SEQ(c, stmt, s->v.If.body); if (asdl_seq_LEN(s->v.If.orelse)) { - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next); - VISIT_SEQ(c, stmt, s->v.If.orelse); + _VISIT_SEQ(c, stmt, s->v.If.orelse); } USE_LABEL(c, end); @@ -3157,24 +3157,24 @@ compiler_for(struct compiler *c, stmt_ty s) if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) { return 0; } - VISIT(c, expr, s->v.For.iter); - ADDOP(c, loc, GET_ITER); + _VISIT(c, expr, s->v.For.iter); + _ADDOP(c, loc, GET_ITER); USE_LABEL(c, start); - ADDOP_JUMP(c, loc, FOR_ITER, cleanup); + _ADDOP_JUMP(c, loc, FOR_ITER, cleanup); USE_LABEL(c, body); - VISIT(c, expr, s->v.For.target); - VISIT_SEQ(c, stmt, s->v.For.body); + _VISIT(c, expr, s->v.For.target); + _VISIT_SEQ(c, stmt, s->v.For.body); /* Mark jump as artificial */ - ADDOP_JUMP(c, NO_LOCATION, JUMP, start); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, start); USE_LABEL(c, cleanup); - ADDOP(c, NO_LOCATION, END_FOR); + _ADDOP(c, NO_LOCATION, END_FOR); compiler_pop_fblock(c, FOR_LOOP, start); - VISIT_SEQ(c, stmt, s->v.For.orelse); + _VISIT_SEQ(c, stmt, s->v.For.orelse); USE_LABEL(c, end); return 1; @@ -3195,25 +3195,25 @@ compiler_async_for(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, except); NEW_JUMP_TARGET_LABEL(c, end); - VISIT(c, expr, s->v.AsyncFor.iter); - ADDOP(c, loc, GET_AITER); + _VISIT(c, expr, s->v.AsyncFor.iter); + _ADDOP(c, loc, GET_AITER); USE_LABEL(c, start); if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) { return 0; } /* SETUP_FINALLY to guard the __anext__ call */ - ADDOP_JUMP(c, loc, SETUP_FINALLY, except); - ADDOP(c, loc, GET_ANEXT); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); - ADDOP(c, loc, POP_BLOCK); /* for SETUP_FINALLY */ + _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + _ADDOP(c, loc, GET_ANEXT); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); + _ADDOP(c, loc, POP_BLOCK); /* for SETUP_FINALLY */ /* Success block for __anext__ */ - VISIT(c, expr, s->v.AsyncFor.target); - VISIT_SEQ(c, stmt, s->v.AsyncFor.body); + _VISIT(c, expr, s->v.AsyncFor.target); + _VISIT_SEQ(c, stmt, s->v.AsyncFor.body); /* Mark jump as artificial */ - ADDOP_JUMP(c, NO_LOCATION, JUMP, start); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, start); compiler_pop_fblock(c, FOR_LOOP, start); @@ -3223,10 +3223,10 @@ compiler_async_for(struct compiler *c, stmt_ty s) /* Use same line number as the iterator, * as the END_ASYNC_FOR succeeds the `for`, not the body. */ loc = LOC(s->v.AsyncFor.iter); - ADDOP(c, loc, END_ASYNC_FOR); + _ADDOP(c, loc, END_ASYNC_FOR); /* `else` block */ - VISIT_SEQ(c, stmt, s->v.For.orelse); + _VISIT_SEQ(c, stmt, s->v.For.orelse); USE_LABEL(c, end); return 1; @@ -3249,7 +3249,7 @@ compiler_while(struct compiler *c, stmt_ty s) } USE_LABEL(c, body); - VISIT_SEQ(c, stmt, s->v.While.body); + _VISIT_SEQ(c, stmt, s->v.While.body); if (!compiler_jump_if(c, LOC(s), s->v.While.test, body, 1)) { return 0; } @@ -3258,7 +3258,7 @@ compiler_while(struct compiler *c, stmt_ty s) USE_LABEL(c, anchor); if (s->v.While.orelse) { - VISIT_SEQ(c, stmt, s->v.While.orelse); + _VISIT_SEQ(c, stmt, s->v.While.orelse); } USE_LABEL(c, end); @@ -3281,28 +3281,28 @@ compiler_return(struct compiler *c, stmt_ty s) } if (preserve_tos) { - VISIT(c, expr, s->v.Return.value); + _VISIT(c, expr, s->v.Return.value); } else { /* Emit instruction with line number for return value */ if (s->v.Return.value != NULL) { loc = LOC(s->v.Return.value); - ADDOP(c, loc, NOP); + _ADDOP(c, loc, NOP); } } if (s->v.Return.value == NULL || s->v.Return.value->lineno != s->lineno) { loc = LOC(s); - ADDOP(c, loc, NOP); + _ADDOP(c, loc, NOP); } if (!compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL)) return 0; if (s->v.Return.value == NULL) { - ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_LOAD_CONST(c, loc, Py_None); } else if (!preserve_tos) { - ADDOP_LOAD_CONST(c, loc, s->v.Return.value->v.Constant.value); + _ADDOP_LOAD_CONST(c, loc, s->v.Return.value->v.Constant.value); } - ADDOP(c, loc, RETURN_VALUE); + _ADDOP(c, loc, RETURN_VALUE); return 1; } @@ -3312,7 +3312,7 @@ compiler_break(struct compiler *c, location loc) { struct fblockinfo *loop = NULL; /* Emit instruction with line number */ - ADDOP(c, loc, NOP); + _ADDOP(c, loc, NOP); if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) { return 0; } @@ -3322,7 +3322,7 @@ compiler_break(struct compiler *c, location loc) if (!compiler_unwind_fblock(c, &loc, loop, 0)) { return 0; } - ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); + _ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); return 1; } @@ -3331,14 +3331,14 @@ compiler_continue(struct compiler *c, location loc) { struct fblockinfo *loop = NULL; /* Emit instruction with line number */ - ADDOP(c, loc, NOP); + _ADDOP(c, loc, NOP); if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) { return 0; } if (loop == NULL) { return compiler_error(c, loc, "'continue' not properly in loop"); } - ADDOP_JUMP(c, loc, JUMP, loop->fb_block); + _ADDOP_JUMP(c, loc, JUMP, loop->fb_block); return 1; } @@ -3395,7 +3395,7 @@ compiler_try_finally(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); /* `try` block */ - ADDOP_JUMP(c, loc, SETUP_FINALLY, end); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); if (!compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.Try.finalbody)) @@ -3405,30 +3405,30 @@ compiler_try_finally(struct compiler *c, stmt_ty s) return 0; } else { - VISIT_SEQ(c, stmt, s->v.Try.body); + _VISIT_SEQ(c, stmt, s->v.Try.body); } - ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, FINALLY_TRY, body); - VISIT_SEQ(c, stmt, s->v.Try.finalbody); + _VISIT_SEQ(c, stmt, s->v.Try.finalbody); - ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); /* `finally` block */ USE_LABEL(c, end); loc = NO_LOCATION; - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - ADDOP(c, loc, PUSH_EXC_INFO); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + _ADDOP(c, loc, PUSH_EXC_INFO); if (!compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)) return 0; - VISIT_SEQ(c, stmt, s->v.Try.finalbody); + _VISIT_SEQ(c, stmt, s->v.Try.finalbody); loc = location_of_last_executing_statement(s->v.Try.finalbody); compiler_pop_fblock(c, FINALLY_END, end); - ADDOP_I(c, loc, RERAISE, 0); + _ADDOP_I(c, loc, RERAISE, 0); USE_LABEL(c, cleanup); - POP_EXCEPT_AND_RERAISE(c, loc); + _POP_EXCEPT_AND_RERAISE(c, loc); USE_LABEL(c, exit); return 1; @@ -3444,7 +3444,7 @@ compiler_try_star_finally(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, exit); NEW_JUMP_TARGET_LABEL(c, cleanup); /* `try` block */ - ADDOP_JUMP(c, loc, SETUP_FINALLY, end); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); if (!compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.TryStar.finalbody)) { @@ -3456,31 +3456,31 @@ compiler_try_star_finally(struct compiler *c, stmt_ty s) } } else { - VISIT_SEQ(c, stmt, s->v.TryStar.body); + _VISIT_SEQ(c, stmt, s->v.TryStar.body); } - ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, FINALLY_TRY, body); - VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); + _VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); - ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); /* `finally` block */ USE_LABEL(c, end); loc = NO_LOCATION; - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - ADDOP(c, loc, PUSH_EXC_INFO); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + _ADDOP(c, loc, PUSH_EXC_INFO); if (!compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)) { return 0; } - VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); + _VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); loc = location_of_last_executing_statement(s->v.Try.finalbody); compiler_pop_fblock(c, FINALLY_END, end); - ADDOP_I(c, loc, RERAISE, 0); + _ADDOP_I(c, loc, RERAISE, 0); USE_LABEL(c, cleanup); - POP_EXCEPT_AND_RERAISE(c, loc); + _POP_EXCEPT_AND_RERAISE(c, loc); USE_LABEL(c, exit); return 1; @@ -3526,24 +3526,24 @@ compiler_try_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, end); NEW_JUMP_TARGET_LABEL(c, cleanup); - ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); if (!compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)) return 0; - VISIT_SEQ(c, stmt, s->v.Try.body); + _VISIT_SEQ(c, stmt, s->v.Try.body); compiler_pop_fblock(c, TRY_EXCEPT, body); - ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); if (s->v.Try.orelse && asdl_seq_LEN(s->v.Try.orelse)) { - VISIT_SEQ(c, stmt, s->v.Try.orelse); + _VISIT_SEQ(c, stmt, s->v.Try.orelse); } - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); n = asdl_seq_LEN(s->v.Try.handlers); USE_LABEL(c, except); - ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); - ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); + _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); /* Runtime will push a block here, so we need to account for that */ if (!compiler_push_fblock(c, loc, EXCEPTION_HANDLER, NO_LABEL, NO_LABEL, NULL)) return 0; @@ -3557,9 +3557,9 @@ compiler_try_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, next_except); except = next_except; if (handler->v.ExceptHandler.type) { - VISIT(c, expr, handler->v.ExceptHandler.type); - ADDOP(c, loc, CHECK_EXC_MATCH); - ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, except); + _VISIT(c, expr, handler->v.ExceptHandler.type); + _ADDOP(c, loc, CHECK_EXC_MATCH); + _ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, except); } if (handler->v.ExceptHandler.name) { NEW_JUMP_TARGET_LABEL(c, cleanup_end); @@ -3579,7 +3579,7 @@ compiler_try_except(struct compiler *c, stmt_ty s) */ /* second try: */ - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, @@ -3588,50 +3588,50 @@ compiler_try_except(struct compiler *c, stmt_ty s) } /* second # body */ - VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); /* name = None; del name; # Mark as artificial */ - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP(c, NO_LOCATION, POP_EXCEPT); - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_EXCEPT); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); /* except: */ USE_LABEL(c, cleanup_end); /* name = None; del name; # artificial */ - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); - ADDOP_I(c, NO_LOCATION, RERAISE, 1); + _ADDOP_I(c, NO_LOCATION, RERAISE, 1); } else { NEW_JUMP_TARGET_LABEL(c, cleanup_body); - ADDOP(c, loc, POP_TOP); /* exc_value */ + _ADDOP(c, loc, POP_TOP); /* exc_value */ USE_LABEL(c, cleanup_body); if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, NULL)) return 0; - VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP(c, NO_LOCATION, POP_EXCEPT); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_EXCEPT); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); } USE_LABEL(c, except); } /* artificial */ compiler_pop_fblock(c, EXCEPTION_HANDLER, NO_LABEL); - ADDOP_I(c, NO_LOCATION, RERAISE, 0); + _ADDOP_I(c, NO_LOCATION, RERAISE, 0); USE_LABEL(c, cleanup); - POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, end); return 1; @@ -3698,22 +3698,22 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); NEW_JUMP_TARGET_LABEL(c, reraise_star); - ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); if (!compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)) { return 0; } - VISIT_SEQ(c, stmt, s->v.TryStar.body); + _VISIT_SEQ(c, stmt, s->v.TryStar.body); compiler_pop_fblock(c, TRY_EXCEPT, body); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP_JUMP(c, NO_LOCATION, JUMP, orelse); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, orelse); Py_ssize_t n = asdl_seq_LEN(s->v.TryStar.handlers); USE_LABEL(c, except); - ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); - ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); + _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); /* Runtime will push a block here, so we need to account for that */ if (!compiler_push_fblock(c, loc, EXCEPTION_GROUP_HANDLER, NO_LABEL, NO_LABEL, "except handler")) { @@ -3732,7 +3732,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) [exc] COPY 1 [orig, exc] */ - ADDOP_I(c, loc, COPY, 1); + _ADDOP_I(c, loc, COPY, 1); /* create empty list for exceptions raised/reraise in the except* blocks */ /* @@ -3740,16 +3740,16 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) [orig, exc, []] SWAP 2 [orig, [], exc] */ - ADDOP_I(c, loc, BUILD_LIST, 0); - ADDOP_I(c, loc, SWAP, 2); + _ADDOP_I(c, loc, BUILD_LIST, 0); + _ADDOP_I(c, loc, SWAP, 2); } if (handler->v.ExceptHandler.type) { - VISIT(c, expr, handler->v.ExceptHandler.type); - ADDOP(c, loc, CHECK_EG_MATCH); - ADDOP_I(c, loc, COPY, 1); - ADDOP_JUMP(c, loc, POP_JUMP_IF_NOT_NONE, handle_match); - ADDOP(c, loc, POP_TOP); // match - ADDOP_JUMP(c, loc, JUMP, except); + _VISIT(c, expr, handler->v.ExceptHandler.type); + _ADDOP(c, loc, CHECK_EG_MATCH); + _ADDOP_I(c, loc, COPY, 1); + _ADDOP_JUMP(c, loc, POP_JUMP_IF_NOT_NONE, handle_match); + _ADDOP(c, loc, POP_TOP); // match + _ADDOP_JUMP(c, loc, JUMP, except); } USE_LABEL(c, handle_match); @@ -3761,7 +3761,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store); } else { - ADDOP(c, loc, POP_TOP); // match + _ADDOP(c, loc, POP_TOP); // match } /* @@ -3775,7 +3775,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) del name */ /* second try: */ - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, handler->v.ExceptHandler.name)) { @@ -3783,38 +3783,38 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) } /* second # body */ - VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); /* name = None; del name; # artificial */ - ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); if (handler->v.ExceptHandler.name) { - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); } - ADDOP_JUMP(c, NO_LOCATION, JUMP, except); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, except); /* except: */ USE_LABEL(c, cleanup_end); /* name = None; del name; # artificial */ if (handler->v.ExceptHandler.name) { - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); } /* add exception raised to the res list */ - ADDOP_I(c, NO_LOCATION, LIST_APPEND, 3); // exc - ADDOP(c, NO_LOCATION, POP_TOP); // lasti - ADDOP_JUMP(c, NO_LOCATION, JUMP, except); + _ADDOP_I(c, NO_LOCATION, LIST_APPEND, 3); // exc + _ADDOP(c, NO_LOCATION, POP_TOP); // lasti + _ADDOP_JUMP(c, NO_LOCATION, JUMP, except); USE_LABEL(c, except); if (i == n - 1) { /* Add exc to the list (if not None it's the unhandled part of the EG) */ - ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1); - ADDOP_JUMP(c, NO_LOCATION, JUMP, reraise_star); + _ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, reraise_star); } } /* artificial */ @@ -3822,27 +3822,27 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, reraise); USE_LABEL(c, reraise_star); - ADDOP(c, NO_LOCATION, PREP_RERAISE_STAR); - ADDOP_I(c, NO_LOCATION, COPY, 1); - ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_NOT_NONE, reraise); + _ADDOP(c, NO_LOCATION, PREP_RERAISE_STAR); + _ADDOP_I(c, NO_LOCATION, COPY, 1); + _ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_NOT_NONE, reraise); /* Nothing to reraise */ - ADDOP(c, NO_LOCATION, POP_TOP); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP(c, NO_LOCATION, POP_EXCEPT); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP(c, NO_LOCATION, POP_TOP); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_EXCEPT); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, reraise); - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP_I(c, NO_LOCATION, SWAP, 2); - ADDOP(c, NO_LOCATION, POP_EXCEPT); - ADDOP_I(c, NO_LOCATION, RERAISE, 0); + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP_I(c, NO_LOCATION, SWAP, 2); + _ADDOP(c, NO_LOCATION, POP_EXCEPT); + _ADDOP_I(c, NO_LOCATION, RERAISE, 0); USE_LABEL(c, cleanup); - POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, orelse); - VISIT_SEQ(c, stmt, s->v.TryStar.orelse); + _VISIT_SEQ(c, stmt, s->v.TryStar.orelse); USE_LABEL(c, end); return 1; @@ -3892,17 +3892,17 @@ compiler_import_as(struct compiler *c, location loc, attr = PyUnicode_Substring(name, pos, (dot != -1) ? dot : len); if (!attr) return 0; - ADDOP_N(c, loc, IMPORT_FROM, attr, names); + _ADDOP_N(c, loc, IMPORT_FROM, attr, names); if (dot == -1) { break; } - ADDOP_I(c, loc, SWAP, 2); - ADDOP(c, loc, POP_TOP); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP(c, loc, POP_TOP); } if (!compiler_nameop(c, loc, asname, Store)) { return 0; } - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); return 1; } return compiler_nameop(c, loc, asname, Store); @@ -3926,9 +3926,9 @@ compiler_import(struct compiler *c, stmt_ty s) alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i); int r; - ADDOP_LOAD_CONST(c, loc, zero); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADDOP_NAME(c, loc, IMPORT_NAME, alias->name, names); + _ADDOP_LOAD_CONST(c, loc, zero); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_NAME(c, loc, IMPORT_NAME, alias->name, names); if (alias->asname) { r = compiler_import_as(c, loc, alias->name, alias->asname); @@ -3960,7 +3960,7 @@ compiler_from_import(struct compiler *c, stmt_ty s) { Py_ssize_t n = asdl_seq_LEN(s->v.ImportFrom.names); - ADDOP_LOAD_CONST_NEW(c, LOC(s), PyLong_FromLong(s->v.ImportFrom.level)); + _ADDOP_LOAD_CONST_NEW(c, LOC(s), PyLong_FromLong(s->v.ImportFrom.level)); PyObject *names = PyTuple_New(n); if (!names) { @@ -3981,14 +3981,14 @@ compiler_from_import(struct compiler *c, stmt_ty s) return compiler_error(c, LOC(s), "from __future__ imports must occur " "at the beginning of the file"); } - ADDOP_LOAD_CONST_NEW(c, LOC(s), names); + _ADDOP_LOAD_CONST_NEW(c, LOC(s), names); if (s->v.ImportFrom.module) { - ADDOP_NAME(c, LOC(s), IMPORT_NAME, s->v.ImportFrom.module, names); + _ADDOP_NAME(c, LOC(s), IMPORT_NAME, s->v.ImportFrom.module, names); } else { _Py_DECLARE_STR(empty, ""); - ADDOP_NAME(c, LOC(s), IMPORT_NAME, &_Py_STR(empty), names); + _ADDOP_NAME(c, LOC(s), IMPORT_NAME, &_Py_STR(empty), names); } for (Py_ssize_t i = 0; i < n; i++) { alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); @@ -3996,11 +3996,11 @@ compiler_from_import(struct compiler *c, stmt_ty s) if (i == 0 && PyUnicode_READ_CHAR(alias->name, 0) == '*') { assert(n == 1); - ADDOP(c, LOC(s), IMPORT_STAR); + _ADDOP(c, LOC(s), IMPORT_STAR); return 1; } - ADDOP_NAME(c, LOC(s), IMPORT_FROM, alias->name, names); + _ADDOP_NAME(c, LOC(s), IMPORT_FROM, alias->name, names); store_name = alias->name; if (alias->asname) { store_name = alias->asname; @@ -4011,7 +4011,7 @@ compiler_from_import(struct compiler *c, stmt_ty s) } } /* remove imported module */ - ADDOP(c, LOC(s), POP_TOP); + _ADDOP(c, LOC(s), POP_TOP); return 1; } @@ -4038,12 +4038,12 @@ compiler_assert(struct compiler *c, stmt_ty s) if (!compiler_jump_if(c, LOC(s), s->v.Assert.test, end, 1)) { return 0; } - ADDOP(c, LOC(s), LOAD_ASSERTION_ERROR); + _ADDOP(c, LOC(s), LOAD_ASSERTION_ERROR); if (s->v.Assert.msg) { - VISIT(c, expr, s->v.Assert.msg); - ADDOP_I(c, LOC(s), CALL, 0); + _VISIT(c, expr, s->v.Assert.msg); + _ADDOP_I(c, LOC(s), CALL, 0); } - ADDOP_I(c, LOC(s), RAISE_VARARGS, 1); + _ADDOP_I(c, LOC(s), RAISE_VARARGS, 1); USE_LABEL(c, end); return 1; @@ -4053,19 +4053,19 @@ static int compiler_stmt_expr(struct compiler *c, location loc, expr_ty value) { if (c->c_interactive && c->c_nestlevel <= 1) { - VISIT(c, expr, value); - ADDOP(c, loc, PRINT_EXPR); + _VISIT(c, expr, value); + _ADDOP(c, loc, PRINT_EXPR); return 1; } if (value->kind == Constant_kind) { /* ignore constant statement */ - ADDOP(c, loc, NOP); + _ADDOP(c, loc, NOP); return 1; } - VISIT(c, expr, value); - ADDOP(c, NO_LOCATION, POP_TOP); /* artificial */ + _VISIT(c, expr, value); + _ADDOP(c, NO_LOCATION, POP_TOP); /* artificial */ return 1; } @@ -4081,17 +4081,17 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case Return_kind: return compiler_return(c, s); case Delete_kind: - VISIT_SEQ(c, expr, s->v.Delete.targets) + _VISIT_SEQ(c, expr, s->v.Delete.targets) break; case Assign_kind: { Py_ssize_t n = asdl_seq_LEN(s->v.Assign.targets); - VISIT(c, expr, s->v.Assign.value); + _VISIT(c, expr, s->v.Assign.value); for (Py_ssize_t i = 0; i < n; i++) { if (i < n - 1) { - ADDOP_I(c, LOC(s), COPY, 1); + _ADDOP_I(c, LOC(s), COPY, 1); } - VISIT(c, expr, + _VISIT(c, expr, (expr_ty)asdl_seq_GET(s->v.Assign.targets, i)); } break; @@ -4112,14 +4112,14 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) { Py_ssize_t n = 0; if (s->v.Raise.exc) { - VISIT(c, expr, s->v.Raise.exc); + _VISIT(c, expr, s->v.Raise.exc); n++; if (s->v.Raise.cause) { - VISIT(c, expr, s->v.Raise.cause); + _VISIT(c, expr, s->v.Raise.cause); n++; } } - ADDOP_I(c, LOC(s), RAISE_VARARGS, (int)n); + _ADDOP_I(c, LOC(s), RAISE_VARARGS, (int)n); break; } case Try_kind: @@ -4141,7 +4141,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) } case Pass_kind: { - ADDOP(c, LOC(s), NOP); + _ADDOP(c, LOC(s), NOP); break; } case Break_kind: @@ -4234,7 +4234,7 @@ addop_binary(struct compiler *c, location loc, operator_ty binop, inplace ? "inplace" : "binary", binop); return 0; } - ADDOP_I(c, loc, BINARY_OP, oparg); + _ADDOP_I(c, loc, BINARY_OP, oparg); return 1; } @@ -4242,10 +4242,10 @@ addop_binary(struct compiler *c, location loc, operator_ty binop, static int addop_yield(struct compiler *c, location loc) { if (c->u->u_ste->ste_generator && c->u->u_ste->ste_coroutine) { - ADDOP(c, loc, ASYNC_GEN_WRAP); + _ADDOP(c, loc, ASYNC_GEN_WRAP); } - ADDOP_I(c, loc, YIELD_VALUE, 0); - ADDOP_I(c, loc, RESUME, 1); + _ADDOP_I(c, loc, YIELD_VALUE, 0); + _ADDOP_I(c, loc, RESUME, 1); return 1; } @@ -4318,7 +4318,7 @@ compiler_nameop(struct compiler *c, location loc, case Store: op = STORE_FAST; break; case Del: op = DELETE_FAST; break; } - ADDOP_N(c, loc, op, mangled, varnames); + _ADDOP_N(c, loc, op, mangled, varnames); return 1; case OP_GLOBAL: switch (ctx) { @@ -4366,13 +4366,13 @@ compiler_boolop(struct compiler *c, expr_ty e) n = asdl_seq_LEN(s) - 1; assert(n >= 0); for (i = 0; i < n; ++i) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); - ADDOP_JUMP(c, loc, jumpi, end); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); + _ADDOP_JUMP(c, loc, jumpi, end); NEW_JUMP_TARGET_LABEL(c, next); USE_LABEL(c, next); } - VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); USE_LABEL(c, end); return 1; @@ -4395,7 +4395,7 @@ starunpack_helper(struct compiler *c, location loc, PyTuple_SET_ITEM(folded, i, Py_NewRef(val)); } if (tuple && !pushed) { - ADDOP_LOAD_CONST_NEW(c, loc, folded); + _ADDOP_LOAD_CONST_NEW(c, loc, folded); } else { if (add == SET_ADD) { Py_SETREF(folded, PyFrozenSet_New(folded)); @@ -4403,11 +4403,11 @@ starunpack_helper(struct compiler *c, location loc, return 0; } } - ADDOP_I(c, loc, build, pushed); - ADDOP_LOAD_CONST_NEW(c, loc, folded); - ADDOP_I(c, loc, extend, 1); + _ADDOP_I(c, loc, build, pushed); + _ADDOP_LOAD_CONST_NEW(c, loc, folded); + _ADDOP_I(c, loc, extend, 1); if (tuple) { - ADDOP(c, loc, LIST_TO_TUPLE); + _ADDOP(c, loc, LIST_TO_TUPLE); } } return 1; @@ -4425,40 +4425,40 @@ starunpack_helper(struct compiler *c, location loc, if (!seen_star && !big) { for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); - VISIT(c, expr, elt); + _VISIT(c, expr, elt); } if (tuple) { - ADDOP_I(c, loc, BUILD_TUPLE, n+pushed); + _ADDOP_I(c, loc, BUILD_TUPLE, n+pushed); } else { - ADDOP_I(c, loc, build, n+pushed); + _ADDOP_I(c, loc, build, n+pushed); } return 1; } int sequence_built = 0; if (big) { - ADDOP_I(c, loc, build, pushed); + _ADDOP_I(c, loc, build, pushed); sequence_built = 1; } for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); if (elt->kind == Starred_kind) { if (sequence_built == 0) { - ADDOP_I(c, loc, build, i+pushed); + _ADDOP_I(c, loc, build, i+pushed); sequence_built = 1; } - VISIT(c, expr, elt->v.Starred.value); - ADDOP_I(c, loc, extend, 1); + _VISIT(c, expr, elt->v.Starred.value); + _ADDOP_I(c, loc, extend, 1); } else { - VISIT(c, expr, elt); + _VISIT(c, expr, elt); if (sequence_built) { - ADDOP_I(c, loc, add, 1); + _ADDOP_I(c, loc, add, 1); } } } assert(sequence_built); if (tuple) { - ADDOP(c, loc, LIST_TO_TUPLE); + _ADDOP(c, loc, LIST_TO_TUPLE); } return 1; } @@ -4476,7 +4476,7 @@ unpack_helper(struct compiler *c, location loc, asdl_expr_seq *elts) return compiler_error(c, loc, "too many expressions in " "star-unpacking assignment"); - ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); + _ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == Starred_kind) { @@ -4485,7 +4485,7 @@ unpack_helper(struct compiler *c, location loc, asdl_expr_seq *elts) } } if (!seen_star) { - ADDOP_I(c, loc, UNPACK_SEQUENCE, n); + _ADDOP_I(c, loc, UNPACK_SEQUENCE, n); } return 1; } @@ -4497,7 +4497,7 @@ assignment_helper(struct compiler *c, location loc, asdl_expr_seq *elts) RETURN_IF_FALSE(unpack_helper(c, loc, elts)); for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); - VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value); + _VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value); } return 1; } @@ -4515,7 +4515,7 @@ compiler_list(struct compiler *c, expr_ty e) BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0); } else - VISIT_SEQ(c, expr, elts); + _VISIT_SEQ(c, expr, elts); return 1; } @@ -4532,7 +4532,7 @@ compiler_tuple(struct compiler *c, expr_ty e) BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1); } else - VISIT_SEQ(c, expr, elts); + _VISIT_SEQ(c, expr, elts); return 1; } @@ -4565,7 +4565,7 @@ compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end location loc = LOC(e); if (n > 1 && !big && are_all_items_const(e->v.Dict.keys, begin, end)) { for (i = begin; i < end; i++) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); } keys = PyTuple_New(n); if (keys == NULL) { @@ -4575,22 +4575,22 @@ compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end key = ((expr_ty)asdl_seq_GET(e->v.Dict.keys, i))->v.Constant.value; PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key)); } - ADDOP_LOAD_CONST_NEW(c, loc, keys); - ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); + _ADDOP_LOAD_CONST_NEW(c, loc, keys); + _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); return 1; } if (big) { - ADDOP_I(c, loc, BUILD_MAP, 0); + _ADDOP_I(c, loc, BUILD_MAP, 0); } for (i = begin; i < end; i++) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); if (big) { - ADDOP_I(c, loc, MAP_ADD, 1); + _ADDOP_I(c, loc, MAP_ADD, 1); } } if (!big) { - ADDOP_I(c, loc, BUILD_MAP, n); + _ADDOP_I(c, loc, BUILD_MAP, n); } return 1; } @@ -4613,17 +4613,17 @@ compiler_dict(struct compiler *c, expr_ty e) return 0; } if (have_dict) { - ADDOP_I(c, loc, DICT_UPDATE, 1); + _ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; elements = 0; } if (have_dict == 0) { - ADDOP_I(c, loc, BUILD_MAP, 0); + _ADDOP_I(c, loc, BUILD_MAP, 0); have_dict = 1; } - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); - ADDOP_I(c, loc, DICT_UPDATE, 1); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + _ADDOP_I(c, loc, DICT_UPDATE, 1); } else { if (elements*2 > STACK_USE_GUIDELINE) { @@ -4631,7 +4631,7 @@ compiler_dict(struct compiler *c, expr_ty e) return 0; } if (have_dict) { - ADDOP_I(c, loc, DICT_UPDATE, 1); + _ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; elements = 0; @@ -4646,12 +4646,12 @@ compiler_dict(struct compiler *c, expr_ty e) return 0; } if (have_dict) { - ADDOP_I(c, loc, DICT_UPDATE, 1); + _ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; } if (!have_dict) { - ADDOP_I(c, loc, BUILD_MAP, 0); + _ADDOP_I(c, loc, BUILD_MAP, 0); } return 1; } @@ -4665,31 +4665,31 @@ compiler_compare(struct compiler *c, expr_ty e) if (!check_compare(c, e)) { return 0; } - VISIT(c, expr, e->v.Compare.left); + _VISIT(c, expr, e->v.Compare.left); assert(asdl_seq_LEN(e->v.Compare.ops) > 0); n = asdl_seq_LEN(e->v.Compare.ops) - 1; if (n == 0) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); - ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, 0)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); + _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, 0)); } else { NEW_JUMP_TARGET_LABEL(c, cleanup); for (i = 0; i < n; i++) { - VISIT(c, expr, + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); - ADDOP_I(c, loc, SWAP, 2); - ADDOP_I(c, loc, COPY, 2); - ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, i)); - ADDOP_JUMP(c, loc, JUMP_IF_FALSE_OR_POP, cleanup); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP_I(c, loc, COPY, 2); + _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, i)); + _ADDOP_JUMP(c, loc, JUMP_IF_FALSE_OR_POP, cleanup); } - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); - ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, n)); + _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); + _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, n)); NEW_JUMP_TARGET_LABEL(c, end); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, cleanup); - ADDOP_I(c, loc, SWAP, 2); - ADDOP(c, loc, POP_TOP); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP(c, loc, POP_TOP); USE_LABEL(c, end); } @@ -4900,20 +4900,20 @@ maybe_optimize_method_call(struct compiler *c, expr_ty e) } } /* Alright, we can optimize the code. */ - VISIT(c, expr, meth->v.Attribute.value); + _VISIT(c, expr, meth->v.Attribute.value); location loc = LOC(meth); loc = update_start_location_to_match_attr(c, loc, meth); - ADDOP_NAME(c, loc, LOAD_METHOD, meth->v.Attribute.attr, names); - VISIT_SEQ(c, expr, e->v.Call.args); + _ADDOP_NAME(c, loc, LOAD_METHOD, meth->v.Attribute.attr, names); + _VISIT_SEQ(c, expr, e->v.Call.args); if (kwdsl) { - VISIT_SEQ(c, keyword, kwds); + _VISIT_SEQ(c, keyword, kwds); if (!compiler_call_simple_kw_helper(c, loc, kwds, kwdsl)) { return 0; }; } loc = update_start_location_to_match_attr(c, LOC(e), meth); - ADDOP_I(c, loc, CALL, argsl + kwdsl); + _ADDOP_I(c, loc, CALL, argsl + kwdsl); return 1; } @@ -4955,8 +4955,8 @@ compiler_call(struct compiler *c, expr_ty e) return 0; } location loc = LOC(e->v.Call.func); - ADDOP(c, loc, PUSH_NULL); - VISIT(c, expr, e->v.Call.func); + _ADDOP(c, loc, PUSH_NULL); + _VISIT(c, expr, e->v.Call.func); loc = LOC(e); return compiler_call_helper(c, loc, 0, e->v.Call.args, @@ -4970,19 +4970,19 @@ compiler_joined_str(struct compiler *c, expr_ty e) Py_ssize_t value_count = asdl_seq_LEN(e->v.JoinedStr.values); if (value_count > STACK_USE_GUIDELINE) { _Py_DECLARE_STR(empty, ""); - ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); - ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); - ADDOP_I(c, loc, BUILD_LIST, 0); + _ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); + _ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); + _ADDOP_I(c, loc, BUILD_LIST, 0); for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.JoinedStr.values); i++) { - VISIT(c, expr, asdl_seq_GET(e->v.JoinedStr.values, i)); - ADDOP_I(c, loc, LIST_APPEND, 1); + _VISIT(c, expr, asdl_seq_GET(e->v.JoinedStr.values, i)); + _ADDOP_I(c, loc, LIST_APPEND, 1); } - ADDOP_I(c, loc, CALL, 1); + _ADDOP_I(c, loc, CALL, 1); } else { - VISIT_SEQ(c, expr, e->v.JoinedStr.values); + _VISIT_SEQ(c, expr, e->v.JoinedStr.values); if (asdl_seq_LEN(e->v.JoinedStr.values) != 1) { - ADDOP_I(c, loc, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values)); + _ADDOP_I(c, loc, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values)); } } return 1; @@ -5010,7 +5010,7 @@ compiler_formatted_value(struct compiler *c, expr_ty e) int oparg; /* The expression to be formatted. */ - VISIT(c, expr, e->v.FormattedValue.value); + _VISIT(c, expr, e->v.FormattedValue.value); switch (conversion) { case 's': oparg = FVC_STR; break; @@ -5024,13 +5024,13 @@ compiler_formatted_value(struct compiler *c, expr_ty e) } if (e->v.FormattedValue.format_spec) { /* Evaluate the format spec, and update our opcode arg. */ - VISIT(c, expr, e->v.FormattedValue.format_spec); + _VISIT(c, expr, e->v.FormattedValue.format_spec); oparg |= FVS_HAVE_SPEC; } /* And push our opcode and oparg */ location loc = LOC(e); - ADDOP_I(c, loc, FORMAT_VALUE, oparg); + _ADDOP_I(c, loc, FORMAT_VALUE, oparg); return 1; } @@ -5048,7 +5048,7 @@ compiler_subkwargs(struct compiler *c, location loc, if (n > 1 && !big) { for (i = begin; i < end; i++) { kw = asdl_seq_GET(keywords, i); - VISIT(c, expr, kw->value); + _VISIT(c, expr, kw->value); } keys = PyTuple_New(n); if (keys == NULL) { @@ -5058,23 +5058,23 @@ compiler_subkwargs(struct compiler *c, location loc, key = ((keyword_ty) asdl_seq_GET(keywords, i))->arg; PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key)); } - ADDOP_LOAD_CONST_NEW(c, loc, keys); - ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); + _ADDOP_LOAD_CONST_NEW(c, loc, keys); + _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); return 1; } if (big) { - ADDOP_I(c, NO_LOCATION, BUILD_MAP, 0); + _ADDOP_I(c, NO_LOCATION, BUILD_MAP, 0); } for (i = begin; i < end; i++) { kw = asdl_seq_GET(keywords, i); - ADDOP_LOAD_CONST(c, loc, kw->arg); - VISIT(c, expr, kw->value); + _ADDOP_LOAD_CONST(c, loc, kw->arg); + _VISIT(c, expr, kw->value); if (big) { - ADDOP_I(c, NO_LOCATION, MAP_ADD, 1); + _ADDOP_I(c, NO_LOCATION, MAP_ADD, 1); } } if (!big) { - ADDOP_I(c, loc, BUILD_MAP, n); + _ADDOP_I(c, loc, BUILD_MAP, n); } return 1; } @@ -5101,7 +5101,7 @@ compiler_call_simple_kw_helper(struct compiler *c, location loc, return 0; } Py_DECREF(names); - ADDOP_I(c, loc, KW_NAMES, arg); + _ADDOP_I(c, loc, KW_NAMES, arg); return 1; } @@ -5142,22 +5142,22 @@ compiler_call_helper(struct compiler *c, location loc, for (i = 0; i < nelts; i++) { expr_ty elt = asdl_seq_GET(args, i); assert(elt->kind != Starred_kind); - VISIT(c, expr, elt); + _VISIT(c, expr, elt); } if (nkwelts) { - VISIT_SEQ(c, keyword, keywords); + _VISIT_SEQ(c, keyword, keywords); if (!compiler_call_simple_kw_helper(c, loc, keywords, nkwelts)) { return 0; }; } - ADDOP_I(c, loc, CALL, n + nelts + nkwelts); + _ADDOP_I(c, loc, CALL, n + nelts + nkwelts); return 1; ex_call: /* Do positional arguments. */ if (n ==0 && nelts == 1 && ((expr_ty)asdl_seq_GET(args, 0))->kind == Starred_kind) { - VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value); + _VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value); } else if (starunpack_helper(c, loc, args, n, BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1) == 0) { @@ -5178,17 +5178,17 @@ compiler_call_helper(struct compiler *c, location loc, return 0; } if (have_dict) { - ADDOP_I(c, loc, DICT_MERGE, 1); + _ADDOP_I(c, loc, DICT_MERGE, 1); } have_dict = 1; nseen = 0; } if (!have_dict) { - ADDOP_I(c, loc, BUILD_MAP, 0); + _ADDOP_I(c, loc, BUILD_MAP, 0); have_dict = 1; } - VISIT(c, expr, kw->value); - ADDOP_I(c, loc, DICT_MERGE, 1); + _VISIT(c, expr, kw->value); + _ADDOP_I(c, loc, DICT_MERGE, 1); } else { nseen++; @@ -5200,13 +5200,13 @@ compiler_call_helper(struct compiler *c, location loc, return 0; } if (have_dict) { - ADDOP_I(c, loc, DICT_MERGE, 1); + _ADDOP_I(c, loc, DICT_MERGE, 1); } have_dict = 1; } assert(have_dict); } - ADDOP_I(c, loc, CALL_FUNCTION_EX, nkwelts > 0); + _ADDOP_I(c, loc, CALL_FUNCTION_EX, nkwelts > 0); return 1; } @@ -5261,7 +5261,7 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, if (gen_index == 0) { /* Receive outermost iter as an implicit argument */ c->u->u_argcount = 1; - ADDOP_I(c, loc, LOAD_FAST, 0); + _ADDOP_I(c, loc, LOAD_FAST, 0); } else { /* Sub-iter - calculate on the fly */ @@ -5282,21 +5282,21 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, if (asdl_seq_LEN(elts) == 1) { expr_ty elt = asdl_seq_GET(elts, 0); if (elt->kind != Starred_kind) { - VISIT(c, expr, elt); + _VISIT(c, expr, elt); start = NO_LABEL; } } if (IS_LABEL(start)) { - VISIT(c, expr, gen->iter); - ADDOP(c, loc, GET_ITER); + _VISIT(c, expr, gen->iter); + _ADDOP(c, loc, GET_ITER); } } if (IS_LABEL(start)) { depth++; USE_LABEL(c, start); - ADDOP_JUMP(c, loc, FOR_ITER, anchor); + _ADDOP_JUMP(c, loc, FOR_ITER, anchor); } - VISIT(c, expr, gen->target); + _VISIT(c, expr, gen->target); /* XXX this needs to be cleaned up...a lot! */ Py_ssize_t n = asdl_seq_LEN(gen->ifs); @@ -5322,28 +5322,28 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - VISIT(c, expr, elt); - ADDOP_YIELD(c, elt_loc); - ADDOP(c, elt_loc, POP_TOP); + _VISIT(c, expr, elt); + _ADDOP_YIELD(c, elt_loc); + _ADDOP(c, elt_loc, POP_TOP); break; case COMP_LISTCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + _VISIT(c, expr, elt); + _ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); break; case COMP_SETCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + _VISIT(c, expr, elt); + _ADDOP_I(c, elt_loc, SET_ADD, depth + 1); break; case COMP_DICTCOMP: /* With '{k: v}', k is evaluated before v, so we do the same. */ - VISIT(c, expr, elt); - VISIT(c, expr, val); + _VISIT(c, expr, elt); + _VISIT(c, expr, val); elt_loc = LOCATION(elt->lineno, val->end_lineno, elt->col_offset, val->end_col_offset); - ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + _ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); break; default: return 0; @@ -5352,10 +5352,10 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, USE_LABEL(c, if_cleanup); if (IS_LABEL(start)) { - ADDOP_JUMP(c, elt_loc, JUMP, start); + _ADDOP_JUMP(c, elt_loc, JUMP, start); USE_LABEL(c, anchor); - ADDOP(c, NO_LOCATION, END_FOR); + _ADDOP(c, NO_LOCATION, END_FOR); } return 1; @@ -5377,12 +5377,12 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, if (gen_index == 0) { /* Receive outermost iter as an implicit argument */ c->u->u_argcount = 1; - ADDOP_I(c, loc, LOAD_FAST, 0); + _ADDOP_I(c, loc, LOAD_FAST, 0); } else { /* Sub-iter - calculate on the fly */ - VISIT(c, expr, gen->iter); - ADDOP(c, loc, GET_AITER); + _VISIT(c, expr, gen->iter); + _ADDOP(c, loc, GET_AITER); } USE_LABEL(c, start); @@ -5392,12 +5392,12 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, return 0; } - ADDOP_JUMP(c, loc, SETUP_FINALLY, except); - ADDOP(c, loc, GET_ANEXT); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); - ADDOP(c, loc, POP_BLOCK); - VISIT(c, expr, gen->target); + _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + _ADDOP(c, loc, GET_ANEXT); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); + _ADDOP(c, loc, POP_BLOCK); + _VISIT(c, expr, gen->target); Py_ssize_t n = asdl_seq_LEN(gen->ifs); for (Py_ssize_t i = 0; i < n; i++) { @@ -5422,28 +5422,28 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - VISIT(c, expr, elt); - ADDOP_YIELD(c, elt_loc); - ADDOP(c, elt_loc, POP_TOP); + _VISIT(c, expr, elt); + _ADDOP_YIELD(c, elt_loc); + _ADDOP(c, elt_loc, POP_TOP); break; case COMP_LISTCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + _VISIT(c, expr, elt); + _ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); break; case COMP_SETCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + _VISIT(c, expr, elt); + _ADDOP_I(c, elt_loc, SET_ADD, depth + 1); break; case COMP_DICTCOMP: /* With '{k: v}', k is evaluated before v, so we do the same. */ - VISIT(c, expr, elt); - VISIT(c, expr, val); + _VISIT(c, expr, elt); + _VISIT(c, expr, val); elt_loc = LOCATION(elt->lineno, val->end_lineno, elt->col_offset, val->end_col_offset); - ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + _ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); break; default: return 0; @@ -5451,13 +5451,13 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, } USE_LABEL(c, if_cleanup); - ADDOP_JUMP(c, elt_loc, JUMP, start); + _ADDOP_JUMP(c, elt_loc, JUMP, start); compiler_pop_fblock(c, ASYNC_COMPREHENSION_GENERATOR, start); USE_LABEL(c, except); - ADDOP(c, loc, END_ASYNC_FOR); + _ADDOP(c, loc, END_ASYNC_FOR); return 1; } @@ -5512,7 +5512,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, goto error_in_scope; } - ADDOP_I(c, loc, op, 0); + _ADDOP_I(c, loc, op, 0); } if (!compiler_comprehension_generator(c, loc, generators, 0, 0, @@ -5521,7 +5521,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, } if (type != COMP_GENEXP) { - ADDOP(c, LOC(e), RETURN_VALUE); + _ADDOP(c, LOC(e), RETURN_VALUE); } if (type == COMP_GENEXP) { if (!wrap_in_stopiteration_handler(c)) { @@ -5545,21 +5545,21 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, Py_DECREF(qualname); Py_DECREF(co); - VISIT(c, expr, outermost->iter); + _VISIT(c, expr, outermost->iter); loc = LOC(e); if (outermost->is_async) { - ADDOP(c, loc, GET_AITER); + _ADDOP(c, loc, GET_AITER); } else { - ADDOP(c, loc, GET_ITER); + _ADDOP(c, loc, GET_ITER); } - ADDOP_I(c, loc, CALL, 0); + _ADDOP_I(c, loc, CALL, 0); if (is_async_generator && type != COMP_GENEXP) { - ADDOP_I(c, loc, GET_AWAITABLE, 0); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); + _ADDOP_I(c, loc, GET_AWAITABLE, 0); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); } return 1; @@ -5616,7 +5616,7 @@ compiler_dictcomp(struct compiler *c, expr_ty e) static int compiler_visit_keyword(struct compiler *c, keyword_ty k) { - VISIT(c, expr, k->value); + _VISIT(c, expr, k->value); return 1; } @@ -5624,20 +5624,20 @@ compiler_visit_keyword(struct compiler *c, keyword_ty k) static int compiler_with_except_finish(struct compiler *c, jump_target_label cleanup) { NEW_JUMP_TARGET_LABEL(c, suppress); - ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_TRUE, suppress); - ADDOP_I(c, NO_LOCATION, RERAISE, 2); + _ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_TRUE, suppress); + _ADDOP_I(c, NO_LOCATION, RERAISE, 2); USE_LABEL(c, suppress); - ADDOP(c, NO_LOCATION, POP_TOP); /* exc_value */ - ADDOP(c, NO_LOCATION, POP_BLOCK); - ADDOP(c, NO_LOCATION, POP_EXCEPT); - ADDOP(c, NO_LOCATION, POP_TOP); - ADDOP(c, NO_LOCATION, POP_TOP); + _ADDOP(c, NO_LOCATION, POP_TOP); /* exc_value */ + _ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_EXCEPT); + _ADDOP(c, NO_LOCATION, POP_TOP); + _ADDOP(c, NO_LOCATION, POP_TOP); NEW_JUMP_TARGET_LABEL(c, exit); - ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); USE_LABEL(c, cleanup); - POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, exit); return 1; @@ -5686,14 +5686,14 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) NEW_JUMP_TARGET_LABEL(c, cleanup); /* Evaluate EXPR */ - VISIT(c, expr, item->context_expr); + _VISIT(c, expr, item->context_expr); - ADDOP(c, loc, BEFORE_ASYNC_WITH); - ADDOP_I(c, loc, GET_AWAITABLE, 1); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); + _ADDOP(c, loc, BEFORE_ASYNC_WITH); + _ADDOP_I(c, loc, GET_AWAITABLE, 1); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); - ADDOP_JUMP(c, loc, SETUP_WITH, final); + _ADDOP_JUMP(c, loc, SETUP_WITH, final); /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); @@ -5702,17 +5702,17 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) } if (item->optional_vars) { - VISIT(c, expr, item->optional_vars); + _VISIT(c, expr, item->optional_vars); } else { /* Discard result from context.__aenter__() */ - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); } pos++; if (pos == asdl_seq_LEN(s->v.AsyncWith.items)) { /* BLOCK code */ - VISIT_SEQ(c, stmt, s->v.AsyncWith.body) + _VISIT_SEQ(c, stmt, s->v.AsyncWith.body) } else if (!compiler_async_with(c, s, pos)) { return 0; @@ -5720,7 +5720,7 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) compiler_pop_fblock(c, ASYNC_WITH, block); - ADDOP(c, loc, POP_BLOCK); + _ADDOP(c, loc, POP_BLOCK); /* End of body; start the cleanup */ /* For successful outcome: @@ -5728,23 +5728,23 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) */ if(!compiler_call_exit_with_nones(c, loc)) return 0; - ADDOP_I(c, loc, GET_AWAITABLE, 2); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); + _ADDOP_I(c, loc, GET_AWAITABLE, 2); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); - ADDOP_JUMP(c, loc, JUMP, exit); + _ADDOP_JUMP(c, loc, JUMP, exit); /* For exceptional outcome: */ USE_LABEL(c, final); - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - ADDOP(c, loc, PUSH_EXC_INFO); - ADDOP(c, loc, WITH_EXCEPT_START); - ADDOP_I(c, loc, GET_AWAITABLE, 2); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + _ADDOP(c, loc, PUSH_EXC_INFO); + _ADDOP(c, loc, WITH_EXCEPT_START); + _ADDOP_I(c, loc, GET_AWAITABLE, 2); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); compiler_with_except_finish(c, cleanup); USE_LABEL(c, exit); @@ -5786,11 +5786,11 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) NEW_JUMP_TARGET_LABEL(c, cleanup); /* Evaluate EXPR */ - VISIT(c, expr, item->context_expr); + _VISIT(c, expr, item->context_expr); /* Will push bound __exit__ */ location loc = LOC(s); - ADDOP(c, loc, BEFORE_WITH); - ADDOP_JUMP(c, loc, SETUP_WITH, final); + _ADDOP(c, loc, BEFORE_WITH); + _ADDOP_JUMP(c, loc, SETUP_WITH, final); /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); @@ -5799,21 +5799,21 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) } if (item->optional_vars) { - VISIT(c, expr, item->optional_vars); + _VISIT(c, expr, item->optional_vars); } else { /* Discard result from context.__enter__() */ - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); } pos++; if (pos == asdl_seq_LEN(s->v.With.items)) /* BLOCK code */ - VISIT_SEQ(c, stmt, s->v.With.body) + _VISIT_SEQ(c, stmt, s->v.With.body) else if (!compiler_with(c, s, pos)) return 0; - ADDOP(c, NO_LOCATION, POP_BLOCK); + _ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, WITH, block); /* End of body; start the cleanup. */ @@ -5824,15 +5824,15 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) loc = LOC(s); if (!compiler_call_exit_with_nones(c, loc)) return 0; - ADDOP(c, loc, POP_TOP); - ADDOP_JUMP(c, loc, JUMP, exit); + _ADDOP(c, loc, POP_TOP); + _ADDOP_JUMP(c, loc, JUMP, exit); /* For exceptional outcome: */ USE_LABEL(c, final); - ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - ADDOP(c, loc, PUSH_EXC_INFO); - ADDOP(c, loc, WITH_EXCEPT_START); + _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + _ADDOP(c, loc, PUSH_EXC_INFO); + _ADDOP(c, loc, WITH_EXCEPT_START); compiler_with_except_finish(c, cleanup); USE_LABEL(c, exit); @@ -5845,20 +5845,20 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) location loc = LOC(e); switch (e->kind) { case NamedExpr_kind: - VISIT(c, expr, e->v.NamedExpr.value); - ADDOP_I(c, loc, COPY, 1); - VISIT(c, expr, e->v.NamedExpr.target); + _VISIT(c, expr, e->v.NamedExpr.value); + _ADDOP_I(c, loc, COPY, 1); + _VISIT(c, expr, e->v.NamedExpr.target); break; case BoolOp_kind: return compiler_boolop(c, e); case BinOp_kind: - VISIT(c, expr, e->v.BinOp.left); - VISIT(c, expr, e->v.BinOp.right); - ADDOP_BINARY(c, loc, e->v.BinOp.op); + _VISIT(c, expr, e->v.BinOp.left); + _VISIT(c, expr, e->v.BinOp.right); + _ADDOP_BINARY(c, loc, e->v.BinOp.op); break; case UnaryOp_kind: - VISIT(c, expr, e->v.UnaryOp.operand); - ADDOP(c, loc, unaryop(e->v.UnaryOp.op)); + _VISIT(c, expr, e->v.UnaryOp.operand); + _ADDOP(c, loc, unaryop(e->v.UnaryOp.op)); break; case Lambda_kind: return compiler_lambda(c, e); @@ -5880,12 +5880,12 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) if (c->u->u_ste->ste_type != FunctionBlock) return compiler_error(c, loc, "'yield' outside function"); if (e->v.Yield.value) { - VISIT(c, expr, e->v.Yield.value); + _VISIT(c, expr, e->v.Yield.value); } else { - ADDOP_LOAD_CONST(c, loc, Py_None); + _ADDOP_LOAD_CONST(c, loc, Py_None); } - ADDOP_YIELD(c, loc); + _ADDOP_YIELD(c, loc); break; case YieldFrom_kind: if (c->u->u_ste->ste_type != FunctionBlock) @@ -5894,10 +5894,10 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) return compiler_error(c, loc, "'yield from' inside async function"); - VISIT(c, expr, e->v.YieldFrom.value); - ADDOP(c, loc, GET_YIELD_FROM_ITER); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 0); + _VISIT(c, expr, e->v.YieldFrom.value); + _ADDOP(c, loc, GET_YIELD_FROM_ITER); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 0); break; case Await_kind: if (!IS_TOP_LEVEL_AWAIT(c)){ @@ -5911,17 +5911,17 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) } } - VISIT(c, expr, e->v.Await.value); - ADDOP_I(c, loc, GET_AWAITABLE, 0); - ADDOP_LOAD_CONST(c, loc, Py_None); - ADD_YIELD_FROM(c, loc, 1); + _VISIT(c, expr, e->v.Await.value); + _ADDOP_I(c, loc, GET_AWAITABLE, 0); + _ADDOP_LOAD_CONST(c, loc, Py_None); + _ADD_YIELD_FROM(c, loc, 1); break; case Compare_kind: return compiler_compare(c, e); case Call_kind: return compiler_call(c, e); case Constant_kind: - ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); + _ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); break; case JoinedStr_kind: return compiler_joined_str(c, e); @@ -5929,21 +5929,21 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) return compiler_formatted_value(c, e); /* The following exprs can be assignment targets. */ case Attribute_kind: - VISIT(c, expr, e->v.Attribute.value); + _VISIT(c, expr, e->v.Attribute.value); loc = LOC(e); loc = update_start_location_to_match_attr(c, loc, e); switch (e->v.Attribute.ctx) { case Load: - ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); + _ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); break; case Store: if (forbidden_name(c, loc, e->v.Attribute.attr, e->v.Attribute.ctx)) { return 0; } - ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); + _ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); break; case Del: - ADDOP_NAME(c, loc, DELETE_ATTR, e->v.Attribute.attr, names); + _ADDOP_NAME(c, loc, DELETE_ATTR, e->v.Attribute.attr, names); break; } break; @@ -5967,7 +5967,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) if (n == 0) { return 0; } - ADDOP_I(c, loc, BUILD_SLICE, n); + _ADDOP_I(c, loc, BUILD_SLICE, n); break; } case Name_kind: @@ -6005,27 +6005,27 @@ compiler_augassign(struct compiler *c, stmt_ty s) switch (e->kind) { case Attribute_kind: - VISIT(c, expr, e->v.Attribute.value); - ADDOP_I(c, loc, COPY, 1); + _VISIT(c, expr, e->v.Attribute.value); + _ADDOP_I(c, loc, COPY, 1); loc = update_start_location_to_match_attr(c, loc, e); - ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); + _ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); break; case Subscript_kind: - VISIT(c, expr, e->v.Subscript.value); + _VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice)) { if (!compiler_slice(c, e->v.Subscript.slice)) { return 0; } - ADDOP_I(c, loc, COPY, 3); - ADDOP_I(c, loc, COPY, 3); - ADDOP_I(c, loc, COPY, 3); - ADDOP(c, loc, BINARY_SLICE); + _ADDOP_I(c, loc, COPY, 3); + _ADDOP_I(c, loc, COPY, 3); + _ADDOP_I(c, loc, COPY, 3); + _ADDOP(c, loc, BINARY_SLICE); } else { - VISIT(c, expr, e->v.Subscript.slice); - ADDOP_I(c, loc, COPY, 2); - ADDOP_I(c, loc, COPY, 2); - ADDOP(c, loc, BINARY_SUBSCR); + _VISIT(c, expr, e->v.Subscript.slice); + _ADDOP_I(c, loc, COPY, 2); + _ADDOP_I(c, loc, COPY, 2); + _ADDOP(c, loc, BINARY_SUBSCR); } break; case Name_kind: @@ -6041,28 +6041,28 @@ compiler_augassign(struct compiler *c, stmt_ty s) loc = LOC(s); - VISIT(c, expr, s->v.AugAssign.value); - ADDOP_INPLACE(c, loc, s->v.AugAssign.op); + _VISIT(c, expr, s->v.AugAssign.value); + _ADDOP_INPLACE(c, loc, s->v.AugAssign.op); loc = LOC(e); switch (e->kind) { case Attribute_kind: loc = update_start_location_to_match_attr(c, loc, e); - ADDOP_I(c, loc, SWAP, 2); - ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); break; case Subscript_kind: if (is_two_element_slice(e->v.Subscript.slice)) { - ADDOP_I(c, loc, SWAP, 4); - ADDOP_I(c, loc, SWAP, 3); - ADDOP_I(c, loc, SWAP, 2); - ADDOP(c, loc, STORE_SLICE); + _ADDOP_I(c, loc, SWAP, 4); + _ADDOP_I(c, loc, SWAP, 3); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP(c, loc, STORE_SLICE); } else { - ADDOP_I(c, loc, SWAP, 3); - ADDOP_I(c, loc, SWAP, 2); - ADDOP(c, loc, STORE_SUBSCR); + _ADDOP_I(c, loc, SWAP, 3); + _ADDOP_I(c, loc, SWAP, 2); + _ADDOP(c, loc, STORE_SUBSCR); } break; case Name_kind: @@ -6076,8 +6076,8 @@ compiler_augassign(struct compiler *c, stmt_ty s) static int check_ann_expr(struct compiler *c, expr_ty e) { - VISIT(c, expr, e); - ADDOP(c, LOC(e), POP_TOP); + _VISIT(c, expr, e); + _ADDOP(c, LOC(e), POP_TOP); return 1; } @@ -6141,8 +6141,8 @@ compiler_annassign(struct compiler *c, stmt_ty s) /* We perform the actual assignment first. */ if (s->v.AnnAssign.value) { - VISIT(c, expr, s->v.AnnAssign.value); - VISIT(c, expr, targ); + _VISIT(c, expr, s->v.AnnAssign.value); + _VISIT(c, expr, targ); } switch (targ->kind) { case Name_kind: @@ -6153,15 +6153,15 @@ compiler_annassign(struct compiler *c, stmt_ty s) (c->u->u_scope_type == COMPILER_SCOPE_MODULE || c->u->u_scope_type == COMPILER_SCOPE_CLASS)) { if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) { - VISIT(c, annexpr, s->v.AnnAssign.annotation) + _VISIT(c, annexpr, s->v.AnnAssign.annotation) } else { - VISIT(c, expr, s->v.AnnAssign.annotation); + _VISIT(c, expr, s->v.AnnAssign.annotation); } - ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names); + _ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names); mangled = _Py_Mangle(c->u->u_private, targ->v.Name.id); - ADDOP_LOAD_CONST_NEW(c, loc, mangled); - ADDOP(c, loc, STORE_SUBSCR); + _ADDOP_LOAD_CONST_NEW(c, loc, mangled); + _ADDOP(c, loc, STORE_SUBSCR); } break; case Attribute_kind: @@ -6273,28 +6273,28 @@ compiler_subscript(struct compiler *c, expr_ty e) } } - VISIT(c, expr, e->v.Subscript.value); + _VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice) && ctx != Del) { if (!compiler_slice(c, e->v.Subscript.slice)) { return 0; } if (ctx == Load) { - ADDOP(c, loc, BINARY_SLICE); + _ADDOP(c, loc, BINARY_SLICE); } else { assert(ctx == Store); - ADDOP(c, loc, STORE_SLICE); + _ADDOP(c, loc, STORE_SLICE); } } else { - VISIT(c, expr, e->v.Subscript.slice); + _VISIT(c, expr, e->v.Subscript.slice); switch (ctx) { case Load: op = BINARY_SUBSCR; break; case Store: op = STORE_SUBSCR; break; case Del: op = DELETE_SUBSCR; break; } assert(op); - ADDOP(c, loc, op); + _ADDOP(c, loc, op); } return 1; } @@ -6309,22 +6309,22 @@ compiler_slice(struct compiler *c, expr_ty s) /* only handles the cases where BUILD_SLICE is emitted */ if (s->v.Slice.lower) { - VISIT(c, expr, s->v.Slice.lower); + _VISIT(c, expr, s->v.Slice.lower); } else { - ADDOP_LOAD_CONST(c, LOC(s), Py_None); + _ADDOP_LOAD_CONST(c, LOC(s), Py_None); } if (s->v.Slice.upper) { - VISIT(c, expr, s->v.Slice.upper); + _VISIT(c, expr, s->v.Slice.upper); } else { - ADDOP_LOAD_CONST(c, LOC(s), Py_None); + _ADDOP_LOAD_CONST(c, LOC(s), Py_None); } if (s->v.Slice.step) { n++; - VISIT(c, expr, s->v.Slice.step); + _VISIT(c, expr, s->v.Slice.step); } return n; } @@ -6383,7 +6383,7 @@ jump_to_fail_pop(struct compiler *c, location loc, // capture on success: Py_ssize_t pops = pc->on_top + PyList_GET_SIZE(pc->stores); RETURN_IF_FALSE(ensure_fail_pop(c, pc, pops)); - ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]); + _ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]); return 1; } @@ -6423,7 +6423,7 @@ static int pattern_helper_rotate(struct compiler *c, location loc, Py_ssize_t count) { while (1 < count) { - ADDOP_I(c, loc, SWAP, count--); + _ADDOP_I(c, loc, SWAP, count--); } return 1; } @@ -6433,7 +6433,7 @@ pattern_helper_store_name(struct compiler *c, location loc, identifier n, pattern_context *pc) { if (n == NULL) { - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); return 1; } if (forbidden_name(c, loc, n, Store)) { @@ -6468,7 +6468,7 @@ pattern_unpack_helper(struct compiler *c, location loc, return compiler_error(c, loc, "too many expressions in " "star-unpacking sequence pattern"); - ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); + _ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == MatchStar_kind) { @@ -6477,7 +6477,7 @@ pattern_unpack_helper(struct compiler *c, location loc, } } if (!seen_star) { - ADDOP_I(c, loc, UNPACK_SEQUENCE, n); + _ADDOP_I(c, loc, UNPACK_SEQUENCE, n); } return 1; } @@ -6521,23 +6521,23 @@ pattern_helper_sequence_subscr(struct compiler *c, location loc, assert(WILDCARD_STAR_CHECK(pattern)); continue; } - ADDOP_I(c, loc, COPY, 1); + _ADDOP_I(c, loc, COPY, 1); if (i < star) { - ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(i)); + _ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(i)); } else { // The subject may not support negative indexing! Compute a // nonnegative index: - ADDOP(c, loc, GET_LEN); - ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(size - i)); - ADDOP_BINARY(c, loc, Sub); + _ADDOP(c, loc, GET_LEN); + _ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(size - i)); + _ADDOP_BINARY(c, loc, Sub); } - ADDOP(c, loc, BINARY_SUBSCR); + _ADDOP(c, loc, BINARY_SUBSCR); RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); } // Pop the subject, we're done with it: pc->on_top--; - ADDOP(c, loc, POP_TOP); + _ADDOP(c, loc, POP_TOP); return 1; } @@ -6571,7 +6571,7 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) } // Need to make a copy for (possibly) storing later: pc->on_top++; - ADDOP_I(c, LOC(p), COPY, 1); + _ADDOP_I(c, LOC(p), COPY, 1); RETURN_IF_FALSE(compiler_pattern(c, p->v.MatchAs.pattern, pc)); // Success! Store it: pc->on_top--; @@ -6634,7 +6634,7 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) if (nattrs) { RETURN_IF_FALSE(!validate_kwd_attrs(c, kwd_attrs, kwd_patterns)); } - VISIT(c, expr, p->v.MatchClass.cls); + _VISIT(c, expr, p->v.MatchClass.cls); PyObject *attr_names; RETURN_IF_FALSE(attr_names = PyTuple_New(nattrs)); Py_ssize_t i; @@ -6642,15 +6642,15 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) PyObject *name = asdl_seq_GET(kwd_attrs, i); PyTuple_SET_ITEM(attr_names, i, Py_NewRef(name)); } - ADDOP_LOAD_CONST_NEW(c, LOC(p), attr_names); - ADDOP_I(c, LOC(p), MATCH_CLASS, nargs); - ADDOP_I(c, LOC(p), COPY, 1); - ADDOP_LOAD_CONST(c, LOC(p), Py_None); - ADDOP_I(c, LOC(p), IS_OP, 1); + _ADDOP_LOAD_CONST_NEW(c, LOC(p), attr_names); + _ADDOP_I(c, LOC(p), MATCH_CLASS, nargs); + _ADDOP_I(c, LOC(p), COPY, 1); + _ADDOP_LOAD_CONST(c, LOC(p), Py_None); + _ADDOP_I(c, LOC(p), IS_OP, 1); // TOS is now a tuple of (nargs + nattrs) attributes (or None): pc->on_top++; RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); - ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, nargs + nattrs); + _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, nargs + nattrs); pc->on_top += nargs + nattrs - 1; for (i = 0; i < nargs + nattrs; i++) { pc->on_top--; @@ -6664,7 +6664,7 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) pattern = asdl_seq_GET(kwd_patterns, i - nargs); } if (WILDCARD_CHECK(pattern)) { - ADDOP(c, LOC(p), POP_TOP); + _ADDOP(c, LOC(p), POP_TOP); continue; } RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); @@ -6692,19 +6692,19 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, PyObject *star_target = p->v.MatchMapping.rest; // We need to keep the subject on top during the mapping and length checks: pc->on_top++; - ADDOP(c, LOC(p), MATCH_MAPPING); + _ADDOP(c, LOC(p), MATCH_MAPPING); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); if (!size && !star_target) { // If the pattern is just "{}", we're done! Pop the subject: pc->on_top--; - ADDOP(c, LOC(p), POP_TOP); + _ADDOP(c, LOC(p), POP_TOP); return 1; } if (size) { // If the pattern has any keys in it, perform a length check: - ADDOP(c, LOC(p), GET_LEN); - ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); - ADDOP_COMPARE(c, LOC(p), GtE); + _ADDOP(c, LOC(p), GET_LEN); + _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); + _ADDOP_COMPARE(c, LOC(p), GtE); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } if (INT_MAX < size - 1) { @@ -6759,17 +6759,17 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // all keys have been checked; there are no duplicates Py_DECREF(seen); - ADDOP_I(c, LOC(p), BUILD_TUPLE, size); - ADDOP(c, LOC(p), MATCH_KEYS); + _ADDOP_I(c, LOC(p), BUILD_TUPLE, size); + _ADDOP(c, LOC(p), MATCH_KEYS); // There's now a tuple of keys and a tuple of values on top of the subject: pc->on_top += 2; - ADDOP_I(c, LOC(p), COPY, 1); - ADDOP_LOAD_CONST(c, LOC(p), Py_None); - ADDOP_I(c, LOC(p), IS_OP, 1); + _ADDOP_I(c, LOC(p), COPY, 1); + _ADDOP_LOAD_CONST(c, LOC(p), Py_None); + _ADDOP_I(c, LOC(p), IS_OP, 1); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); // So far so good. Use that tuple of values on the stack to match // sub-patterns against: - ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); + _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); pc->on_top += size - 1; for (Py_ssize_t i = 0; i < size; i++) { pc->on_top--; @@ -6786,20 +6786,20 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // rest = dict(TOS1) // for key in TOS: // del rest[key] - ADDOP_I(c, LOC(p), BUILD_MAP, 0); // [subject, keys, empty] - ADDOP_I(c, LOC(p), SWAP, 3); // [empty, keys, subject] - ADDOP_I(c, LOC(p), DICT_UPDATE, 2); // [copy, keys] - ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); // [copy, keys...] + _ADDOP_I(c, LOC(p), BUILD_MAP, 0); // [subject, keys, empty] + _ADDOP_I(c, LOC(p), SWAP, 3); // [empty, keys, subject] + _ADDOP_I(c, LOC(p), DICT_UPDATE, 2); // [copy, keys] + _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); // [copy, keys...] while (size) { - ADDOP_I(c, LOC(p), COPY, 1 + size--); // [copy, keys..., copy] - ADDOP_I(c, LOC(p), SWAP, 2); // [copy, keys..., copy, key] - ADDOP(c, LOC(p), DELETE_SUBSCR); // [copy, keys...] + _ADDOP_I(c, LOC(p), COPY, 1 + size--); // [copy, keys..., copy] + _ADDOP_I(c, LOC(p), SWAP, 2); // [copy, keys..., copy, key] + _ADDOP(c, LOC(p), DELETE_SUBSCR); // [copy, keys...] } RETURN_IF_FALSE(pattern_helper_store_name(c, LOC(p), star_target, pc)); } else { - ADDOP(c, LOC(p), POP_TOP); // Tuple of keys. - ADDOP(c, LOC(p), POP_TOP); // Subject. + _ADDOP(c, LOC(p), POP_TOP); // Tuple of keys. + _ADDOP(c, LOC(p), POP_TOP); // Subject. } return 1; @@ -6948,7 +6948,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) Py_DECREF(control); // NOTE: Returning macros are safe again. // Pop the copy of the subject: - ADDOP(c, LOC(p), POP_TOP); + _ADDOP(c, LOC(p), POP_TOP); return 1; diff: compiler_error(c, LOC(p), "alternative patterns bind different names"); @@ -6987,27 +6987,27 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, } // We need to keep the subject on top during the sequence and length checks: pc->on_top++; - ADDOP(c, LOC(p), MATCH_SEQUENCE); + _ADDOP(c, LOC(p), MATCH_SEQUENCE); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); if (star < 0) { // No star: len(subject) == size - ADDOP(c, LOC(p), GET_LEN); - ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); - ADDOP_COMPARE(c, LOC(p), Eq); + _ADDOP(c, LOC(p), GET_LEN); + _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); + _ADDOP_COMPARE(c, LOC(p), Eq); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } else if (size > 1) { // Star: len(subject) >= size - 1 - ADDOP(c, LOC(p), GET_LEN); - ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size - 1)); - ADDOP_COMPARE(c, LOC(p), GtE); + _ADDOP(c, LOC(p), GET_LEN); + _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size - 1)); + _ADDOP_COMPARE(c, LOC(p), GtE); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } // Whatever comes next should consume the subject: pc->on_top--; if (only_wildcard) { // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc. - ADDOP(c, LOC(p), POP_TOP); + _ADDOP(c, LOC(p), POP_TOP); } else if (star_wildcard) { RETURN_IF_FALSE(pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); @@ -7027,8 +7027,8 @@ compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc) const char *e = "patterns may only match literals and attribute lookups"; return compiler_error(c, LOC(p), e); } - VISIT(c, expr, value); - ADDOP_COMPARE(c, LOC(p), Eq); + _VISIT(c, expr, value); + _ADDOP_COMPARE(c, LOC(p), Eq); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); return 1; } @@ -7037,8 +7037,8 @@ static int compiler_pattern_singleton(struct compiler *c, pattern_ty p, pattern_context *pc) { assert(p->kind == MatchSingleton_kind); - ADDOP_LOAD_CONST(c, LOC(p), p->v.MatchSingleton.value); - ADDOP_COMPARE(c, LOC(p), Is); + _ADDOP_LOAD_CONST(c, LOC(p), p->v.MatchSingleton.value); + _ADDOP_COMPARE(c, LOC(p), Is); RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); return 1; } @@ -7073,7 +7073,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) static int compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) { - VISIT(c, expr, s->v.Match.subject); + _VISIT(c, expr, s->v.Match.subject); NEW_JUMP_TARGET_LABEL(c, end); Py_ssize_t cases = asdl_seq_LEN(s->v.Match.cases); assert(cases > 0); @@ -7083,7 +7083,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) m = asdl_seq_GET(s->v.Match.cases, i); // Only copy the subject if we're *not* on the last case: if (i != cases - has_default - 1) { - ADDOP_I(c, LOC(m->pattern), COPY, 1); + _ADDOP_I(c, LOC(m->pattern), COPY, 1); } RETURN_IF_FALSE(pc->stores = PyList_New(0)); // Irrefutable cases must be either guarded, last, or both: @@ -7114,10 +7114,10 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) } // Success! Pop the subject off, we're done with it: if (i != cases - has_default - 1) { - ADDOP(c, LOC(m->pattern), POP_TOP); + _ADDOP(c, LOC(m->pattern), POP_TOP); } - VISIT_SEQ(c, stmt, m->body); - ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + _VISIT_SEQ(c, stmt, m->body); + _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); // If the pattern fails to match, we want the line number of the // cleanup to be associated with the failed pattern, not the last line // of the body @@ -7129,16 +7129,16 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) m = asdl_seq_GET(s->v.Match.cases, cases - 1); if (cases == 1) { // No matches. Done with the subject: - ADDOP(c, LOC(m->pattern), POP_TOP); + _ADDOP(c, LOC(m->pattern), POP_TOP); } else { // Show line coverage for default case (it doesn't create bytecode) - ADDOP(c, LOC(m->pattern), NOP); + _ADDOP(c, LOC(m->pattern), NOP); } if (m->guard) { RETURN_IF_FALSE(compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)); } - VISIT_SEQ(c, stmt, m->body); + _VISIT_SEQ(c, stmt, m->body); } USE_LABEL(c, end); return 1; @@ -8830,9 +8830,9 @@ assemble(struct compiler *c, int addNone) /* Make sure every block that falls off the end returns None. */ if (!basicblock_returns(CFG_BUILDER(c)->g_curblock)) { if (addNone) { - ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); } - ADDOP(c, NO_LOCATION, RETURN_VALUE); + _ADDOP(c, NO_LOCATION, RETURN_VALUE); } int nblocks = 0; From 4ca4b8c2f204a1b447524748a96cc76ca0a26523 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:32:54 +0000 Subject: [PATCH 12/93] add new versions of the macros (not used yet) --- Python/compile.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) diff --git a/Python/compile.c b/Python/compile.c index 27efd2740aede5..a41a841ab54215 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1609,6 +1609,123 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return cfg_builder_addop(g, opcode, target.id, loc); } +#define ADDOP(C, LOC, OP) \ + RETURN_IF_ERROR(cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))); + +#define ADDOP_IN_SCOPE(C, LOC, OP) { \ + if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \ + compiler_exit_scope(c); \ + return -1; \ + } \ +} + +#define ADDOP_LOAD_CONST(C, LOC, O) \ + RETURN_IF_ERROR(compiler_addop_load_const((C), (LOC), (O))); + +/* Same as ADDOP_LOAD_CONST, but steals a reference. */ +#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \ + PyObject *__new_const = (O); \ + if (__new_const == NULL) { \ + return ERROR; \ + } \ + if (compiler_addop_load_const((C), (LOC), __new_const) < 0) { \ + Py_DECREF(__new_const); \ + return ERROR; \ + } \ + Py_DECREF(__new_const); \ +} + +#define ADDOP_N(C, LOC, OP, O, TYPE) { \ + assert(!HAS_CONST(OP)); /* use _ADDOP_LOAD_CONST_NEW */ \ + if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \ + Py_DECREF((O)); \ + return ERROR; \ + } \ + Py_DECREF((O)); \ +} + +#define ADDOP_NAME(C, LOC, OP, O, TYPE) \ + RETURN_IF_ERROR(compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))); + +#define ADDOP_I(C, LOC, OP, O) \ + RETURN_IF_ERROR(cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC))); + +#define ADDOP_JUMP(C, LOC, OP, O) \ + RETURN_IF_ERROR(cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))); + +#define ADDOP_COMPARE(C, LOC, CMP) { \ + if (!compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))) \ + return ERROR; \ +} + +#define ADDOP_BINARY(C, LOC, BINOP) { \ + if (!addop_binary((C), (LOC), (BINOP), false)) \ + return ERROR; \ +} + +#define ADDOP_INPLACE(C, LOC, BINOP) { \ + if (!addop_binary((C), (LOC), (BINOP), true)) \ + return ERROR; \ +} + +#define ADD_YIELD_FROM(C, LOC, await) { \ + if (! compiler_add_yield_from((C), (LOC), (await))) \ + return ERROR; \ +} + +#define POP_EXCEPT_AND_RERAISE(C, LOC) { \ + if (!compiler_pop_except_and_reraise((C), (LOC))) \ + return ERROR; \ +} + +#define ADDOP_YIELD(C, LOC) { \ + if (!addop_yield((C), (LOC))) \ + return ERROR; \ +} + +/* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use + the ASDL name to synthesize the name of the C type and the visit function. +*/ + +#define VISIT(C, TYPE, V) {\ + if (!compiler_visit_ ## TYPE((C), (V))) \ + return ERROR; \ +} + +#define VISIT_IN_SCOPE(C, TYPE, V) {\ + if (!compiler_visit_ ## TYPE((C), (V))) { \ + compiler_exit_scope(c); \ + return ERROR; \ + } \ +} + +#define VISIT_SEQ(C, TYPE, SEQ) { \ + int _i; \ + asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ + for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ + TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ + if (!compiler_visit_ ## TYPE((C), elt)) \ + return ERROR; \ + } \ +} + +#define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ + int _i; \ + asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ + for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ + TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ + if (!compiler_visit_ ## TYPE((C), elt)) { \ + compiler_exit_scope(c); \ + return ERROR; \ + } \ + } \ +} + + +/*******************/ + + + #define _ADDOP(C, LOC, OP) { \ if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) \ From 9baeb63222985bf754f5f198906186fdc611a5f8 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:36:01 +0000 Subject: [PATCH 13/93] compiler_enter_scope returns SUCCESS/ERROR --- Python/compile.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a41a841ab54215..a742508aefa68a 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1856,7 +1856,7 @@ compiler_enter_scope(struct compiler *c, identifier name, struct compiler_unit)); if (!u) { PyErr_NoMemory(); - return 0; + return ERROR; } u->u_scope_type = scope_type; u->u_argcount = 0; @@ -1865,14 +1865,14 @@ compiler_enter_scope(struct compiler *c, identifier name, u->u_ste = PySymtable_Lookup(c->c_st, key); if (!u->u_ste) { compiler_unit_free(u); - return 0; + return ERROR; } u->u_name = Py_NewRef(name); u->u_varnames = list2dict(u->u_ste->ste_varnames); u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0); if (!u->u_varnames || !u->u_cellvars) { compiler_unit_free(u); - return 0; + return ERROR; } if (u->u_ste->ste_needs_class_closure) { /* Cook up an implicit __class__ cell. */ @@ -1883,7 +1883,7 @@ compiler_enter_scope(struct compiler *c, identifier name, _PyLong_GetZero()); if (res < 0) { compiler_unit_free(u); - return 0; + return ERROR; } } @@ -1891,7 +1891,7 @@ compiler_enter_scope(struct compiler *c, identifier name, PyDict_GET_SIZE(u->u_cellvars)); if (!u->u_freevars) { compiler_unit_free(u); - return 0; + return ERROR; } u->u_nfblocks = 0; @@ -1899,12 +1899,12 @@ compiler_enter_scope(struct compiler *c, identifier name, u->u_consts = PyDict_New(); if (!u->u_consts) { compiler_unit_free(u); - return 0; + return ERROR; } u->u_names = PyDict_New(); if (!u->u_names) { compiler_unit_free(u); - return 0; + return ERROR; } u->u_private = NULL; @@ -1915,7 +1915,7 @@ compiler_enter_scope(struct compiler *c, identifier name, if (!capsule || PyList_Append(c->c_stack, capsule) < 0) { Py_XDECREF(capsule); compiler_unit_free(u); - return 0; + return ERROR; } Py_DECREF(capsule); u->u_private = Py_XNewRef(c->u->u_private); @@ -1926,7 +1926,7 @@ compiler_enter_scope(struct compiler *c, identifier name, cfg_builder *g = CFG_BUILDER(c); if (cfg_builder_init(g) < 0) { - return 0; + return ERROR; } if (u->u_scope_type == COMPILER_SCOPE_MODULE) { @@ -1934,15 +1934,15 @@ compiler_enter_scope(struct compiler *c, identifier name, } else { if (compiler_set_qualname(c) < 0){ - return 0; + return ERROR; } } - _ADDOP_I(c, loc, RESUME, 0); + ADDOP_I(c, loc, RESUME, 0); if (u->u_scope_type == COMPILER_SCOPE_MODULE) { loc.lineno = -1; } - return 1; + return SUCCESS; } static void @@ -2307,8 +2307,8 @@ static int compiler_codegen(struct compiler *c, mod_ty mod) { _Py_DECLARE_STR(anon_module, ""); - if (!compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE, - mod, 1)) { + if (compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE, + mod, 1) < 0) { return 0; } location loc = LOCATION(1, 1, 0, 0); @@ -2810,7 +2810,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) funcflags |= 0x04; } - if (!compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno)) { + if (compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno) < 0) { return 0; } @@ -2882,8 +2882,8 @@ compiler_class(struct compiler *c, stmt_ty s) This borrows from compiler_call. */ /* 1. compile the class body into a code object */ - if (!compiler_enter_scope(c, s->v.ClassDef.name, - COMPILER_SCOPE_CLASS, (void *)s, firstlineno)) { + if (compiler_enter_scope(c, s->v.ClassDef.name, + COMPILER_SCOPE_CLASS, (void *)s, firstlineno) < 0) { return 0; } /* this block represents what we do in the new scope */ @@ -3195,8 +3195,8 @@ compiler_lambda(struct compiler *c, expr_ty e) } _Py_DECLARE_STR(anon_lambda, ""); - if (!compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA, - (void *)e, e->lineno)) { + if (compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA, + (void *)e, e->lineno) < 0) { return 0; } /* Make None the first constant, so the lambda can't have a @@ -5592,8 +5592,8 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, int is_top_level_await = IS_TOP_LEVEL_AWAIT(c); outermost = (comprehension_ty) asdl_seq_GET(generators, 0); - if (!compiler_enter_scope(c, name, COMPILER_SCOPE_COMPREHENSION, - (void *)e, e->lineno)) + if (compiler_enter_scope(c, name, COMPILER_SCOPE_COMPREHENSION, + (void *)e, e->lineno) < 0) { goto error; } From 566acc56ab87fb30b6e6a59062438743ab524c8f Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:38:27 +0000 Subject: [PATCH 14/93] find_add returns bool --- Python/compile.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a742508aefa68a..593e03b1812b49 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1976,7 +1976,7 @@ compiler_exit_scope(struct compiler *c) /* Search if variable annotations are present statically in a block. */ -static int +static bool find_ann(asdl_stmt_seq *stmts) { int i, j, res = 0; @@ -1986,7 +1986,7 @@ find_ann(asdl_stmt_seq *stmts) st = (stmt_ty)asdl_seq_GET(stmts, i); switch (st->kind) { case AnnAssign_kind: - return 1; + return true; case For_kind: res = find_ann(st->v.For.body) || find_ann(st->v.For.orelse); @@ -2014,7 +2014,7 @@ find_ann(asdl_stmt_seq *stmts) excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( st->v.Try.handlers, j); if (find_ann(handler->v.ExceptHandler.body)) { - return 1; + return true; } } res = find_ann(st->v.Try.body) || @@ -2026,7 +2026,7 @@ find_ann(asdl_stmt_seq *stmts) excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( st->v.TryStar.handlers, j); if (find_ann(handler->v.ExceptHandler.body)) { - return 1; + return true; } } res = find_ann(st->v.TryStar.body) || @@ -2034,7 +2034,7 @@ find_ann(asdl_stmt_seq *stmts) find_ann(st->v.TryStar.orelse); break; default: - res = 0; + res = false; } if (res) { break; From 93287a1c15394db5f786460fce21fb2f1f987472 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:46:18 +0000 Subject: [PATCH 15/93] compiler_push_fblock returns SUCCESS/ERROR --- Python/compile.c | 52 +++++++++++++++++++++++++++--------------------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 593e03b1812b49..8f27ae1192345f 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2054,14 +2054,15 @@ compiler_push_fblock(struct compiler *c, location loc, { struct fblockinfo *f; if (c->u->u_nfblocks >= CO_MAXBLOCKS) { - return compiler_error(c, loc, "too many statically nested blocks"); + compiler_error(c, loc, "too many statically nested blocks"); + return ERROR; } f = &c->u->u_fblock[c->u->u_nfblocks++]; f->fb_type = t; f->fb_block = block_label; f->fb_exit = exit; f->fb_datum = datum; - return 1; + return SUCCESS; } static void @@ -2156,7 +2157,7 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, /* This POP_BLOCK gets the line number of the unwinding statement */ _ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { - if (!compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL)) { + if (compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL) < 0) { return 0; } } @@ -3271,7 +3272,7 @@ compiler_for(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); NEW_JUMP_TARGET_LABEL(c, end); - if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) { + if (compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL) < 0) { return 0; } _VISIT(c, expr, s->v.For.iter); @@ -3316,7 +3317,7 @@ compiler_async_for(struct compiler *c, stmt_ty s) _ADDOP(c, loc, GET_AITER); USE_LABEL(c, start); - if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) { + if (compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL) < 0) { return 0; } /* SETUP_FINALLY to guard the __anext__ call */ @@ -3358,7 +3359,7 @@ compiler_while(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, anchor); USE_LABEL(c, loop); - if (!compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL)) { + if (compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL) < 0) { return 0; } if (!compiler_jump_if(c, LOC(s), s->v.While.test, anchor, 0)) { @@ -3515,8 +3516,9 @@ compiler_try_finally(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); - if (!compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.Try.finalbody)) + if (compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.Try.finalbody) < 0) { return 0; + } if (s->v.Try.handlers && asdl_seq_LEN(s->v.Try.handlers)) { if (!compiler_try_except(c, s)) return 0; @@ -3536,8 +3538,9 @@ compiler_try_finally(struct compiler *c, stmt_ty s) loc = NO_LOCATION; _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); _ADDOP(c, loc, PUSH_EXC_INFO); - if (!compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)) + if (compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL) < 0) { return 0; + } _VISIT_SEQ(c, stmt, s->v.Try.finalbody); loc = location_of_last_executing_statement(s->v.Try.finalbody); compiler_pop_fblock(c, FINALLY_END, end); @@ -3564,7 +3567,7 @@ compiler_try_star_finally(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); - if (!compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.TryStar.finalbody)) { + if (compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.TryStar.finalbody) < 0) { return 0; } if (s->v.TryStar.handlers && asdl_seq_LEN(s->v.TryStar.handlers)) { @@ -3587,7 +3590,7 @@ compiler_try_star_finally(struct compiler *c, stmt_ty s) loc = NO_LOCATION; _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); _ADDOP(c, loc, PUSH_EXC_INFO); - if (!compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)) { + if (compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL) < 0) { return 0; } _VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); @@ -3646,8 +3649,9 @@ compiler_try_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); - if (!compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)) + if (compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL) < 0) { return 0; + } _VISIT_SEQ(c, stmt, s->v.Try.body); compiler_pop_fblock(c, TRY_EXCEPT, body); _ADDOP(c, NO_LOCATION, POP_BLOCK); @@ -3662,8 +3666,9 @@ compiler_try_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); /* Runtime will push a block here, so we need to account for that */ - if (!compiler_push_fblock(c, loc, EXCEPTION_HANDLER, NO_LABEL, NO_LABEL, NULL)) + if (compiler_push_fblock(c, loc, EXCEPTION_HANDLER, NO_LABEL, NO_LABEL, NULL) < 0) { return 0; + } for (i = 0; i < n; i++) { excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( s->v.Try.handlers, i); @@ -3699,8 +3704,8 @@ compiler_try_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); - if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, - NO_LABEL, handler->v.ExceptHandler.name)) { + if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, + NO_LABEL, handler->v.ExceptHandler.name) < 0) { return 0; } @@ -3732,8 +3737,9 @@ compiler_try_except(struct compiler *c, stmt_ty s) _ADDOP(c, loc, POP_TOP); /* exc_value */ USE_LABEL(c, cleanup_body); - if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, NULL)) + if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, NULL) < 0) { return 0; + } _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); _ADDOP(c, NO_LOCATION, POP_BLOCK); @@ -3818,7 +3824,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); - if (!compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)) { + if (compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL) < 0) { return 0; } _VISIT_SEQ(c, stmt, s->v.TryStar.body); @@ -3832,8 +3838,8 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); /* Runtime will push a block here, so we need to account for that */ - if (!compiler_push_fblock(c, loc, EXCEPTION_GROUP_HANDLER, - NO_LABEL, NO_LABEL, "except handler")) { + if (compiler_push_fblock(c, loc, EXCEPTION_GROUP_HANDLER, + NO_LABEL, NO_LABEL, "except handler") < 0) { return 0; } for (Py_ssize_t i = 0; i < n; i++) { @@ -3895,7 +3901,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); - if (!compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, handler->v.ExceptHandler.name)) { + if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, handler->v.ExceptHandler.name) < 0) { return 0; } @@ -5504,8 +5510,8 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, USE_LABEL(c, start); /* Runtime will push a block here, so we need to account for that */ - if (!compiler_push_fblock(c, loc, ASYNC_COMPREHENSION_GENERATOR, - start, NO_LABEL, NULL)) { + if (compiler_push_fblock(c, loc, ASYNC_COMPREHENSION_GENERATOR, + start, NO_LABEL, NULL) < 0) { return 0; } @@ -5814,7 +5820,7 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); - if (!compiler_push_fblock(c, loc, ASYNC_WITH, block, final, s)) { + if (compiler_push_fblock(c, loc, ASYNC_WITH, block, final, s) < 0) { return 0; } @@ -5911,7 +5917,7 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); - if (!compiler_push_fblock(c, loc, WITH, block, final, s)) { + if (compiler_push_fblock(c, loc, WITH, block, final, s) < 0) { return 0; } From 851538020ffe0ecb9675c74bef4ca0a063447be6 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:48:58 +0000 Subject: [PATCH 16/93] compiler_call_exit_with_nones returns SUCCESS/ERROR --- Python/compile.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 8f27ae1192345f..7ce6e405823a46 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2078,11 +2078,11 @@ compiler_pop_fblock(struct compiler *c, enum fblocktype t, jump_target_label blo static int compiler_call_exit_with_nones(struct compiler *c, location loc) { - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADDOP_I(c, loc, CALL, 2); - return 1; + ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_I(c, loc, CALL, 2); + return SUCCESS; } static int @@ -2191,7 +2191,7 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, if (preserve_tos) { _ADDOP_I(c, *ploc, SWAP, 2); } - if(!compiler_call_exit_with_nones(c, *ploc)) { + if (compiler_call_exit_with_nones(c, *ploc) < 0) { return 0; } if (info->fb_type == ASYNC_WITH) { @@ -5849,8 +5849,9 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) /* For successful outcome: * call __exit__(None, None, None) */ - if(!compiler_call_exit_with_nones(c, loc)) + if (compiler_call_exit_with_nones(c, loc) < 0) { return 0; + } _ADDOP_I(c, loc, GET_AWAITABLE, 2); _ADDOP_LOAD_CONST(c, loc, Py_None); _ADD_YIELD_FROM(c, loc, 1); @@ -5945,8 +5946,9 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) * call __exit__(None, None, None) */ loc = LOC(s); - if (!compiler_call_exit_with_nones(c, loc)) + if (compiler_call_exit_with_nones(c, loc) < 0) { return 0; + } _ADDOP(c, loc, POP_TOP); _ADDOP_JUMP(c, loc, JUMP, exit); From 13583a34967caa1027a373db12f1267c79b35b10 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:53:42 +0000 Subject: [PATCH 17/93] pop_except_and_reraise returns SUCCESS/ERROR --- Python/compile.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7ce6e405823a46..28a09f63369c80 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1673,10 +1673,8 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return ERROR; \ } -#define POP_EXCEPT_AND_RERAISE(C, LOC) { \ - if (!compiler_pop_except_and_reraise((C), (LOC))) \ - return ERROR; \ -} +#define POP_EXCEPT_AND_RERAISE(C, LOC) \ + RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))); #define ADDOP_YIELD(C, LOC) { \ if (!addop_yield((C), (LOC))) \ @@ -1795,8 +1793,10 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define _ADD_YIELD_FROM(C, LOC, await) \ RETURN_IF_FALSE(compiler_add_yield_from((C), (LOC), (await))) -#define _POP_EXCEPT_AND_RERAISE(C, LOC) \ - RETURN_IF_FALSE(compiler_pop_except_and_reraise((C), (LOC))) +#define _POP_EXCEPT_AND_RERAISE(C, LOC) { \ + if (compiler_pop_except_and_reraise((C), (LOC)) < 0) \ + return 0; \ +} #define _ADDOP_YIELD(C, LOC) \ RETURN_IF_FALSE(addop_yield((C), (LOC))) @@ -2119,10 +2119,10 @@ compiler_pop_except_and_reraise(struct compiler *c, location loc) * (exception_unwind clears the stack) */ - _ADDOP_I(c, loc, COPY, 3); - _ADDOP(c, loc, POP_EXCEPT); - _ADDOP_I(c, loc, RERAISE, 1); - return 1; + ADDOP_I(c, loc, COPY, 3); + ADDOP(c, loc, POP_EXCEPT); + ADDOP_I(c, loc, RERAISE, 1); + return SUCCESS; } /* Unwind a frame block. If preserve_tos is true, the TOS before From 1fd574a3fe2257ef8507879703fa2663b891f1cb Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 17:57:23 +0000 Subject: [PATCH 18/93] compiler_add_yield_from returns SUCCESS/ERROR --- Python/compile.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 28a09f63369c80..4a4b030e3ee321 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1668,10 +1668,8 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return ERROR; \ } -#define ADD_YIELD_FROM(C, LOC, await) { \ - if (! compiler_add_yield_from((C), (LOC), (await))) \ - return ERROR; \ -} +#define ADD_YIELD_FROM(C, LOC, await) \ + RETURN_IF_ERROR(compiler_add_yield_from((C), (LOC), (await))); #define POP_EXCEPT_AND_RERAISE(C, LOC) \ RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))); @@ -1790,8 +1788,10 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define _ADDOP_INPLACE(C, LOC, BINOP) \ RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), true)) -#define _ADD_YIELD_FROM(C, LOC, await) \ - RETURN_IF_FALSE(compiler_add_yield_from((C), (LOC), (await))) +#define _ADD_YIELD_FROM(C, LOC, await) { \ + if (compiler_add_yield_from((C), (LOC), (await)) < 0) \ + return 0; \ +} #define _POP_EXCEPT_AND_RERAISE(C, LOC) { \ if (compiler_pop_except_and_reraise((C), (LOC)) < 0) \ @@ -2093,20 +2093,20 @@ compiler_add_yield_from(struct compiler *c, location loc, int await) NEW_JUMP_TARGET_LABEL(c, exit); USE_LABEL(c, send); - _ADDOP_JUMP(c, loc, SEND, exit); + ADDOP_JUMP(c, loc, SEND, exit); // Set up a virtual try/except to handle when StopIteration is raised during // a close or throw call. The only way YIELD_VALUE raises if they do! - _ADDOP_JUMP(c, loc, SETUP_FINALLY, fail); - _ADDOP_I(c, loc, YIELD_VALUE, 0); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP_I(c, loc, RESUME, await ? 3 : 2); - _ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send); + ADDOP_JUMP(c, loc, SETUP_FINALLY, fail); + ADDOP_I(c, loc, YIELD_VALUE, 0); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP_I(c, loc, RESUME, await ? 3 : 2); + ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send); USE_LABEL(c, fail); - _ADDOP(c, loc, CLEANUP_THROW); + ADDOP(c, loc, CLEANUP_THROW); USE_LABEL(c, exit); - return 1; + return SUCCESS; } static int From a3d5cad2c845def8cfe2bdb8fe3ec1a4e4e58735 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:02:13 +0000 Subject: [PATCH 19/93] compiler_unwind_fblock returns SUCCESS/ERROR --- Python/compile.c | 70 ++++++++++++++++++++++++------------------------ 1 file changed, 35 insertions(+), 35 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 4a4b030e3ee321..006df4ed609e8e 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2139,30 +2139,30 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, case EXCEPTION_HANDLER: case EXCEPTION_GROUP_HANDLER: case ASYNC_COMPREHENSION_GENERATOR: - return 1; + return SUCCESS; case FOR_LOOP: /* Pop the iterator */ if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } - _ADDOP(c, *ploc, POP_TOP); - return 1; + ADDOP(c, *ploc, POP_TOP); + return SUCCESS; case TRY_EXCEPT: - _ADDOP(c, *ploc, POP_BLOCK); - return 1; + ADDOP(c, *ploc, POP_BLOCK); + return SUCCESS; case FINALLY_TRY: /* This POP_BLOCK gets the line number of the unwinding statement */ - _ADDOP(c, *ploc, POP_BLOCK); + ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { if (compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL) < 0) { - return 0; + return ERROR; } } /* Emit the finally block */ - _VISIT_SEQ(c, stmt, info->fb_datum); + VISIT_SEQ(c, stmt, info->fb_datum); if (preserve_tos) { compiler_pop_fblock(c, POP_VALUE, NO_LABEL); } @@ -2170,64 +2170,64 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, * statement causing the unwinding, so make the unwinding * instruction artificial */ *ploc = NO_LOCATION; - return 1; + return SUCCESS; case FINALLY_END: if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } - _ADDOP(c, *ploc, POP_TOP); /* exc_value */ + ADDOP(c, *ploc, POP_TOP); /* exc_value */ if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } - _ADDOP(c, *ploc, POP_BLOCK); - _ADDOP(c, *ploc, POP_EXCEPT); - return 1; + ADDOP(c, *ploc, POP_BLOCK); + ADDOP(c, *ploc, POP_EXCEPT); + return SUCCESS; case WITH: case ASYNC_WITH: *ploc = LOC((stmt_ty)info->fb_datum); - _ADDOP(c, *ploc, POP_BLOCK); + ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } if (compiler_call_exit_with_nones(c, *ploc) < 0) { - return 0; + return ERROR; } if (info->fb_type == ASYNC_WITH) { - _ADDOP_I(c, *ploc, GET_AWAITABLE, 2); - _ADDOP_LOAD_CONST(c, *ploc, Py_None); - _ADD_YIELD_FROM(c, *ploc, 1); + ADDOP_I(c, *ploc, GET_AWAITABLE, 2); + ADDOP_LOAD_CONST(c, *ploc, Py_None); + ADD_YIELD_FROM(c, *ploc, 1); } - _ADDOP(c, *ploc, POP_TOP); + ADDOP(c, *ploc, POP_TOP); /* The exit block should appear to execute after the * statement causing the unwinding, so make the unwinding * instruction artificial */ *ploc = NO_LOCATION; - return 1; + return SUCCESS; case HANDLER_CLEANUP: { if (info->fb_datum) { - _ADDOP(c, *ploc, POP_BLOCK); + ADDOP(c, *ploc, POP_BLOCK); } if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } - _ADDOP(c, *ploc, POP_BLOCK); - _ADDOP(c, *ploc, POP_EXCEPT); + ADDOP(c, *ploc, POP_BLOCK); + ADDOP(c, *ploc, POP_EXCEPT); if (info->fb_datum) { - _ADDOP_LOAD_CONST(c, *ploc, Py_None); + ADDOP_LOAD_CONST(c, *ploc, Py_None); compiler_nameop(c, *ploc, info->fb_datum, Store); compiler_nameop(c, *ploc, info->fb_datum, Del); } - return 1; + return SUCCESS; } case POP_VALUE: { if (preserve_tos) { - _ADDOP_I(c, *ploc, SWAP, 2); + ADDOP_I(c, *ploc, SWAP, 2); } - _ADDOP(c, *ploc, POP_TOP); - return 1; + ADDOP(c, *ploc, POP_TOP); + return SUCCESS; } } Py_UNREACHABLE(); @@ -2252,7 +2252,7 @@ compiler_unwind_fblock_stack(struct compiler *c, location *ploc, } struct fblockinfo copy = *top; c->u->u_nfblocks--; - if (!compiler_unwind_fblock(c, ploc, ©, preserve_tos)) { + if (compiler_unwind_fblock(c, ploc, ©, preserve_tos) < 0) { return 0; } if (!compiler_unwind_fblock_stack(c, ploc, preserve_tos, loop)) { @@ -3437,7 +3437,7 @@ compiler_break(struct compiler *c, location loc) if (loop == NULL) { return compiler_error(c, loc, "'break' outside loop"); } - if (!compiler_unwind_fblock(c, &loc, loop, 0)) { + if (compiler_unwind_fblock(c, &loc, loop, 0) < 0) { return 0; } _ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); From 6fe5dd786a387893539f8a486db93100136d8fab Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:06:37 +0000 Subject: [PATCH 20/93] compiler_unwind_fblock_stack returns SUCCESS/ERROR --- Python/compile.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 006df4ed609e8e..5ae46fe978b64c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2239,28 +2239,27 @@ compiler_unwind_fblock_stack(struct compiler *c, location *ploc, int preserve_tos, struct fblockinfo **loop) { if (c->u->u_nfblocks == 0) { - return 1; + return SUCCESS; } struct fblockinfo *top = &c->u->u_fblock[c->u->u_nfblocks-1]; if (top->fb_type == EXCEPTION_GROUP_HANDLER) { - return compiler_error( - c, *ploc, "'break', 'continue' and 'return' cannot appear in an except* block"); + compiler_error(c, *ploc, + "'break', 'continue' and 'return' cannot appear in an except* block"); + return ERROR; } if (loop != NULL && (top->fb_type == WHILE_LOOP || top->fb_type == FOR_LOOP)) { *loop = top; - return 1; + return SUCCESS; } struct fblockinfo copy = *top; c->u->u_nfblocks--; if (compiler_unwind_fblock(c, ploc, ©, preserve_tos) < 0) { - return 0; - } - if (!compiler_unwind_fblock_stack(c, ploc, preserve_tos, loop)) { - return 0; + return ERROR; } + RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, ploc, preserve_tos, loop)); c->u->u_fblock[c->u->u_nfblocks] = copy; c->u->u_nfblocks++; - return 1; + return SUCCESS; } /* Compile a sequence of statements, checking for a docstring @@ -3412,8 +3411,9 @@ compiler_return(struct compiler *c, stmt_ty s) _ADDOP(c, loc, NOP); } - if (!compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL)) + if (compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL) < 0) { return 0; + } if (s->v.Return.value == NULL) { _ADDOP_LOAD_CONST(c, loc, Py_None); } @@ -3431,7 +3431,7 @@ compiler_break(struct compiler *c, location loc) struct fblockinfo *loop = NULL; /* Emit instruction with line number */ _ADDOP(c, loc, NOP); - if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) { + if (compiler_unwind_fblock_stack(c, &loc, 0, &loop) < 0) { return 0; } if (loop == NULL) { @@ -3450,7 +3450,7 @@ compiler_continue(struct compiler *c, location loc) struct fblockinfo *loop = NULL; /* Emit instruction with line number */ _ADDOP(c, loc, NOP); - if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) { + if (compiler_unwind_fblock_stack(c, &loc, 0, &loop) < 0) { return 0; } if (loop == NULL) { From 297a0d69998119c275372db5763235c44343b099 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:20:34 +0000 Subject: [PATCH 21/93] compiler_body returns SUCCESS/ERROR --- Python/compile.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 5ae46fe978b64c..9e0c96febe6683 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2282,10 +2282,11 @@ compiler_body(struct compiler *c, location loc, asdl_stmt_seq *stmts) } /* Every annotated class and module should have __annotations__. */ if (find_ann(stmts)) { - _ADDOP(c, loc, SETUP_ANNOTATIONS); + ADDOP(c, loc, SETUP_ANNOTATIONS); + } + if (!asdl_seq_LEN(stmts)) { + return SUCCESS; } - if (!asdl_seq_LEN(stmts)) - return 1; /* if not -OO mode, set docstring */ if (c->c_optimize < 2) { docstring = _PyAST_GetDocString(stmts); @@ -2293,14 +2294,16 @@ compiler_body(struct compiler *c, location loc, asdl_stmt_seq *stmts) i = 1; st = (stmt_ty)asdl_seq_GET(stmts, 0); assert(st->kind == Expr_kind); - _VISIT(c, expr, st->v.Expr.value); - if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store)) - return 0; + VISIT(c, expr, st->v.Expr.value); + if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store)) { + return ERROR; + } } } - for (; i < asdl_seq_LEN(stmts); i++) - _VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); - return 1; + for (; i < asdl_seq_LEN(stmts); i++) { + VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); + } + return SUCCESS; } static int @@ -2314,7 +2317,7 @@ compiler_codegen(struct compiler *c, mod_ty mod) location loc = LOCATION(1, 1, 0, 0); switch (mod->kind) { case Module_kind: - if (!compiler_body(c, loc, mod->v.Module.body)) { + if (compiler_body(c, loc, mod->v.Module.body) < 0) { compiler_exit_scope(c); return 0; } @@ -2908,7 +2911,7 @@ compiler_class(struct compiler *c, stmt_ty s) return 0; } /* compile the body proper */ - if (!compiler_body(c, loc, s->v.ClassDef.body)) { + if (compiler_body(c, loc, s->v.ClassDef.body) < 0) { compiler_exit_scope(c); return 0; } From c504cd37ed0d07dfc2c9100d50000cb13bf54b16 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:25:05 +0000 Subject: [PATCH 22/93] compiler_codegen returns SUCCESS/ERROR --- Python/compile.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 9e0c96febe6683..24d7760c066f03 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2310,42 +2310,42 @@ static int compiler_codegen(struct compiler *c, mod_ty mod) { _Py_DECLARE_STR(anon_module, ""); - if (compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE, - mod, 1) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE, + mod, 1)); + location loc = LOCATION(1, 1, 0, 0); switch (mod->kind) { case Module_kind: if (compiler_body(c, loc, mod->v.Module.body) < 0) { compiler_exit_scope(c); - return 0; + return ERROR; } break; case Interactive_kind: if (find_ann(mod->v.Interactive.body)) { - _ADDOP(c, loc, SETUP_ANNOTATIONS); + ADDOP(c, loc, SETUP_ANNOTATIONS); } c->c_interactive = 1; - _VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body); + VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body); break; case Expression_kind: - _VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); + VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); break; default: PyErr_Format(PyExc_SystemError, "module kind %d should not be possible", mod->kind); - return 0; + return ERROR; } - return 1; + return SUCCESS; } static PyCodeObject * compiler_mod(struct compiler *c, mod_ty mod) { int addNone = mod->kind != Expression_kind; - if (!compiler_codegen(c, mod)) { + if (compiler_codegen(c, mod) < 0) { return NULL; } PyCodeObject *co = assemble(c, addNone); @@ -10227,7 +10227,7 @@ _PyCompile_CodeGen(PyObject *ast, PyObject *filename, PyCompilerFlags *pflags, return NULL; } - if (!compiler_codegen(c, mod)) { + if (compiler_codegen(c, mod) < 0) { goto finally; } From b6028e22b5a242befaa718d8e6a4ab0aaf47eac4 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:36:44 +0000 Subject: [PATCH 23/93] compiler_make_closure returns SUCCESS/ERROR --- Python/compile.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 24d7760c066f03..6a50644ed0cfa9 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2412,7 +2412,7 @@ compiler_make_closure(struct compiler *c, location loc, */ int reftype = get_ref_type(c, name); if (reftype == -1) { - return 0; + return ERROR; } int arg; if (reftype == CELL) { @@ -2435,16 +2435,16 @@ compiler_make_closure(struct compiler *c, location loc, co->co_name, freevars); Py_DECREF(freevars); - return 0; + return ERROR; } - _ADDOP_I(c, loc, LOAD_CLOSURE, arg); + ADDOP_I(c, loc, LOAD_CLOSURE, arg); } flags |= 0x08; - _ADDOP_I(c, loc, BUILD_TUPLE, co->co_nfreevars); + ADDOP_I(c, loc, BUILD_TUPLE, co->co_nfreevars); } - _ADDOP_LOAD_CONST(c, loc, (PyObject*)co); - _ADDOP_I(c, loc, MAKE_FUNCTION, flags); - return 1; + ADDOP_LOAD_CONST(c, loc, (PyObject*)co); + ADDOP_I(c, loc, MAKE_FUNCTION, flags); + return SUCCESS; } static int @@ -2846,7 +2846,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) Py_XDECREF(co); return 0; } - if (!compiler_make_closure(c, loc, co, funcflags, qualname)) { + if (compiler_make_closure(c, loc, co, funcflags, qualname) < 0) { Py_DECREF(qualname); Py_DECREF(co); return 0; @@ -2952,7 +2952,7 @@ compiler_class(struct compiler *c, stmt_ty s) _ADDOP(c, loc, LOAD_BUILD_CLASS); /* 3. load a function (or closure) made from the code object */ - if (!compiler_make_closure(c, loc, co, 0, NULL)) { + if (compiler_make_closure(c, loc, co, 0, NULL) < 0) { Py_DECREF(co); return 0; } @@ -3226,7 +3226,7 @@ compiler_lambda(struct compiler *c, expr_ty e) return 0; } - if (!compiler_make_closure(c, loc, co, funcflags, qualname)) { + if (compiler_make_closure(c, loc, co, funcflags, qualname) < 0) { Py_DECREF(qualname); Py_DECREF(co); return 0; @@ -5665,7 +5665,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, goto error; loc = LOC(e); - if (!compiler_make_closure(c, loc, co, 0, qualname)) { + if (compiler_make_closure(c, loc, co, 0, qualname) < 0) { goto error; } Py_DECREF(qualname); From 19235f78f57343a064c47c7d76e8c91e5e79e9c7 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:43:01 +0000 Subject: [PATCH 24/93] compiler_decorators and compiler_apply_decorators return SUCCESS/ERROR --- Python/compile.c | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 6a50644ed0cfa9..9eeef654a50f0c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2450,28 +2450,28 @@ compiler_make_closure(struct compiler *c, location loc, static int compiler_decorators(struct compiler *c, asdl_expr_seq* decos) { - int i; - - if (!decos) - return 1; + if (!decos) { + return SUCCESS; + } - for (i = 0; i < asdl_seq_LEN(decos); i++) { - _VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); + for (Py_ssize_t i = 0; i < asdl_seq_LEN(decos); i++) { + VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); } - return 1; + return SUCCESS; } static int compiler_apply_decorators(struct compiler *c, asdl_expr_seq* decos) { - if (!decos) - return 1; + if (!decos) { + return SUCCESS; + } for (Py_ssize_t i = asdl_seq_LEN(decos) - 1; i > -1; i--) { location loc = LOC((expr_ty)asdl_seq_GET(decos, i)); - _ADDOP_I(c, loc, CALL, 0); + ADDOP_I(c, loc, CALL, 0); } - return 1; + return SUCCESS; } static int @@ -2792,8 +2792,9 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) if (!compiler_check_debug_args(c, args)) return 0; - if (!compiler_decorators(c, decos)) + if (compiler_decorators(c, decos) < 0) { return 0; + } firstlineno = s->lineno; if (asdl_seq_LEN(decos)) { @@ -2854,8 +2855,9 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) Py_DECREF(qualname); Py_DECREF(co); - if (!compiler_apply_decorators(c, decos)) + if (compiler_apply_decorators(c, decos) < 0) { return 0; + } return compiler_nameop(c, loc, name, Store); } @@ -2866,8 +2868,9 @@ compiler_class(struct compiler *c, stmt_ty s) int i, firstlineno; asdl_expr_seq *decos = s->v.ClassDef.decorator_list; - if (!compiler_decorators(c, decos)) + if (compiler_decorators(c, decos) < 0) { return 0; + } firstlineno = s->lineno; if (asdl_seq_LEN(decos)) { @@ -2967,8 +2970,9 @@ compiler_class(struct compiler *c, stmt_ty s) s->v.ClassDef.keywords)) return 0; /* 6. apply decorators */ - if (!compiler_apply_decorators(c, decos)) + if (compiler_apply_decorators(c, decos) < 0) { return 0; + } /* 7. store into */ if (!compiler_nameop(c, loc, s->v.ClassDef.name, Store)) From 9d936351c23e26cf548438e7f0485b5ebfac3be4 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:47:19 +0000 Subject: [PATCH 25/93] compiler_visit_kwonlydefaults returns SUCCESS/ERROR --- Python/compile.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 9eeef654a50f0c..4221da7877bd24 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2480,7 +2480,7 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, { /* Push a dict of keyword-only default values. - Return 0 on error, -1 if no dict pushed, 1 if a dict is pushed. + Return -1 on error, 0 if no dict pushed, 1 if a dict is pushed. */ int i; PyObject *keys = NULL; @@ -2497,7 +2497,7 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, keys = PyList_New(1); if (keys == NULL) { Py_DECREF(mangled); - return 0; + return ERROR; } PyList_SET_ITEM(keys, 0, mangled); } @@ -2523,12 +2523,12 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, return 1; } else { - return -1; + return 0; } error: Py_XDECREF(keys); - return 0; + return ERROR; } static int @@ -2653,8 +2653,8 @@ compiler_default_arguments(struct compiler *c, location loc, int res = compiler_visit_kwonlydefaults(c, loc, args->kwonlyargs, args->kw_defaults); - if (res == 0) { - return -1; + if (res < 0) { + return ERROR; } else if (res > 0) { funcflags |= 0x02; From dfbe826be76b6cc07c3f5d626af88ba5b1fae066 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:49:44 +0000 Subject: [PATCH 26/93] forbidden_name returns bool --- Python/compile.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 4221da7877bd24..e803160feb64c2 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2663,27 +2663,28 @@ compiler_default_arguments(struct compiler *c, location loc, return funcflags; } -static int +static bool forbidden_name(struct compiler *c, location loc, identifier name, expr_context_ty ctx) { if (ctx == Store && _PyUnicode_EqualToASCIIString(name, "__debug__")) { compiler_error(c, loc, "cannot assign to __debug__"); - return 1; + return true; } if (ctx == Del && _PyUnicode_EqualToASCIIString(name, "__debug__")) { compiler_error(c, loc, "cannot delete __debug__"); - return 1; + return true; } - return 0; + return false; } static int compiler_check_debug_one_arg(struct compiler *c, arg_ty arg) { if (arg != NULL) { - if (forbidden_name(c, LOC(arg), arg->arg, Store)) + if (forbidden_name(c, LOC(arg), arg->arg, Store)) { return 0; + } } return 1; } @@ -4394,8 +4395,9 @@ compiler_nameop(struct compiler *c, location loc, !_PyUnicode_EqualToASCIIString(name, "True") && !_PyUnicode_EqualToASCIIString(name, "False")); - if (forbidden_name(c, loc, name, ctx)) + if (forbidden_name(c, loc, name, ctx)) { return 0; + } mangled = _Py_Mangle(c->u->u_private, name); if (!mangled) @@ -6278,8 +6280,9 @@ compiler_annassign(struct compiler *c, stmt_ty s) } switch (targ->kind) { case Name_kind: - if (forbidden_name(c, loc, targ->v.Name.id, Store)) + if (forbidden_name(c, loc, targ->v.Name.id, Store)) { return 0; + } /* If we have a simple name in a module or class, store annotation. */ if (s->v.AnnAssign.simple && (c->u->u_scope_type == COMPILER_SCOPE_MODULE || @@ -6297,8 +6300,9 @@ compiler_annassign(struct compiler *c, stmt_ty s) } break; case Attribute_kind: - if (forbidden_name(c, loc, targ->v.Attribute.attr, Store)) + if (forbidden_name(c, loc, targ->v.Attribute.attr, Store)) { return 0; + } if (!s->v.AnnAssign.value && !check_ann_expr(c, targ->v.Attribute.value)) { return 0; From 9757b0dac536bf9f493bd179c4eb5240a85d1489 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 18:58:42 +0000 Subject: [PATCH 27/93] compiler_check_debug_one_arg, compiler_check_debug_args, compiler_check_debug_args_seq return SUCCESS/ERROR --- Python/compile.c | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e803160feb64c2..5b66e513dbdd26 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2683,10 +2683,10 @@ compiler_check_debug_one_arg(struct compiler *c, arg_ty arg) { if (arg != NULL) { if (forbidden_name(c, LOC(arg), arg->arg, Store)) { - return 0; + return ERROR; } } - return 1; + return SUCCESS; } static int @@ -2694,27 +2694,22 @@ compiler_check_debug_args_seq(struct compiler *c, asdl_arg_seq *args) { if (args != NULL) { for (Py_ssize_t i = 0, n = asdl_seq_LEN(args); i < n; i++) { - if (!compiler_check_debug_one_arg(c, asdl_seq_GET(args, i))) - return 0; + RETURN_IF_ERROR( + compiler_check_debug_one_arg(c, asdl_seq_GET(args, i))); } } - return 1; + return SUCCESS; } static int compiler_check_debug_args(struct compiler *c, arguments_ty args) { - if (!compiler_check_debug_args_seq(c, args->posonlyargs)) - return 0; - if (!compiler_check_debug_args_seq(c, args->args)) - return 0; - if (!compiler_check_debug_one_arg(c, args->vararg)) - return 0; - if (!compiler_check_debug_args_seq(c, args->kwonlyargs)) - return 0; - if (!compiler_check_debug_one_arg(c, args->kwarg)) - return 0; - return 1; + RETURN_IF_ERROR(compiler_check_debug_args_seq(c, args->posonlyargs)); + RETURN_IF_ERROR(compiler_check_debug_args_seq(c, args->args)); + RETURN_IF_ERROR(compiler_check_debug_one_arg(c, args->vararg)); + RETURN_IF_ERROR(compiler_check_debug_args_seq(c, args->kwonlyargs)); + RETURN_IF_ERROR(compiler_check_debug_one_arg(c, args->kwarg)); + return SUCCESS; } static inline int @@ -2790,8 +2785,9 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) scope_type = COMPILER_SCOPE_FUNCTION; } - if (!compiler_check_debug_args(c, args)) + if (compiler_check_debug_args(c, args) < 0) { return 0; + } if (compiler_decorators(c, decos) < 0) { return 0; @@ -3193,8 +3189,9 @@ compiler_lambda(struct compiler *c, expr_ty e) arguments_ty args = e->v.Lambda.args; assert(e->kind == Lambda_kind); - if (!compiler_check_debug_args(c, args)) + if (compiler_check_debug_args(c, args) < 0) { return 0; + } location loc = LOC(e); funcflags = compiler_default_arguments(c, loc, args); From 151e8f03bf3f3347b26b90b44a05bc7f1a701cb3 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:03:42 +0000 Subject: [PATCH 28/93] insert_instruction, wrap_in_stopiteration_handler return SUCCESS/ERROR --- Python/compile.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 5b66e513dbdd26..238afd3dbfb94f 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2714,14 +2714,12 @@ compiler_check_debug_args(struct compiler *c, arguments_ty args) static inline int insert_instruction(basicblock *block, int pos, struct instr *instr) { - if (basicblock_next_instr(block) < 0) { - return -1; - } + RETURN_IF_ERROR(basicblock_next_instr(block)); for (int i = block->b_iused - 1; i > pos; i--) { block->b_instr[i] = block->b_instr[i-1]; } block->b_instr[pos] = *instr; - return 0; + return SUCCESS; } static int @@ -2736,16 +2734,15 @@ wrap_in_stopiteration_handler(struct compiler *c) .i_loc = NO_LOCATION, .i_target = NULL, }; - if (insert_instruction(c->u->u_cfg_builder.g_entryblock, 0, &setup)) { - return 0; - } + RETURN_IF_ERROR( + insert_instruction(c->u->u_cfg_builder.g_entryblock, 0, &setup)); - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - _ADDOP(c, NO_LOCATION, RETURN_VALUE); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP(c, NO_LOCATION, RETURN_VALUE); USE_LABEL(c, handler); - _ADDOP(c, NO_LOCATION, STOPITERATION_ERROR); - _ADDOP_I(c, NO_LOCATION, RERAISE, 1); - return 1; + ADDOP(c, NO_LOCATION, STOPITERATION_ERROR); + ADDOP_I(c, NO_LOCATION, RERAISE, 1); + return SUCCESS; } static int @@ -2831,7 +2828,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) _VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i)); } if (c->u->u_ste->ste_coroutine || c->u->u_ste->ste_generator) { - if (!wrap_in_stopiteration_handler(c)) { + if (wrap_in_stopiteration_handler(c) < 0) { compiler_exit_scope(c); return 0; } @@ -5653,7 +5650,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, _ADDOP(c, LOC(e), RETURN_VALUE); } if (type == COMP_GENEXP) { - if (!wrap_in_stopiteration_handler(c)) { + if (wrap_in_stopiteration_handler(c) < 0) { goto error_in_scope; } } From 1409c3ece639653d331989055eedb209814d28ee Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:17:31 +0000 Subject: [PATCH 29/93] compiler_class returns SUCCESS/ERROR --- Python/compile.c | 65 ++++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 33 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 238afd3dbfb94f..c5b68bf32adbcb 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2862,9 +2862,7 @@ compiler_class(struct compiler *c, stmt_ty s) int i, firstlineno; asdl_expr_seq *decos = s->v.ClassDef.decorator_list; - if (compiler_decorators(c, decos) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_decorators(c, decos)); firstlineno = s->lineno; if (asdl_seq_LEN(decos)) { @@ -2882,10 +2880,10 @@ compiler_class(struct compiler *c, stmt_ty s) This borrows from compiler_call. */ /* 1. compile the class body into a code object */ - if (compiler_enter_scope(c, s->v.ClassDef.name, - COMPILER_SCOPE_CLASS, (void *)s, firstlineno) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_enter_scope(c, s->v.ClassDef.name, + COMPILER_SCOPE_CLASS, (void *)s, firstlineno)); + /* this block represents what we do in the new scope */ { location loc = LOCATION(firstlineno, firstlineno, 0, 0); @@ -2894,23 +2892,23 @@ compiler_class(struct compiler *c, stmt_ty s) /* load (global) __name__ ... */ if (!compiler_nameop(c, loc, &_Py_ID(__name__), Load)) { compiler_exit_scope(c); - return 0; + return ERROR; } /* ... and store it as __module__ */ if (!compiler_nameop(c, loc, &_Py_ID(__module__), Store)) { compiler_exit_scope(c); - return 0; + return ERROR; } assert(c->u->u_qualname); - _ADDOP_LOAD_CONST(c, loc, c->u->u_qualname); + ADDOP_LOAD_CONST(c, loc, c->u->u_qualname); if (!compiler_nameop(c, loc, &_Py_ID(__qualname__), Store)) { compiler_exit_scope(c); - return 0; + return ERROR; } /* compile the body proper */ if (compiler_body(c, loc, s->v.ClassDef.body) < 0) { compiler_exit_scope(c); - return 0; + return ERROR; } /* The following code is artificial */ /* Return __classcell__ if it is referenced, otherwise return None */ @@ -2919,59 +2917,60 @@ compiler_class(struct compiler *c, stmt_ty s) i = compiler_lookup_arg(c->u->u_cellvars, &_Py_ID(__class__)); if (i < 0) { compiler_exit_scope(c); - return 0; + return ERROR; } assert(i == 0); - _ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i); - _ADDOP_I(c, NO_LOCATION, COPY, 1); + ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i); + ADDOP_I(c, NO_LOCATION, COPY, 1); if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store)) { compiler_exit_scope(c); - return 0; + return ERROR; } } else { /* No methods referenced __class__, so just return None */ assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0); - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); } - _ADDOP_IN_SCOPE(c, NO_LOCATION, RETURN_VALUE); + ADDOP_IN_SCOPE(c, NO_LOCATION, RETURN_VALUE); /* create the code object */ co = assemble(c, 1); } /* leave the new scope */ compiler_exit_scope(c); - if (co == NULL) - return 0; + if (co == NULL) { + return ERROR; + } location loc = LOC(s); /* 2. load the 'build_class' function */ - _ADDOP(c, loc, PUSH_NULL); - _ADDOP(c, loc, LOAD_BUILD_CLASS); + ADDOP(c, loc, PUSH_NULL); + ADDOP(c, loc, LOAD_BUILD_CLASS); /* 3. load a function (or closure) made from the code object */ if (compiler_make_closure(c, loc, co, 0, NULL) < 0) { Py_DECREF(co); - return 0; + return ERROR; } Py_DECREF(co); /* 4. load class name */ - _ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name); + ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name); /* 5. generate the rest of the code for the call */ if (!compiler_call_helper(c, loc, 2, s->v.ClassDef.bases, - s->v.ClassDef.keywords)) - return 0; - /* 6. apply decorators */ - if (compiler_apply_decorators(c, decos) < 0) { - return 0; + s->v.ClassDef.keywords)) { + return ERROR; } + /* 6. apply decorators */ + RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); /* 7. store into */ - if (!compiler_nameop(c, loc, s->v.ClassDef.name, Store)) - return 0; - return 1; + if (!compiler_nameop(c, loc, s->v.ClassDef.name, Store)) { + return ERROR; + } + return SUCCESS; } /* Return 0 if the expression is a constant value except named singletons. @@ -4202,7 +4201,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case FunctionDef_kind: return compiler_function(c, s, 0); case ClassDef_kind: - return compiler_class(c, s); + return compiler_class(c, s) == SUCCESS ? 1 : 0; case Return_kind: return compiler_return(c, s); case Delete_kind: From d1a28e451ed07ff9a14c63cbfe07595fde3520b9 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:21:08 +0000 Subject: [PATCH 30/93] compiler_return returns SUCCESS/ERROR --- Python/compile.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index c5b68bf32adbcb..2df9f1f41855c6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3389,41 +3389,41 @@ compiler_return(struct compiler *c, stmt_ty s) location loc = LOC(s); int preserve_tos = ((s->v.Return.value != NULL) && (s->v.Return.value->kind != Constant_kind)); - if (c->u->u_ste->ste_type != FunctionBlock) - return compiler_error(c, loc, "'return' outside function"); + if (c->u->u_ste->ste_type != FunctionBlock) { + compiler_error(c, loc, "'return' outside function"); + return ERROR; + } if (s->v.Return.value != NULL && c->u->u_ste->ste_coroutine && c->u->u_ste->ste_generator) { - return compiler_error( - c, loc, "'return' with value in async generator"); + compiler_error(c, loc, "'return' with value in async generator"); + return ERROR; } if (preserve_tos) { - _VISIT(c, expr, s->v.Return.value); + VISIT(c, expr, s->v.Return.value); } else { /* Emit instruction with line number for return value */ if (s->v.Return.value != NULL) { loc = LOC(s->v.Return.value); - _ADDOP(c, loc, NOP); + ADDOP(c, loc, NOP); } } if (s->v.Return.value == NULL || s->v.Return.value->lineno != s->lineno) { loc = LOC(s); - _ADDOP(c, loc, NOP); + ADDOP(c, loc, NOP); } - if (compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL)); if (s->v.Return.value == NULL) { - _ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_LOAD_CONST(c, loc, Py_None); } else if (!preserve_tos) { - _ADDOP_LOAD_CONST(c, loc, s->v.Return.value->v.Constant.value); + ADDOP_LOAD_CONST(c, loc, s->v.Return.value->v.Constant.value); } - _ADDOP(c, loc, RETURN_VALUE); + ADDOP(c, loc, RETURN_VALUE); - return 1; + return SUCCESS; } static int @@ -4203,7 +4203,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case ClassDef_kind: return compiler_class(c, s) == SUCCESS ? 1 : 0; case Return_kind: - return compiler_return(c, s); + return compiler_return(c, s) == SUCCESS ? 1 : 0; case Delete_kind: _VISIT_SEQ(c, expr, s->v.Delete.targets) break; From 15b73da4befa227043e4908d5af5d33873b1b10f Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:25:12 +0000 Subject: [PATCH 31/93] compiler_augassign return SUCCESS/ERROR --- Python/compile.c | 58 ++++++++++++++++++++++++------------------------ 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 2df9f1f41855c6..55366947e8f7e4 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4221,7 +4221,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) break; } case AugAssign_kind: - return compiler_augassign(c, s); + return compiler_augassign(c, s) == SUCCESS ? 1 : 0; case AnnAssign_kind: return compiler_annassign(c, s); case For_kind: @@ -6132,72 +6132,72 @@ compiler_augassign(struct compiler *c, stmt_ty s) switch (e->kind) { case Attribute_kind: - _VISIT(c, expr, e->v.Attribute.value); - _ADDOP_I(c, loc, COPY, 1); + VISIT(c, expr, e->v.Attribute.value); + ADDOP_I(c, loc, COPY, 1); loc = update_start_location_to_match_attr(c, loc, e); - _ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); + ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); break; case Subscript_kind: - _VISIT(c, expr, e->v.Subscript.value); + VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice)) { if (!compiler_slice(c, e->v.Subscript.slice)) { - return 0; + return ERROR; } - _ADDOP_I(c, loc, COPY, 3); - _ADDOP_I(c, loc, COPY, 3); - _ADDOP_I(c, loc, COPY, 3); - _ADDOP(c, loc, BINARY_SLICE); + ADDOP_I(c, loc, COPY, 3); + ADDOP_I(c, loc, COPY, 3); + ADDOP_I(c, loc, COPY, 3); + ADDOP(c, loc, BINARY_SLICE); } else { - _VISIT(c, expr, e->v.Subscript.slice); - _ADDOP_I(c, loc, COPY, 2); - _ADDOP_I(c, loc, COPY, 2); - _ADDOP(c, loc, BINARY_SUBSCR); + VISIT(c, expr, e->v.Subscript.slice); + ADDOP_I(c, loc, COPY, 2); + ADDOP_I(c, loc, COPY, 2); + ADDOP(c, loc, BINARY_SUBSCR); } break; case Name_kind: if (!compiler_nameop(c, loc, e->v.Name.id, Load)) - return 0; + return ERROR; break; default: PyErr_Format(PyExc_SystemError, "invalid node type (%d) for augmented assignment", e->kind); - return 0; + return ERROR; } loc = LOC(s); - _VISIT(c, expr, s->v.AugAssign.value); - _ADDOP_INPLACE(c, loc, s->v.AugAssign.op); + VISIT(c, expr, s->v.AugAssign.value); + ADDOP_INPLACE(c, loc, s->v.AugAssign.op); loc = LOC(e); switch (e->kind) { case Attribute_kind: loc = update_start_location_to_match_attr(c, loc, e); - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); + ADDOP_I(c, loc, SWAP, 2); + ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); break; case Subscript_kind: if (is_two_element_slice(e->v.Subscript.slice)) { - _ADDOP_I(c, loc, SWAP, 4); - _ADDOP_I(c, loc, SWAP, 3); - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP(c, loc, STORE_SLICE); + ADDOP_I(c, loc, SWAP, 4); + ADDOP_I(c, loc, SWAP, 3); + ADDOP_I(c, loc, SWAP, 2); + ADDOP(c, loc, STORE_SLICE); } else { - _ADDOP_I(c, loc, SWAP, 3); - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP(c, loc, STORE_SUBSCR); + ADDOP_I(c, loc, SWAP, 3); + ADDOP_I(c, loc, SWAP, 2); + ADDOP(c, loc, STORE_SUBSCR); } break; case Name_kind: - return compiler_nameop(c, loc, e->v.Name.id, Store); + return compiler_nameop(c, loc, e->v.Name.id, Store) ? SUCCESS : ERROR; default: Py_UNREACHABLE(); } - return 1; + return SUCCESS; } static int From 40615daf7830cba3e0bdf4bb476869671bc1eae5 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:28:01 +0000 Subject: [PATCH 32/93] compiler_annassign returns SUCCESS/ERROR --- Python/compile.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 55366947e8f7e4..15ed1156288fed 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4223,7 +4223,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case AugAssign_kind: return compiler_augassign(c, s) == SUCCESS ? 1 : 0; case AnnAssign_kind: - return compiler_annassign(c, s); + return compiler_annassign(c, s) == SUCCESS ? 1 : 0; case For_kind: return compiler_for(c, s); case While_kind: @@ -6268,57 +6268,57 @@ compiler_annassign(struct compiler *c, stmt_ty s) /* We perform the actual assignment first. */ if (s->v.AnnAssign.value) { - _VISIT(c, expr, s->v.AnnAssign.value); - _VISIT(c, expr, targ); + VISIT(c, expr, s->v.AnnAssign.value); + VISIT(c, expr, targ); } switch (targ->kind) { case Name_kind: if (forbidden_name(c, loc, targ->v.Name.id, Store)) { - return 0; + return ERROR; } /* If we have a simple name in a module or class, store annotation. */ if (s->v.AnnAssign.simple && (c->u->u_scope_type == COMPILER_SCOPE_MODULE || c->u->u_scope_type == COMPILER_SCOPE_CLASS)) { if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) { - _VISIT(c, annexpr, s->v.AnnAssign.annotation) + VISIT(c, annexpr, s->v.AnnAssign.annotation) } else { - _VISIT(c, expr, s->v.AnnAssign.annotation); + VISIT(c, expr, s->v.AnnAssign.annotation); } - _ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names); + ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names); mangled = _Py_Mangle(c->u->u_private, targ->v.Name.id); - _ADDOP_LOAD_CONST_NEW(c, loc, mangled); - _ADDOP(c, loc, STORE_SUBSCR); + ADDOP_LOAD_CONST_NEW(c, loc, mangled); + ADDOP(c, loc, STORE_SUBSCR); } break; case Attribute_kind: if (forbidden_name(c, loc, targ->v.Attribute.attr, Store)) { - return 0; + return ERROR; } if (!s->v.AnnAssign.value && !check_ann_expr(c, targ->v.Attribute.value)) { - return 0; + return ERROR; } break; case Subscript_kind: if (!s->v.AnnAssign.value && (!check_ann_expr(c, targ->v.Subscript.value) || !check_ann_subscr(c, targ->v.Subscript.slice))) { - return 0; + return ERROR; } break; default: PyErr_Format(PyExc_SystemError, "invalid node type (%d) for annotated assignment", targ->kind); - return 0; + return ERROR; } /* Annotation is evaluated last. */ if (!s->v.AnnAssign.simple && !check_annotation(c, s)) { - return 0; + return ERROR; } - return 1; + return SUCCESS; } /* Raises a SyntaxError and returns 0. From 90bb804da327c8cec3d2b76868aa201accfc9036 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:29:39 +0000 Subject: [PATCH 33/93] compiler_for returns SUCCESS/ERROR --- Python/compile.c | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 15ed1156288fed..d62651a34620ac 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3272,30 +3272,29 @@ compiler_for(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); NEW_JUMP_TARGET_LABEL(c, end); - if (compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL) < 0) { - return 0; - } - _VISIT(c, expr, s->v.For.iter); - _ADDOP(c, loc, GET_ITER); + RETURN_IF_ERROR(compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)); + + VISIT(c, expr, s->v.For.iter); + ADDOP(c, loc, GET_ITER); USE_LABEL(c, start); - _ADDOP_JUMP(c, loc, FOR_ITER, cleanup); + ADDOP_JUMP(c, loc, FOR_ITER, cleanup); USE_LABEL(c, body); - _VISIT(c, expr, s->v.For.target); - _VISIT_SEQ(c, stmt, s->v.For.body); + VISIT(c, expr, s->v.For.target); + VISIT_SEQ(c, stmt, s->v.For.body); /* Mark jump as artificial */ - _ADDOP_JUMP(c, NO_LOCATION, JUMP, start); + ADDOP_JUMP(c, NO_LOCATION, JUMP, start); USE_LABEL(c, cleanup); - _ADDOP(c, NO_LOCATION, END_FOR); + ADDOP(c, NO_LOCATION, END_FOR); compiler_pop_fblock(c, FOR_LOOP, start); - _VISIT_SEQ(c, stmt, s->v.For.orelse); + VISIT_SEQ(c, stmt, s->v.For.orelse); USE_LABEL(c, end); - return 1; + return SUCCESS; } @@ -4225,7 +4224,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case AnnAssign_kind: return compiler_annassign(c, s) == SUCCESS ? 1 : 0; case For_kind: - return compiler_for(c, s); + return compiler_for(c, s) == SUCCESS ? 1 : 0; case While_kind: return compiler_while(c, s); case If_kind: From 42dca9270262c5983397972abb3dda0ba7ef443c Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:32:25 +0000 Subject: [PATCH 34/93] compiler_while returns SUCCESS/ERROR --- Python/compile.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index d62651a34620ac..61ecf891c22663 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3358,28 +3358,27 @@ compiler_while(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, anchor); USE_LABEL(c, loop); - if (compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL) < 0) { - return 0; - } + + RETURN_IF_ERROR(compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL)); if (!compiler_jump_if(c, LOC(s), s->v.While.test, anchor, 0)) { - return 0; + return ERROR; } USE_LABEL(c, body); - _VISIT_SEQ(c, stmt, s->v.While.body); + VISIT_SEQ(c, stmt, s->v.While.body); if (!compiler_jump_if(c, LOC(s), s->v.While.test, body, 1)) { - return 0; + return ERROR; } compiler_pop_fblock(c, WHILE_LOOP, loop); USE_LABEL(c, anchor); if (s->v.While.orelse) { - _VISIT_SEQ(c, stmt, s->v.While.orelse); + VISIT_SEQ(c, stmt, s->v.While.orelse); } USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4226,7 +4225,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case For_kind: return compiler_for(c, s) == SUCCESS ? 1 : 0; case While_kind: - return compiler_while(c, s); + return compiler_while(c, s) == SUCCESS ? 1 : 0; case If_kind: return compiler_if(c, s); case Match_kind: From fdf615f00edaafc77282531039c356f269b8d7bf Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:35:22 +0000 Subject: [PATCH 35/93] compiler_if returns SUCCESS/ERROR --- Python/compile.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 61ecf891c22663..e696a0c231ccc7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3249,18 +3249,18 @@ compiler_if(struct compiler *c, stmt_ty s) next = end; } if (!compiler_jump_if(c, LOC(s), s->v.If.test, next, 0)) { - return 0; + return ERROR; } - _VISIT_SEQ(c, stmt, s->v.If.body); + VISIT_SEQ(c, stmt, s->v.If.body); if (asdl_seq_LEN(s->v.If.orelse)) { - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next); - _VISIT_SEQ(c, stmt, s->v.If.orelse); + VISIT_SEQ(c, stmt, s->v.If.orelse); } USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4227,7 +4227,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case While_kind: return compiler_while(c, s) == SUCCESS ? 1 : 0; case If_kind: - return compiler_if(c, s); + return compiler_if(c, s) == SUCCESS ? 1 : 0; case Match_kind: return compiler_match(c, s); case Raise_kind: From 99a7257cde3099a41bef1497f7e4de93b5c3b67c Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:38:27 +0000 Subject: [PATCH 36/93] compiler_try_finally returns SUCCESS/ERROR --- Python/compile.c | 41 +++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e696a0c231ccc7..b730dd271659d2 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3512,45 +3512,46 @@ compiler_try_finally(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); /* `try` block */ - _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); + ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); - if (compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.Try.finalbody) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, FINALLY_TRY, body, end, + s->v.Try.finalbody)); + if (s->v.Try.handlers && asdl_seq_LEN(s->v.Try.handlers)) { - if (!compiler_try_except(c, s)) - return 0; + if (!compiler_try_except(c, s)) { + return ERROR; + } } else { - _VISIT_SEQ(c, stmt, s->v.Try.body); + VISIT_SEQ(c, stmt, s->v.Try.body); } - _ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, FINALLY_TRY, body); - _VISIT_SEQ(c, stmt, s->v.Try.finalbody); + VISIT_SEQ(c, stmt, s->v.Try.finalbody); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); /* `finally` block */ USE_LABEL(c, end); loc = NO_LOCATION; - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - _ADDOP(c, loc, PUSH_EXC_INFO); - if (compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL) < 0) { - return 0; - } - _VISIT_SEQ(c, stmt, s->v.Try.finalbody); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + ADDOP(c, loc, PUSH_EXC_INFO); + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)); + VISIT_SEQ(c, stmt, s->v.Try.finalbody); loc = location_of_last_executing_statement(s->v.Try.finalbody); compiler_pop_fblock(c, FINALLY_END, end); - _ADDOP_I(c, loc, RERAISE, 0); + ADDOP_I(c, loc, RERAISE, 0); USE_LABEL(c, cleanup); - _POP_EXCEPT_AND_RERAISE(c, loc); + POP_EXCEPT_AND_RERAISE(c, loc); USE_LABEL(c, exit); - return 1; + return SUCCESS; } static int @@ -3973,7 +3974,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) static int compiler_try(struct compiler *c, stmt_ty s) { if (s->v.Try.finalbody && asdl_seq_LEN(s->v.Try.finalbody)) - return compiler_try_finally(c, s); + return compiler_try_finally(c, s) == SUCCESS ? 1 : 0; else return compiler_try_except(c, s); } From 0902cf1db2500a58c0570968a5c4db3e6c03fecd Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:47:43 +0000 Subject: [PATCH 37/93] compiler_try_except returns SUCCESS/ERROR --- Python/compile.c | 89 ++++++++++++++++++++++++------------------------ 1 file changed, 44 insertions(+), 45 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index b730dd271659d2..3507d3492c6edb 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3520,9 +3520,7 @@ compiler_try_finally(struct compiler *c, stmt_ty s) s->v.Try.finalbody)); if (s->v.Try.handlers && asdl_seq_LEN(s->v.Try.handlers)) { - if (!compiler_try_except(c, s)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_try_except(c, s)); } else { VISIT_SEQ(c, stmt, s->v.Try.body); @@ -3646,42 +3644,43 @@ compiler_try_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, end); NEW_JUMP_TARGET_LABEL(c, cleanup); - _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); - if (compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL) < 0) { - return 0; - } - _VISIT_SEQ(c, stmt, s->v.Try.body); + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)); + VISIT_SEQ(c, stmt, s->v.Try.body); compiler_pop_fblock(c, TRY_EXCEPT, body); - _ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); if (s->v.Try.orelse && asdl_seq_LEN(s->v.Try.orelse)) { - _VISIT_SEQ(c, stmt, s->v.Try.orelse); + VISIT_SEQ(c, stmt, s->v.Try.orelse); } - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); n = asdl_seq_LEN(s->v.Try.handlers); USE_LABEL(c, except); - _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); - _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); + ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + /* Runtime will push a block here, so we need to account for that */ - if (compiler_push_fblock(c, loc, EXCEPTION_HANDLER, NO_LABEL, NO_LABEL, NULL) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, EXCEPTION_HANDLER, NO_LABEL, NO_LABEL, NULL)); + for (i = 0; i < n; i++) { excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( s->v.Try.handlers, i); location loc = LOC(handler); if (!handler->v.ExceptHandler.type && i < n-1) { - return compiler_error(c, loc, "default 'except:' must be last"); + compiler_error(c, loc, "default 'except:' must be last"); + return ERROR; } NEW_JUMP_TARGET_LABEL(c, next_except); except = next_except; if (handler->v.ExceptHandler.type) { - _VISIT(c, expr, handler->v.ExceptHandler.type); - _ADDOP(c, loc, CHECK_EXC_MATCH); - _ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, except); + VISIT(c, expr, handler->v.ExceptHandler.type); + ADDOP(c, loc, CHECK_EXC_MATCH); + ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, except); } if (handler->v.ExceptHandler.name) { NEW_JUMP_TARGET_LABEL(c, cleanup_end); @@ -3701,63 +3700,63 @@ compiler_try_except(struct compiler *c, stmt_ty s) */ /* second try: */ - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); - if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, - NO_LABEL, handler->v.ExceptHandler.name) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, + NO_LABEL, handler->v.ExceptHandler.name)); /* second # body */ - _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); /* name = None; del name; # Mark as artificial */ - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP(c, NO_LOCATION, POP_EXCEPT); - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_EXCEPT); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); /* except: */ USE_LABEL(c, cleanup_end); /* name = None; del name; # artificial */ - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); - _ADDOP_I(c, NO_LOCATION, RERAISE, 1); + ADDOP_I(c, NO_LOCATION, RERAISE, 1); } else { NEW_JUMP_TARGET_LABEL(c, cleanup_body); - _ADDOP(c, loc, POP_TOP); /* exc_value */ + ADDOP(c, loc, POP_TOP); /* exc_value */ USE_LABEL(c, cleanup_body); - if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, NULL) < 0) { - return 0; - } - _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, + NO_LABEL, NULL)); + + VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP(c, NO_LOCATION, POP_EXCEPT); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_EXCEPT); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); } USE_LABEL(c, except); } /* artificial */ compiler_pop_fblock(c, EXCEPTION_HANDLER, NO_LABEL); - _ADDOP_I(c, NO_LOCATION, RERAISE, 0); + ADDOP_I(c, NO_LOCATION, RERAISE, 0); USE_LABEL(c, cleanup); - _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, end); - return 1; + return SUCCESS; } /* @@ -3976,7 +3975,7 @@ compiler_try(struct compiler *c, stmt_ty s) { if (s->v.Try.finalbody && asdl_seq_LEN(s->v.Try.finalbody)) return compiler_try_finally(c, s) == SUCCESS ? 1 : 0; else - return compiler_try_except(c, s); + return compiler_try_except(c, s) == SUCCESS ? 1 : 0; } static int From 2680b56f12d46ef18894f875f983c99db764766a Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:55:42 +0000 Subject: [PATCH 38/93] compiler_try_star_finally, compiler_try_star_except return SUCCESS/ERROR --- Python/compile.c | 145 +++++++++++++++++++++++------------------------ 1 file changed, 72 insertions(+), 73 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 3507d3492c6edb..c9ea72d570747b 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3562,46 +3562,45 @@ compiler_try_star_finally(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, exit); NEW_JUMP_TARGET_LABEL(c, cleanup); /* `try` block */ - _ADDOP_JUMP(c, loc, SETUP_FINALLY, end); + ADDOP_JUMP(c, loc, SETUP_FINALLY, end); USE_LABEL(c, body); - if (compiler_push_fblock(c, loc, FINALLY_TRY, body, end, s->v.TryStar.finalbody) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, FINALLY_TRY, body, end, + s->v.TryStar.finalbody)); + if (s->v.TryStar.handlers && asdl_seq_LEN(s->v.TryStar.handlers)) { - if (!compiler_try_star_except(c, s)) { - return 0; - } + RETURN_IF_ERROR(compiler_try_star_except(c, s)); } else { - _VISIT_SEQ(c, stmt, s->v.TryStar.body); + VISIT_SEQ(c, stmt, s->v.TryStar.body); } - _ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, FINALLY_TRY, body); - _VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); + VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); /* `finally` block */ USE_LABEL(c, end); loc = NO_LOCATION; - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - _ADDOP(c, loc, PUSH_EXC_INFO); - if (compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL) < 0) { - return 0; - } - _VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + ADDOP(c, loc, PUSH_EXC_INFO); + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, FINALLY_END, end, NO_LABEL, NULL)); + + VISIT_SEQ(c, stmt, s->v.TryStar.finalbody); loc = location_of_last_executing_statement(s->v.Try.finalbody); compiler_pop_fblock(c, FINALLY_END, end); - _ADDOP_I(c, loc, RERAISE, 0); + ADDOP_I(c, loc, RERAISE, 0); USE_LABEL(c, cleanup); - _POP_EXCEPT_AND_RERAISE(c, loc); + POP_EXCEPT_AND_RERAISE(c, loc); USE_LABEL(c, exit); - return 1; + return SUCCESS; } @@ -3820,27 +3819,27 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup); NEW_JUMP_TARGET_LABEL(c, reraise_star); - _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + ADDOP_JUMP(c, loc, SETUP_FINALLY, except); USE_LABEL(c, body); - if (compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL) < 0) { - return 0; - } - _VISIT_SEQ(c, stmt, s->v.TryStar.body); + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, TRY_EXCEPT, body, NO_LABEL, NULL)); + VISIT_SEQ(c, stmt, s->v.TryStar.body); compiler_pop_fblock(c, TRY_EXCEPT, body); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, orelse); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP_JUMP(c, NO_LOCATION, JUMP, orelse); Py_ssize_t n = asdl_seq_LEN(s->v.TryStar.handlers); USE_LABEL(c, except); - _ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); - _ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + ADDOP_JUMP(c, NO_LOCATION, SETUP_CLEANUP, cleanup); + ADDOP(c, NO_LOCATION, PUSH_EXC_INFO); + /* Runtime will push a block here, so we need to account for that */ - if (compiler_push_fblock(c, loc, EXCEPTION_GROUP_HANDLER, - NO_LABEL, NO_LABEL, "except handler") < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, EXCEPTION_GROUP_HANDLER, + NO_LABEL, NO_LABEL, "except handler")); + for (Py_ssize_t i = 0; i < n; i++) { excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( s->v.TryStar.handlers, i); @@ -3854,7 +3853,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) [exc] COPY 1 [orig, exc] */ - _ADDOP_I(c, loc, COPY, 1); + ADDOP_I(c, loc, COPY, 1); /* create empty list for exceptions raised/reraise in the except* blocks */ /* @@ -3862,16 +3861,16 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) [orig, exc, []] SWAP 2 [orig, [], exc] */ - _ADDOP_I(c, loc, BUILD_LIST, 0); - _ADDOP_I(c, loc, SWAP, 2); + ADDOP_I(c, loc, BUILD_LIST, 0); + ADDOP_I(c, loc, SWAP, 2); } if (handler->v.ExceptHandler.type) { - _VISIT(c, expr, handler->v.ExceptHandler.type); - _ADDOP(c, loc, CHECK_EG_MATCH); - _ADDOP_I(c, loc, COPY, 1); - _ADDOP_JUMP(c, loc, POP_JUMP_IF_NOT_NONE, handle_match); - _ADDOP(c, loc, POP_TOP); // match - _ADDOP_JUMP(c, loc, JUMP, except); + VISIT(c, expr, handler->v.ExceptHandler.type); + ADDOP(c, loc, CHECK_EG_MATCH); + ADDOP_I(c, loc, COPY, 1); + ADDOP_JUMP(c, loc, POP_JUMP_IF_NOT_NONE, handle_match); + ADDOP(c, loc, POP_TOP); // match + ADDOP_JUMP(c, loc, JUMP, except); } USE_LABEL(c, handle_match); @@ -3883,7 +3882,7 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store); } else { - _ADDOP(c, loc, POP_TOP); // match + ADDOP(c, loc, POP_TOP); // match } /* @@ -3897,46 +3896,46 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) del name */ /* second try: */ - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup_end); USE_LABEL(c, cleanup_body); - if (compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, NO_LABEL, handler->v.ExceptHandler.name) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, HANDLER_CLEANUP, cleanup_body, + NO_LABEL, handler->v.ExceptHandler.name)); /* second # body */ - _VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); + VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body); /* name = None; del name; # artificial */ - _ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); if (handler->v.ExceptHandler.name) { - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); } - _ADDOP_JUMP(c, NO_LOCATION, JUMP, except); + ADDOP_JUMP(c, NO_LOCATION, JUMP, except); /* except: */ USE_LABEL(c, cleanup_end); /* name = None; del name; # artificial */ if (handler->v.ExceptHandler.name) { - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); } /* add exception raised to the res list */ - _ADDOP_I(c, NO_LOCATION, LIST_APPEND, 3); // exc - _ADDOP(c, NO_LOCATION, POP_TOP); // lasti - _ADDOP_JUMP(c, NO_LOCATION, JUMP, except); + ADDOP_I(c, NO_LOCATION, LIST_APPEND, 3); // exc + ADDOP(c, NO_LOCATION, POP_TOP); // lasti + ADDOP_JUMP(c, NO_LOCATION, JUMP, except); USE_LABEL(c, except); if (i == n - 1) { /* Add exc to the list (if not None it's the unhandled part of the EG) */ - _ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, reraise_star); + ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1); + ADDOP_JUMP(c, NO_LOCATION, JUMP, reraise_star); } } /* artificial */ @@ -3944,30 +3943,30 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, reraise); USE_LABEL(c, reraise_star); - _ADDOP(c, NO_LOCATION, PREP_RERAISE_STAR); - _ADDOP_I(c, NO_LOCATION, COPY, 1); - _ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_NOT_NONE, reraise); + ADDOP(c, NO_LOCATION, PREP_RERAISE_STAR); + ADDOP_I(c, NO_LOCATION, COPY, 1); + ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_NOT_NONE, reraise); /* Nothing to reraise */ - _ADDOP(c, NO_LOCATION, POP_TOP); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP(c, NO_LOCATION, POP_EXCEPT); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP(c, NO_LOCATION, POP_TOP); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_EXCEPT); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, reraise); - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP_I(c, NO_LOCATION, SWAP, 2); - _ADDOP(c, NO_LOCATION, POP_EXCEPT); - _ADDOP_I(c, NO_LOCATION, RERAISE, 0); + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP_I(c, NO_LOCATION, SWAP, 2); + ADDOP(c, NO_LOCATION, POP_EXCEPT); + ADDOP_I(c, NO_LOCATION, RERAISE, 0); USE_LABEL(c, cleanup); - _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, orelse); - _VISIT_SEQ(c, stmt, s->v.TryStar.orelse); + VISIT_SEQ(c, stmt, s->v.TryStar.orelse); USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -3982,10 +3981,10 @@ static int compiler_try_star(struct compiler *c, stmt_ty s) { if (s->v.TryStar.finalbody && asdl_seq_LEN(s->v.TryStar.finalbody)) { - return compiler_try_star_finally(c, s); + return compiler_try_star_finally(c, s) == SUCCESS ? 1 : 0; } else { - return compiler_try_star_except(c, s); + return compiler_try_star_except(c, s) == SUCCESS ? 1 : 0; } } From 6136f33c18f5af122efaeac7f132454bb9b92979 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 19:57:44 +0000 Subject: [PATCH 39/93] compiler_try, compiler_try_star return SUCCESS/ERROR --- Python/compile.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index c9ea72d570747b..674cff44377f59 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3972,19 +3972,19 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) static int compiler_try(struct compiler *c, stmt_ty s) { if (s->v.Try.finalbody && asdl_seq_LEN(s->v.Try.finalbody)) - return compiler_try_finally(c, s) == SUCCESS ? 1 : 0; + return compiler_try_finally(c, s); else - return compiler_try_except(c, s) == SUCCESS ? 1 : 0; + return compiler_try_except(c, s); } static int compiler_try_star(struct compiler *c, stmt_ty s) { if (s->v.TryStar.finalbody && asdl_seq_LEN(s->v.TryStar.finalbody)) { - return compiler_try_star_finally(c, s) == SUCCESS ? 1 : 0; + return compiler_try_star_finally(c, s); } else { - return compiler_try_star_except(c, s) == SUCCESS ? 1 : 0; + return compiler_try_star_except(c, s); } } @@ -4244,9 +4244,9 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) break; } case Try_kind: - return compiler_try(c, s); + return compiler_try(c, s) == SUCCESS ? 1 : 0; case TryStar_kind: - return compiler_try_star(c, s); + return compiler_try_star(c, s) == SUCCESS ? 1 : 0; case Assert_kind: return compiler_assert(c, s); case Import_kind: From 73d8b72917da4349b3c3e577726bbb8602aeb832 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 20:05:07 +0000 Subject: [PATCH 40/93] compiler_assert returns SUCCESS/ERROR --- Python/compile.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 674cff44377f59..ced137f85c6c0c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4149,25 +4149,25 @@ compiler_assert(struct compiler *c, stmt_ty s) if (!compiler_warn(c, LOC(s), "assertion is always true, " "perhaps remove parentheses?")) { - return 0; + return ERROR; } } if (c->c_optimize) { - return 1; + return SUCCESS; } NEW_JUMP_TARGET_LABEL(c, end); if (!compiler_jump_if(c, LOC(s), s->v.Assert.test, end, 1)) { - return 0; + return ERROR; } - _ADDOP(c, LOC(s), LOAD_ASSERTION_ERROR); + ADDOP(c, LOC(s), LOAD_ASSERTION_ERROR); if (s->v.Assert.msg) { - _VISIT(c, expr, s->v.Assert.msg); - _ADDOP_I(c, LOC(s), CALL, 0); + VISIT(c, expr, s->v.Assert.msg); + ADDOP_I(c, LOC(s), CALL, 0); } - _ADDOP_I(c, LOC(s), RAISE_VARARGS, 1); + ADDOP_I(c, LOC(s), RAISE_VARARGS, 1); USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4248,7 +4248,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case TryStar_kind: return compiler_try_star(c, s) == SUCCESS ? 1 : 0; case Assert_kind: - return compiler_assert(c, s); + return compiler_assert(c, s) == SUCCESS ? 1 : 0; case Import_kind: return compiler_import(c, s); case ImportFrom_kind: From 6966b263615e5b4cfe58ed1f70cefeeb75cf972b Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 20:06:07 +0000 Subject: [PATCH 41/93] compiler_import, compiler_import_as return SUCCESS/ERROR --- Python/compile.c | 52 +++++++++++++++++++++++++++--------------------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index ced137f85c6c0c..1d2dde9ecc8ceb 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4000,33 +4000,36 @@ compiler_import_as(struct compiler *c, location loc, */ Py_ssize_t len = PyUnicode_GET_LENGTH(name); Py_ssize_t dot = PyUnicode_FindChar(name, '.', 0, len, 1); - if (dot == -2) - return 0; + if (dot == -2) { + return ERROR; + } if (dot != -1) { /* Consume the base module name to get the first attribute */ while (1) { Py_ssize_t pos = dot + 1; PyObject *attr; dot = PyUnicode_FindChar(name, '.', pos, len, 1); - if (dot == -2) - return 0; + if (dot == -2) { + return ERROR; + } attr = PyUnicode_Substring(name, pos, (dot != -1) ? dot : len); - if (!attr) - return 0; - _ADDOP_N(c, loc, IMPORT_FROM, attr, names); + if (!attr) { + return ERROR; + } + ADDOP_N(c, loc, IMPORT_FROM, attr, names); if (dot == -1) { break; } - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP(c, loc, POP_TOP); + ADDOP_I(c, loc, SWAP, 2); + ADDOP(c, loc, POP_TOP); } if (!compiler_nameop(c, loc, asname, Store)) { - return 0; + return ERROR; } - _ADDOP(c, loc, POP_TOP); - return 1; + ADDOP(c, loc, POP_TOP); + return SUCCESS; } - return compiler_nameop(c, loc, asname, Store); + return compiler_nameop(c, loc, asname, Store) ? SUCCESS : ERROR; } static int @@ -4047,14 +4050,15 @@ compiler_import(struct compiler *c, stmt_ty s) alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i); int r; - _ADDOP_LOAD_CONST(c, loc, zero); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADDOP_NAME(c, loc, IMPORT_NAME, alias->name, names); + ADDOP_LOAD_CONST(c, loc, zero); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_NAME(c, loc, IMPORT_NAME, alias->name, names); if (alias->asname) { r = compiler_import_as(c, loc, alias->name, alias->asname); - if (!r) + if (r == ERROR) { return r; + } } else { identifier tmp = alias->name; @@ -4062,18 +4066,20 @@ compiler_import(struct compiler *c, stmt_ty s) alias->name, '.', 0, PyUnicode_GET_LENGTH(alias->name), 1); if (dot != -1) { tmp = PyUnicode_Substring(alias->name, 0, dot); - if (tmp == NULL) - return 0; + if (tmp == NULL) { + return ERROR; + } } r = compiler_nameop(c, loc, tmp, Store); if (dot != -1) { Py_DECREF(tmp); } - if (!r) - return r; + if (!r) { + return ERROR; + } } } - return 1; + return SUCCESS; } static int @@ -4250,7 +4256,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case Assert_kind: return compiler_assert(c, s) == SUCCESS ? 1 : 0; case Import_kind: - return compiler_import(c, s); + return compiler_import(c, s) == SUCCESS ? 1 : 0; case ImportFrom_kind: return compiler_from_import(c, s); case Global_kind: From 1cdf83bb684282d0ae0a27517dce1fd447c61093 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 20:12:53 +0000 Subject: [PATCH 42/93] compiler_from_import, compiler_break return SUCCESS/ERROR --- Python/compile.c | 48 +++++++++++++++++++++++------------------------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 1d2dde9ecc8ceb..f35671b67106d7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3429,18 +3429,15 @@ compiler_break(struct compiler *c, location loc) { struct fblockinfo *loop = NULL; /* Emit instruction with line number */ - _ADDOP(c, loc, NOP); - if (compiler_unwind_fblock_stack(c, &loc, 0, &loop) < 0) { - return 0; - } + ADDOP(c, loc, NOP); + RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, 0, &loop)); if (loop == NULL) { - return compiler_error(c, loc, "'break' outside loop"); - } - if (compiler_unwind_fblock(c, &loc, loop, 0) < 0) { - return 0; + compiler_error(c, loc, "'break' outside loop"); + return ERROR; } - _ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); - return 1; + RETURN_IF_ERROR(compiler_unwind_fblock(c, &loc, loop, 0)); + ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); + return SUCCESS; } static int @@ -4087,11 +4084,11 @@ compiler_from_import(struct compiler *c, stmt_ty s) { Py_ssize_t n = asdl_seq_LEN(s->v.ImportFrom.names); - _ADDOP_LOAD_CONST_NEW(c, LOC(s), PyLong_FromLong(s->v.ImportFrom.level)); + ADDOP_LOAD_CONST_NEW(c, LOC(s), PyLong_FromLong(s->v.ImportFrom.level)); PyObject *names = PyTuple_New(n); if (!names) { - return 0; + return ERROR; } /* build up the names */ @@ -4105,17 +4102,18 @@ compiler_from_import(struct compiler *c, stmt_ty s) _PyUnicode_EqualToASCIIString(s->v.ImportFrom.module, "__future__")) { Py_DECREF(names); - return compiler_error(c, LOC(s), "from __future__ imports must occur " - "at the beginning of the file"); + compiler_error(c, LOC(s), "from __future__ imports must occur " + "at the beginning of the file"); + return ERROR; } - _ADDOP_LOAD_CONST_NEW(c, LOC(s), names); + ADDOP_LOAD_CONST_NEW(c, LOC(s), names); if (s->v.ImportFrom.module) { - _ADDOP_NAME(c, LOC(s), IMPORT_NAME, s->v.ImportFrom.module, names); + ADDOP_NAME(c, LOC(s), IMPORT_NAME, s->v.ImportFrom.module, names); } else { _Py_DECLARE_STR(empty, ""); - _ADDOP_NAME(c, LOC(s), IMPORT_NAME, &_Py_STR(empty), names); + ADDOP_NAME(c, LOC(s), IMPORT_NAME, &_Py_STR(empty), names); } for (Py_ssize_t i = 0; i < n; i++) { alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); @@ -4123,23 +4121,23 @@ compiler_from_import(struct compiler *c, stmt_ty s) if (i == 0 && PyUnicode_READ_CHAR(alias->name, 0) == '*') { assert(n == 1); - _ADDOP(c, LOC(s), IMPORT_STAR); - return 1; + ADDOP(c, LOC(s), IMPORT_STAR); + return SUCCESS; } - _ADDOP_NAME(c, LOC(s), IMPORT_FROM, alias->name, names); + ADDOP_NAME(c, LOC(s), IMPORT_FROM, alias->name, names); store_name = alias->name; if (alias->asname) { store_name = alias->asname; } if (!compiler_nameop(c, LOC(s), store_name, Store)) { - return 0; + return ERROR; } } /* remove imported module */ - _ADDOP(c, LOC(s), POP_TOP); - return 1; + ADDOP(c, LOC(s), POP_TOP); + return SUCCESS; } static int @@ -4258,7 +4256,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case Import_kind: return compiler_import(c, s) == SUCCESS ? 1 : 0; case ImportFrom_kind: - return compiler_from_import(c, s); + return compiler_from_import(c, s) == SUCCESS ? 1 : 0; case Global_kind: case Nonlocal_kind: break; @@ -4273,7 +4271,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) } case Break_kind: { - return compiler_break(c, LOC(s)); + return compiler_break(c, LOC(s)) == SUCCESS ? 1 : 0; } case Continue_kind: { From 229d6fd7628d5175dd33df189ebc3ded4d1a8e0a Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 20:21:50 +0000 Subject: [PATCH 43/93] compiler_continue, compiler_with, compiler_async_with return SUCCESS/ERROR --- Python/compile.c | 122 ++++++++++++++++++++++------------------------- 1 file changed, 58 insertions(+), 64 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index f35671b67106d7..00d706a885aaf6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3445,15 +3445,14 @@ compiler_continue(struct compiler *c, location loc) { struct fblockinfo *loop = NULL; /* Emit instruction with line number */ - _ADDOP(c, loc, NOP); - if (compiler_unwind_fblock_stack(c, &loc, 0, &loop) < 0) { - return 0; - } + ADDOP(c, loc, NOP); + RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, 0, &loop)); if (loop == NULL) { - return compiler_error(c, loc, "'continue' not properly in loop"); + compiler_error(c, loc, "'continue' not properly in loop"); + return ERROR; } - _ADDOP_JUMP(c, loc, JUMP, loop->fb_block); - return 1; + ADDOP_JUMP(c, loc, JUMP, loop->fb_block); + return SUCCESS; } @@ -4275,14 +4274,14 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) } case Continue_kind: { - return compiler_continue(c, LOC(s)); + return compiler_continue(c, LOC(s)) == SUCCESS ? 1 : 0; } case With_kind: - return compiler_with(c, s, 0); + return compiler_with(c, s, 0) == SUCCESS ? 1 : 0; case AsyncFunctionDef_kind: return compiler_function(c, s, 1); case AsyncWith_kind: - return compiler_async_with(c, s, 0); + return compiler_async_with(c, s, 0) == SUCCESS ? 1 : 0; case AsyncFor_kind: return compiler_async_for(c, s); } @@ -5803,7 +5802,8 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) if (IS_TOP_LEVEL_AWAIT(c)){ c->u->u_ste->ste_coroutine = 1; } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION){ - return compiler_error(c, loc, "'async with' outside async function"); + compiler_error(c, loc, "'async with' outside async function"); + return ERROR; } NEW_JUMP_TARGET_LABEL(c, block); @@ -5812,70 +5812,66 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) NEW_JUMP_TARGET_LABEL(c, cleanup); /* Evaluate EXPR */ - _VISIT(c, expr, item->context_expr); + VISIT(c, expr, item->context_expr); - _ADDOP(c, loc, BEFORE_ASYNC_WITH); - _ADDOP_I(c, loc, GET_AWAITABLE, 1); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); + ADDOP(c, loc, BEFORE_ASYNC_WITH); + ADDOP_I(c, loc, GET_AWAITABLE, 1); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); - _ADDOP_JUMP(c, loc, SETUP_WITH, final); + ADDOP_JUMP(c, loc, SETUP_WITH, final); /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); - if (compiler_push_fblock(c, loc, ASYNC_WITH, block, final, s) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_push_fblock(c, loc, ASYNC_WITH, block, final, s)); if (item->optional_vars) { - _VISIT(c, expr, item->optional_vars); + VISIT(c, expr, item->optional_vars); } else { - /* Discard result from context.__aenter__() */ - _ADDOP(c, loc, POP_TOP); + /* Discard result from context.__aenter__() */ + ADDOP(c, loc, POP_TOP); } pos++; if (pos == asdl_seq_LEN(s->v.AsyncWith.items)) { /* BLOCK code */ - _VISIT_SEQ(c, stmt, s->v.AsyncWith.body) + VISIT_SEQ(c, stmt, s->v.AsyncWith.body) } - else if (!compiler_async_with(c, s, pos)) { - return 0; + else if (compiler_async_with(c, s, pos) == ERROR) { + return ERROR; } compiler_pop_fblock(c, ASYNC_WITH, block); - _ADDOP(c, loc, POP_BLOCK); + ADDOP(c, loc, POP_BLOCK); /* End of body; start the cleanup */ /* For successful outcome: * call __exit__(None, None, None) */ - if (compiler_call_exit_with_nones(c, loc) < 0) { - return 0; - } - _ADDOP_I(c, loc, GET_AWAITABLE, 2); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); + RETURN_IF_ERROR(compiler_call_exit_with_nones(c, loc)); + ADDOP_I(c, loc, GET_AWAITABLE, 2); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); - _ADDOP(c, loc, POP_TOP); + ADDOP(c, loc, POP_TOP); - _ADDOP_JUMP(c, loc, JUMP, exit); + ADDOP_JUMP(c, loc, JUMP, exit); /* For exceptional outcome: */ USE_LABEL(c, final); - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - _ADDOP(c, loc, PUSH_EXC_INFO); - _ADDOP(c, loc, WITH_EXCEPT_START); - _ADDOP_I(c, loc, GET_AWAITABLE, 2); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + ADDOP(c, loc, PUSH_EXC_INFO); + ADDOP(c, loc, WITH_EXCEPT_START); + ADDOP_I(c, loc, GET_AWAITABLE, 2); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); compiler_with_except_finish(c, cleanup); USE_LABEL(c, exit); - return 1; + return SUCCESS; } @@ -5913,34 +5909,34 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) NEW_JUMP_TARGET_LABEL(c, cleanup); /* Evaluate EXPR */ - _VISIT(c, expr, item->context_expr); + VISIT(c, expr, item->context_expr); /* Will push bound __exit__ */ location loc = LOC(s); - _ADDOP(c, loc, BEFORE_WITH); - _ADDOP_JUMP(c, loc, SETUP_WITH, final); + ADDOP(c, loc, BEFORE_WITH); + ADDOP_JUMP(c, loc, SETUP_WITH, final); /* SETUP_WITH pushes a finally block. */ USE_LABEL(c, block); - if (compiler_push_fblock(c, loc, WITH, block, final, s) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_push_fblock(c, loc, WITH, block, final, s)); if (item->optional_vars) { - _VISIT(c, expr, item->optional_vars); + VISIT(c, expr, item->optional_vars); } else { /* Discard result from context.__enter__() */ - _ADDOP(c, loc, POP_TOP); + ADDOP(c, loc, POP_TOP); } pos++; - if (pos == asdl_seq_LEN(s->v.With.items)) + if (pos == asdl_seq_LEN(s->v.With.items)) { /* BLOCK code */ - _VISIT_SEQ(c, stmt, s->v.With.body) - else if (!compiler_with(c, s, pos)) - return 0; + VISIT_SEQ(c, stmt, s->v.With.body) + } + else if (compiler_with(c, s, pos) == ERROR) { + return ERROR; + } - _ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_BLOCK); compiler_pop_fblock(c, WITH, block); /* End of body; start the cleanup. */ @@ -5949,22 +5945,20 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) * call __exit__(None, None, None) */ loc = LOC(s); - if (compiler_call_exit_with_nones(c, loc) < 0) { - return 0; - } - _ADDOP(c, loc, POP_TOP); - _ADDOP_JUMP(c, loc, JUMP, exit); + RETURN_IF_ERROR(compiler_call_exit_with_nones(c, loc)); + ADDOP(c, loc, POP_TOP); + ADDOP_JUMP(c, loc, JUMP, exit); /* For exceptional outcome: */ USE_LABEL(c, final); - _ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); - _ADDOP(c, loc, PUSH_EXC_INFO); - _ADDOP(c, loc, WITH_EXCEPT_START); + ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); + ADDOP(c, loc, PUSH_EXC_INFO); + ADDOP(c, loc, WITH_EXCEPT_START); compiler_with_except_finish(c, cleanup); USE_LABEL(c, exit); - return 1; + return SUCCESS; } static int From f8b658e2170aa0f5d4d0efbd6a990fdd5bf2a058 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 20:27:56 +0000 Subject: [PATCH 44/93] compiler_stmt_expr, compiler_async_for return SUCCESS/ERROR --- Python/compile.c | 54 ++++++++++++++++++++++++------------------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 00d706a885aaf6..e4fa099a671f1c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3305,32 +3305,32 @@ compiler_async_for(struct compiler *c, stmt_ty s) if (IS_TOP_LEVEL_AWAIT(c)){ c->u->u_ste->ste_coroutine = 1; } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION) { - return compiler_error(c, loc, "'async for' outside async function"); + compiler_error(c, loc, "'async for' outside async function"); + return ERROR; } NEW_JUMP_TARGET_LABEL(c, start); NEW_JUMP_TARGET_LABEL(c, except); NEW_JUMP_TARGET_LABEL(c, end); - _VISIT(c, expr, s->v.AsyncFor.iter); - _ADDOP(c, loc, GET_AITER); + VISIT(c, expr, s->v.AsyncFor.iter); + ADDOP(c, loc, GET_AITER); USE_LABEL(c, start); - if (compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)); + /* SETUP_FINALLY to guard the __anext__ call */ - _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); - _ADDOP(c, loc, GET_ANEXT); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); - _ADDOP(c, loc, POP_BLOCK); /* for SETUP_FINALLY */ + ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + ADDOP(c, loc, GET_ANEXT); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); + ADDOP(c, loc, POP_BLOCK); /* for SETUP_FINALLY */ /* Success block for __anext__ */ - _VISIT(c, expr, s->v.AsyncFor.target); - _VISIT_SEQ(c, stmt, s->v.AsyncFor.body); + VISIT(c, expr, s->v.AsyncFor.target); + VISIT_SEQ(c, stmt, s->v.AsyncFor.body); /* Mark jump as artificial */ - _ADDOP_JUMP(c, NO_LOCATION, JUMP, start); + ADDOP_JUMP(c, NO_LOCATION, JUMP, start); compiler_pop_fblock(c, FOR_LOOP, start); @@ -3340,13 +3340,13 @@ compiler_async_for(struct compiler *c, stmt_ty s) /* Use same line number as the iterator, * as the END_ASYNC_FOR succeeds the `for`, not the body. */ loc = LOC(s->v.AsyncFor.iter); - _ADDOP(c, loc, END_ASYNC_FOR); + ADDOP(c, loc, END_ASYNC_FOR); /* `else` block */ - _VISIT_SEQ(c, stmt, s->v.For.orelse); + VISIT_SEQ(c, stmt, s->v.For.orelse); USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4177,20 +4177,20 @@ static int compiler_stmt_expr(struct compiler *c, location loc, expr_ty value) { if (c->c_interactive && c->c_nestlevel <= 1) { - _VISIT(c, expr, value); - _ADDOP(c, loc, PRINT_EXPR); - return 1; + VISIT(c, expr, value); + ADDOP(c, loc, PRINT_EXPR); + return SUCCESS; } if (value->kind == Constant_kind) { /* ignore constant statement */ - _ADDOP(c, loc, NOP); - return 1; + ADDOP(c, loc, NOP); + return SUCCESS; } - _VISIT(c, expr, value); - _ADDOP(c, NO_LOCATION, POP_TOP); /* artificial */ - return 1; + VISIT(c, expr, value); + ADDOP(c, NO_LOCATION, POP_TOP); /* artificial */ + return SUCCESS; } static int @@ -4261,7 +4261,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) break; case Expr_kind: { - return compiler_stmt_expr(c, LOC(s), s->v.Expr.value); + return compiler_stmt_expr(c, LOC(s), s->v.Expr.value) == SUCCESS ? 1 : 0; } case Pass_kind: { @@ -4283,7 +4283,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case AsyncWith_kind: return compiler_async_with(c, s, 0) == SUCCESS ? 1 : 0; case AsyncFor_kind: - return compiler_async_for(c, s); + return compiler_async_for(c, s) == SUCCESS ? 1 : 0; } return 1; From 5d8f93b2ce69964af1a3c3a01bc75c3b159f9c74 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:13:11 +0000 Subject: [PATCH 45/93] ensure_fail_pop return SUCCESS/ERROR --- Python/compile.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e4fa099a671f1c..5a39575e8aa383 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6482,20 +6482,20 @@ ensure_fail_pop(struct compiler *c, pattern_context *pc, Py_ssize_t n) { Py_ssize_t size = n + 1; if (size <= pc->fail_pop_size) { - return 1; + return SUCCESS; } Py_ssize_t needed = sizeof(jump_target_label) * size; jump_target_label *resized = PyObject_Realloc(pc->fail_pop, needed); if (resized == NULL) { PyErr_NoMemory(); - return 0; + return ERROR; } pc->fail_pop = resized; while (pc->fail_pop_size < size) { NEW_JUMP_TARGET_LABEL(c, new_block); pc->fail_pop[pc->fail_pop_size++] = new_block; } - return 1; + return SUCCESS; } // Use op to jump to the correct fail_pop block. @@ -6506,7 +6506,9 @@ jump_to_fail_pop(struct compiler *c, location loc, // Pop any items on the top of the stack, plus any objects we were going to // capture on success: Py_ssize_t pops = pc->on_top + PyList_GET_SIZE(pc->stores); - RETURN_IF_FALSE(ensure_fail_pop(c, pc, pops)); + if (ensure_fail_pop(c, pc, pops) < 0) { + return 0; + } _ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]); return 1; } @@ -7233,7 +7235,9 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) Py_DECREF(pc->stores); // NOTE: Returning macros are safe again. if (m->guard) { - RETURN_IF_FALSE(ensure_fail_pop(c, pc, 0)); + if (ensure_fail_pop(c, pc, 0) < 0) { + return 0; + } RETURN_IF_FALSE(compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0)); } // Success! Pop the subject off, we're done with it: From 71e13c241492eb8699c25ca68be5fa04bf971ac1 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:18:25 +0000 Subject: [PATCH 46/93] jump_to_fail_pop return SUCCESS/ERROR --- Python/compile.c | 46 +++++++++++++++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 5a39575e8aa383..47f5238f371b2e 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6506,11 +6506,9 @@ jump_to_fail_pop(struct compiler *c, location loc, // Pop any items on the top of the stack, plus any objects we were going to // capture on success: Py_ssize_t pops = pc->on_top + PyList_GET_SIZE(pc->stores); - if (ensure_fail_pop(c, pc, pops) < 0) { - return 0; - } - _ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]); - return 1; + RETURN_IF_ERROR(ensure_fail_pop(c, pc, pops)); + ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]); + return SUCCESS; } // Build all of the fail_pop blocks and reset fail_pop. @@ -6775,7 +6773,9 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) _ADDOP_I(c, LOC(p), IS_OP, 1); // TOS is now a tuple of (nargs + nattrs) attributes (or None): pc->on_top++; - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, nargs + nattrs); pc->on_top += nargs + nattrs - 1; for (i = 0; i < nargs + nattrs; i++) { @@ -6819,7 +6819,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // We need to keep the subject on top during the mapping and length checks: pc->on_top++; _ADDOP(c, LOC(p), MATCH_MAPPING); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } if (!size && !star_target) { // If the pattern is just "{}", we're done! Pop the subject: pc->on_top--; @@ -6831,7 +6833,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, _ADDOP(c, LOC(p), GET_LEN); _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); _ADDOP_COMPARE(c, LOC(p), GtE); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } } if (INT_MAX < size - 1) { return compiler_error(c, LOC(p), "too many sub-patterns in mapping pattern"); @@ -6892,7 +6896,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, _ADDOP_I(c, LOC(p), COPY, 1); _ADDOP_LOAD_CONST(c, LOC(p), Py_None); _ADDOP_I(c, LOC(p), IS_OP, 1); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } // So far so good. Use that tuple of values on the stack to match // sub-patterns against: _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); @@ -7037,7 +7043,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) old_pc.fail_pop = NULL; // No match. Pop the remaining copy of the subject and fail: if ((cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, LOC(p)) < 0) || - !jump_to_fail_pop(c, LOC(p), pc, JUMP)) { + jump_to_fail_pop(c, LOC(p), pc, JUMP) < 0) { goto error; } @@ -7114,20 +7120,26 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, // We need to keep the subject on top during the sequence and length checks: pc->on_top++; _ADDOP(c, LOC(p), MATCH_SEQUENCE); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } if (star < 0) { // No star: len(subject) == size _ADDOP(c, LOC(p), GET_LEN); _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); _ADDOP_COMPARE(c, LOC(p), Eq); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } } else if (size > 1) { // Star: len(subject) >= size - 1 _ADDOP(c, LOC(p), GET_LEN); _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size - 1)); _ADDOP_COMPARE(c, LOC(p), GtE); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } } // Whatever comes next should consume the subject: pc->on_top--; @@ -7155,7 +7167,9 @@ compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc) } _VISIT(c, expr, value); _ADDOP_COMPARE(c, LOC(p), Eq); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } return 1; } @@ -7165,7 +7179,9 @@ compiler_pattern_singleton(struct compiler *c, pattern_ty p, pattern_context *pc assert(p->kind == MatchSingleton_kind); _ADDOP_LOAD_CONST(c, LOC(p), p->v.MatchSingleton.value); _ADDOP_COMPARE(c, LOC(p), Is); - RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { + return 0; + } return 1; } From 4f10612f889144584dbbd9cc0ea21fa6e24a1fb9 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:22:03 +0000 Subject: [PATCH 47/93] emit_and_reset_fail_pop, compiler_error_duplicate_store return SUCCESS/ERROR --- Python/compile.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 47f5238f371b2e..842db6c48914b6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6518,7 +6518,7 @@ emit_and_reset_fail_pop(struct compiler *c, location loc, { if (!pc->fail_pop_size) { assert(pc->fail_pop == NULL); - return 1; + return SUCCESS; } while (--pc->fail_pop_size) { USE_LABEL(c, pc->fail_pop[pc->fail_pop_size]); @@ -6526,20 +6526,21 @@ emit_and_reset_fail_pop(struct compiler *c, location loc, pc->fail_pop_size = 0; PyObject_Free(pc->fail_pop); pc->fail_pop = NULL; - return 0; + return ERROR; } } USE_LABEL(c, pc->fail_pop[0]); PyObject_Free(pc->fail_pop); pc->fail_pop = NULL; - return 1; + return SUCCESS; } static int compiler_error_duplicate_store(struct compiler *c, location loc, identifier n) { - return compiler_error(c, loc, + compiler_error(c, loc, "multiple assignments to name %R in pattern", n); + return ERROR; } // Duplicate the effect of 3.10's ROT_* instructions using SWAPs. @@ -6569,7 +6570,8 @@ pattern_helper_store_name(struct compiler *c, location loc, return 0; } if (duplicate) { - return compiler_error_duplicate_store(c, loc, n); + compiler_error_duplicate_store(c, loc, n); + return 0; } // Rotate this object underneath any items we need to preserve: Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1; @@ -7030,8 +7032,8 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) } } assert(control); - if ((cfg_builder_addop_j(CFG_BUILDER(c), LOC(alt), JUMP, end) < 0) || - !emit_and_reset_fail_pop(c, LOC(alt), pc)) + if (cfg_builder_addop_j(CFG_BUILDER(c), LOC(alt), JUMP, end) < 0 || + emit_and_reset_fail_pop(c, LOC(alt), pc) < 0) { goto error; } @@ -7265,7 +7267,9 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) // If the pattern fails to match, we want the line number of the // cleanup to be associated with the failed pattern, not the last line // of the body - RETURN_IF_FALSE(emit_and_reset_fail_pop(c, LOC(m->pattern), pc)); + if (emit_and_reset_fail_pop(c, LOC(m->pattern), pc) < 0) { + return 0; + } } if (has_default) { // A trailing "case _" is common, and lets us save a bit of redundant From a5d017d4e302dce0dcd6cbb6cf7c2250c6b65257 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:23:49 +0000 Subject: [PATCH 48/93] pattern_helper_rotate return SUCCESS/ERROR --- Python/compile.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 842db6c48914b6..e875dc369e7971 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6548,9 +6548,9 @@ static int pattern_helper_rotate(struct compiler *c, location loc, Py_ssize_t count) { while (1 < count) { - _ADDOP_I(c, loc, SWAP, count--); + ADDOP_I(c, loc, SWAP, count--); } - return 1; + return SUCCESS; } static int @@ -6575,7 +6575,9 @@ pattern_helper_store_name(struct compiler *c, location loc, } // Rotate this object underneath any items we need to preserve: Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1; - RETURN_IF_FALSE(pattern_helper_rotate(c, loc, rotations)); + if (pattern_helper_rotate(c, loc, rotations) < 0) { + return 0; + } return !PyList_Append(pc->stores, n); } @@ -7024,7 +7026,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) // Do the same thing to the stack, using several // rotations: while (rotations--) { - if (!pattern_helper_rotate(c, LOC(alt), icontrol + 1)){ + if (pattern_helper_rotate(c, LOC(alt), icontrol + 1) < 0) { goto error; } } @@ -7060,7 +7062,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) Py_ssize_t nrots = nstores + 1 + pc->on_top + PyList_GET_SIZE(pc->stores); for (Py_ssize_t i = 0; i < nstores; i++) { // Rotate this capture to its proper place on the stack: - if (!pattern_helper_rotate(c, LOC(p), nrots)) { + if (pattern_helper_rotate(c, LOC(p), nrots) < 0) { goto error; } // Update the list of previous stores with this new name, checking for From cbb63b054246bd6e6d26456f16a4355b5a68b696 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:28:11 +0000 Subject: [PATCH 49/93] pattern_helper_store_name returns SUCCESS/ERROR --- Python/compile.c | 31 ++++++++++++++++++++----------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e875dc369e7971..40eaa895b6fe81 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6558,27 +6558,30 @@ pattern_helper_store_name(struct compiler *c, location loc, identifier n, pattern_context *pc) { if (n == NULL) { - _ADDOP(c, loc, POP_TOP); - return 1; + ADDOP(c, loc, POP_TOP); + return SUCCESS; } if (forbidden_name(c, loc, n, Store)) { - return 0; + return ERROR; } // Can't assign to the same name twice: int duplicate = PySequence_Contains(pc->stores, n); if (duplicate < 0) { - return 0; + return ERROR; } if (duplicate) { compiler_error_duplicate_store(c, loc, n); - return 0; + return ERROR; } // Rotate this object underneath any items we need to preserve: Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1; if (pattern_helper_rotate(c, loc, rotations) < 0) { - return 0; + return ERROR; + } + if (PyList_Append(pc->stores, n) < 0) { + return ERROR; } - return !PyList_Append(pc->stores, n); + return SUCCESS; } @@ -6695,7 +6698,7 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) const char *e = "wildcard makes remaining patterns unreachable"; return compiler_error(c, LOC(p), e); } - return pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc); + return pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc) == SUCCESS ? 1 : 0; } // Need to make a copy for (possibly) storing later: pc->on_top++; @@ -6703,7 +6706,9 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) RETURN_IF_FALSE(compiler_pattern(c, p->v.MatchAs.pattern, pc)); // Success! Store it: pc->on_top--; - RETURN_IF_FALSE(pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc)); + if (pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc) < 0) { + return 0; + } return 1; } @@ -6711,7 +6716,9 @@ static int compiler_pattern_star(struct compiler *c, pattern_ty p, pattern_context *pc) { assert(p->kind == MatchStar_kind); - RETURN_IF_FALSE(pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc)); + if (pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc) < 0) { + return 0; + } return 1; } @@ -6931,7 +6938,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, _ADDOP_I(c, LOC(p), SWAP, 2); // [copy, keys..., copy, key] _ADDOP(c, LOC(p), DELETE_SUBSCR); // [copy, keys...] } - RETURN_IF_FALSE(pattern_helper_store_name(c, LOC(p), star_target, pc)); + if (pattern_helper_store_name(c, LOC(p), star_target, pc) < 0) { + return 0; + } } else { _ADDOP(c, LOC(p), POP_TOP); // Tuple of keys. From 06ba665a91fe49e58bd9065d8c46d2b5dc20cca4 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:30:46 +0000 Subject: [PATCH 50/93] pattern_unpack_helper returns SUCCESS/ERROR --- Python/compile.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 40eaa895b6fe81..554894a3b46300 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6595,22 +6595,25 @@ pattern_unpack_helper(struct compiler *c, location loc, pattern_ty elt = asdl_seq_GET(elts, i); if (elt->kind == MatchStar_kind && !seen_star) { if ((i >= (1 << 8)) || - (n-i-1 >= (INT_MAX >> 8))) - return compiler_error(c, loc, + (n-i-1 >= (INT_MAX >> 8))) { + compiler_error(c, loc, "too many expressions in " "star-unpacking sequence pattern"); - _ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); + return ERROR; + } + ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == MatchStar_kind) { - return compiler_error(c, loc, + compiler_error(c, loc, "multiple starred expressions in sequence pattern"); + return ERROR; } } if (!seen_star) { - _ADDOP_I(c, loc, UNPACK_SEQUENCE, n); + ADDOP_I(c, loc, UNPACK_SEQUENCE, n); } - return 1; + return SUCCESS; } static int @@ -6618,7 +6621,9 @@ pattern_helper_sequence_unpack(struct compiler *c, location loc, asdl_pattern_seq *patterns, Py_ssize_t star, pattern_context *pc) { - RETURN_IF_FALSE(pattern_unpack_helper(c, loc, patterns)); + if (pattern_unpack_helper(c, loc, patterns) < 0) { + return 0; + } Py_ssize_t size = asdl_seq_LEN(patterns); // We've now got a bunch of new subjects on the stack. They need to remain // there after each subpattern match: From 0b84a46bf2900096de872e6429165d76323f5826 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:34:28 +0000 Subject: [PATCH 51/93] pattern_helper_sequence_unpack returns SUCCESS/ERROR --- Python/compile.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 554894a3b46300..e0f2a5be7713f7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6622,7 +6622,7 @@ pattern_helper_sequence_unpack(struct compiler *c, location loc, pattern_context *pc) { if (pattern_unpack_helper(c, loc, patterns) < 0) { - return 0; + return ERROR; } Py_ssize_t size = asdl_seq_LEN(patterns); // We've now got a bunch of new subjects on the stack. They need to remain @@ -6632,9 +6632,11 @@ pattern_helper_sequence_unpack(struct compiler *c, location loc, // One less item to keep track of each time we loop through: pc->on_top--; pattern_ty pattern = asdl_seq_GET(patterns, i); - RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); + if (!compiler_pattern_subpattern(c, pattern, pc)) { + return ERROR; + } } - return 1; + return SUCCESS; } // Like pattern_helper_sequence_unpack, but uses BINARY_SUBSCR instead of @@ -7169,7 +7171,9 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, RETURN_IF_FALSE(pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); } else { - RETURN_IF_FALSE(pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc)); + if (pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc) < 0) { + return 0; + } } return 1; } From c8acddb5918864d6426ecfc90823096641a9c98e Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:39:54 +0000 Subject: [PATCH 52/93] pattern_helper_sequence_subscr, compiler_pattern_subpattern return SUCCESS/ERROR --- Python/compile.c | 40 +++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e0f2a5be7713f7..3dfff99f0d87ea 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6632,9 +6632,7 @@ pattern_helper_sequence_unpack(struct compiler *c, location loc, // One less item to keep track of each time we loop through: pc->on_top--; pattern_ty pattern = asdl_seq_GET(patterns, i); - if (!compiler_pattern_subpattern(c, pattern, pc)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc)); } return SUCCESS; } @@ -6659,24 +6657,24 @@ pattern_helper_sequence_subscr(struct compiler *c, location loc, assert(WILDCARD_STAR_CHECK(pattern)); continue; } - _ADDOP_I(c, loc, COPY, 1); + ADDOP_I(c, loc, COPY, 1); if (i < star) { - _ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(i)); + ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(i)); } else { // The subject may not support negative indexing! Compute a // nonnegative index: - _ADDOP(c, loc, GET_LEN); - _ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(size - i)); - _ADDOP_BINARY(c, loc, Sub); + ADDOP(c, loc, GET_LEN); + ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromSsize_t(size - i)); + ADDOP_BINARY(c, loc, Sub); } - _ADDOP(c, loc, BINARY_SUBSCR); - RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); + ADDOP(c, loc, BINARY_SUBSCR); + RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc)); } // Pop the subject, we're done with it: pc->on_top--; - _ADDOP(c, loc, POP_TOP); - return 1; + ADDOP(c, loc, POP_TOP); + return SUCCESS; } // Like compiler_pattern, but turn off checks for irrefutability. @@ -6686,9 +6684,11 @@ compiler_pattern_subpattern(struct compiler *c, { int allow_irrefutable = pc->allow_irrefutable; pc->allow_irrefutable = 1; - RETURN_IF_FALSE(compiler_pattern(c, p, pc)); + if (!compiler_pattern(c, p, pc)) { + return ERROR; + } pc->allow_irrefutable = allow_irrefutable; - return 1; + return SUCCESS; } static int @@ -6811,7 +6811,9 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) _ADDOP(c, LOC(p), POP_TOP); continue; } - RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); + if (compiler_pattern_subpattern(c, pattern, pc) < 0) { + return 0; + } } // Success! Pop the tuple of attributes: return 1; @@ -6924,7 +6926,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, for (Py_ssize_t i = 0; i < size; i++) { pc->on_top--; pattern_ty pattern = asdl_seq_GET(patterns, i); - RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc)); + if (compiler_pattern_subpattern(c, pattern, pc) < 0) { + return 0; + } } // If we get this far, it's a match! Whatever happens next should consume // the tuple of keys and the subject: @@ -7168,7 +7172,9 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, _ADDOP(c, LOC(p), POP_TOP); } else if (star_wildcard) { - RETURN_IF_FALSE(pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); + if (pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc) < 0) { + return 0; + } } else { if (pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc) < 0) { From 44d545284f7b82f6f377847dbec05eea6548b7f8 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:45:16 +0000 Subject: [PATCH 53/93] compiler_pattern_as, compiler_pattern_star return SUCCESS/ERROR --- Python/compile.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 3dfff99f0d87ea..1c3c2a27fd6b26 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6700,33 +6700,34 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) if (!pc->allow_irrefutable) { if (p->v.MatchAs.name) { const char *e = "name capture %R makes remaining patterns unreachable"; - return compiler_error(c, LOC(p), e, p->v.MatchAs.name); + compiler_error(c, LOC(p), e, p->v.MatchAs.name); + return ERROR; } const char *e = "wildcard makes remaining patterns unreachable"; - return compiler_error(c, LOC(p), e); + compiler_error(c, LOC(p), e); + return ERROR; } - return pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc) == SUCCESS ? 1 : 0; + return pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc); } // Need to make a copy for (possibly) storing later: pc->on_top++; - _ADDOP_I(c, LOC(p), COPY, 1); - RETURN_IF_FALSE(compiler_pattern(c, p->v.MatchAs.pattern, pc)); + ADDOP_I(c, LOC(p), COPY, 1); + if (!compiler_pattern(c, p->v.MatchAs.pattern, pc)) { + return ERROR; + } // Success! Store it: pc->on_top--; - if (pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc) < 0) { - return 0; - } - return 1; + RETURN_IF_ERROR(pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc)); + return SUCCESS; } static int compiler_pattern_star(struct compiler *c, pattern_ty p, pattern_context *pc) { assert(p->kind == MatchStar_kind); - if (pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc) < 0) { - return 0; - } - return 1; + RETURN_IF_ERROR( + pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc)); + return SUCCESS; } static int @@ -7228,9 +7229,9 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) case MatchClass_kind: return compiler_pattern_class(c, p, pc); case MatchStar_kind: - return compiler_pattern_star(c, p, pc); + return compiler_pattern_star(c, p, pc) == SUCCESS ? 1 : 0; case MatchAs_kind: - return compiler_pattern_as(c, p, pc); + return compiler_pattern_as(c, p, pc) == SUCCESS ? 1 : 0; case MatchOr_kind: return compiler_pattern_or(c, p, pc); } From 77d8b27968006e7649a68bc79faa7f939470ef09 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:52:12 +0000 Subject: [PATCH 54/93] compiler_pattern_class, validate_kwd_attrs return SUCCESS/ERROR --- Python/compile.c | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 1c3c2a27fd6b26..34bcf1f8a1e827 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6740,18 +6740,18 @@ validate_kwd_attrs(struct compiler *c, asdl_identifier_seq *attrs, asdl_pattern_ identifier attr = ((identifier)asdl_seq_GET(attrs, i)); location loc = LOC((pattern_ty) asdl_seq_GET(patterns, i)); if (forbidden_name(c, loc, attr, Store)) { - return -1; + return ERROR; } for (Py_ssize_t j = i + 1; j < nattrs; j++) { identifier other = ((identifier)asdl_seq_GET(attrs, j)); if (!PyUnicode_Compare(attr, other)) { location loc = LOC((pattern_ty) asdl_seq_GET(patterns, j)); compiler_error(c, loc, "attribute name repeated in class pattern: %U", attr); - return -1; + return ERROR; } } } - return 0; + return SUCCESS; } static int @@ -6768,34 +6768,36 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char * e = "kwd_attrs (%d) / kwd_patterns (%d) length mismatch in class pattern"; - return compiler_error(c, LOC(p), e, nattrs, nkwd_patterns); + compiler_error(c, LOC(p), e, nattrs, nkwd_patterns); + return ERROR; } if (INT_MAX < nargs || INT_MAX < nargs + nattrs - 1) { const char *e = "too many sub-patterns in class pattern %R"; - return compiler_error(c, LOC(p), e, p->v.MatchClass.cls); + compiler_error(c, LOC(p), e, p->v.MatchClass.cls); + return ERROR; } if (nattrs) { - RETURN_IF_FALSE(!validate_kwd_attrs(c, kwd_attrs, kwd_patterns)); + RETURN_IF_ERROR(validate_kwd_attrs(c, kwd_attrs, kwd_patterns)); + } + VISIT(c, expr, p->v.MatchClass.cls); + PyObject *attr_names = PyTuple_New(nattrs); + if (!attr_names) { + return ERROR; } - _VISIT(c, expr, p->v.MatchClass.cls); - PyObject *attr_names; - RETURN_IF_FALSE(attr_names = PyTuple_New(nattrs)); Py_ssize_t i; for (i = 0; i < nattrs; i++) { PyObject *name = asdl_seq_GET(kwd_attrs, i); PyTuple_SET_ITEM(attr_names, i, Py_NewRef(name)); } - _ADDOP_LOAD_CONST_NEW(c, LOC(p), attr_names); - _ADDOP_I(c, LOC(p), MATCH_CLASS, nargs); - _ADDOP_I(c, LOC(p), COPY, 1); - _ADDOP_LOAD_CONST(c, LOC(p), Py_None); - _ADDOP_I(c, LOC(p), IS_OP, 1); + ADDOP_LOAD_CONST_NEW(c, LOC(p), attr_names); + ADDOP_I(c, LOC(p), MATCH_CLASS, nargs); + ADDOP_I(c, LOC(p), COPY, 1); + ADDOP_LOAD_CONST(c, LOC(p), Py_None); + ADDOP_I(c, LOC(p), IS_OP, 1); // TOS is now a tuple of (nargs + nattrs) attributes (or None): pc->on_top++; - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } - _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, nargs + nattrs); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, nargs + nattrs); pc->on_top += nargs + nattrs - 1; for (i = 0; i < nargs + nattrs; i++) { pc->on_top--; @@ -6809,15 +6811,13 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) pattern = asdl_seq_GET(kwd_patterns, i - nargs); } if (WILDCARD_CHECK(pattern)) { - _ADDOP(c, LOC(p), POP_TOP); + ADDOP(c, LOC(p), POP_TOP); continue; } - if (compiler_pattern_subpattern(c, pattern, pc) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc)); } // Success! Pop the tuple of attributes: - return 1; + return SUCCESS; } static int @@ -7227,7 +7227,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) case MatchMapping_kind: return compiler_pattern_mapping(c, p, pc); case MatchClass_kind: - return compiler_pattern_class(c, p, pc); + return compiler_pattern_class(c, p, pc) == SUCCESS ? 1 : 0; case MatchStar_kind: return compiler_pattern_star(c, p, pc) == SUCCESS ? 1 : 0; case MatchAs_kind: From 2e23b8f077a16f62d5febe8d6ce9df90d8c852fa Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:56:57 +0000 Subject: [PATCH 55/93] compiler_pattern_mapping returns SUCCESS/ERROR --- Python/compile.c | 76 ++++++++++++++++++++++-------------------------- 1 file changed, 34 insertions(+), 42 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 34bcf1f8a1e827..ba5c3e32367f2b 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6833,33 +6833,31 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char * e = "keys (%d) / patterns (%d) length mismatch in mapping pattern"; - return compiler_error(c, LOC(p), e, size, npatterns); + compiler_error(c, LOC(p), e, size, npatterns); + return ERROR; } // We have a double-star target if "rest" is set PyObject *star_target = p->v.MatchMapping.rest; // We need to keep the subject on top during the mapping and length checks: pc->on_top++; - _ADDOP(c, LOC(p), MATCH_MAPPING); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP(c, LOC(p), MATCH_MAPPING); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); if (!size && !star_target) { // If the pattern is just "{}", we're done! Pop the subject: pc->on_top--; - _ADDOP(c, LOC(p), POP_TOP); - return 1; + ADDOP(c, LOC(p), POP_TOP); + return SUCCESS; } if (size) { // If the pattern has any keys in it, perform a length check: - _ADDOP(c, LOC(p), GET_LEN); - _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); - _ADDOP_COMPARE(c, LOC(p), GtE); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP(c, LOC(p), GET_LEN); + ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); + ADDOP_COMPARE(c, LOC(p), GtE); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } if (INT_MAX < size - 1) { - return compiler_error(c, LOC(p), "too many sub-patterns in mapping pattern"); + compiler_error(c, LOC(p), "too many sub-patterns in mapping pattern"); + return ERROR; } // Collect all of the keys into a tuple for MATCH_KEYS and // **rest. They can either be dotted names or literals: @@ -6868,7 +6866,7 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // SyntaxError in the case of duplicates. PyObject *seen = PySet_New(NULL); if (seen == NULL) { - return 0; + return ERROR; } // NOTE: goto error on failure in the loop below to avoid leaking `seen` @@ -6910,26 +6908,22 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // all keys have been checked; there are no duplicates Py_DECREF(seen); - _ADDOP_I(c, LOC(p), BUILD_TUPLE, size); - _ADDOP(c, LOC(p), MATCH_KEYS); + ADDOP_I(c, LOC(p), BUILD_TUPLE, size); + ADDOP(c, LOC(p), MATCH_KEYS); // There's now a tuple of keys and a tuple of values on top of the subject: pc->on_top += 2; - _ADDOP_I(c, LOC(p), COPY, 1); - _ADDOP_LOAD_CONST(c, LOC(p), Py_None); - _ADDOP_I(c, LOC(p), IS_OP, 1); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP_I(c, LOC(p), COPY, 1); + ADDOP_LOAD_CONST(c, LOC(p), Py_None); + ADDOP_I(c, LOC(p), IS_OP, 1); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); // So far so good. Use that tuple of values on the stack to match // sub-patterns against: - _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); + ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); pc->on_top += size - 1; for (Py_ssize_t i = 0; i < size; i++) { pc->on_top--; pattern_ty pattern = asdl_seq_GET(patterns, i); - if (compiler_pattern_subpattern(c, pattern, pc) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc)); } // If we get this far, it's a match! Whatever happens next should consume // the tuple of keys and the subject: @@ -6941,28 +6935,26 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // rest = dict(TOS1) // for key in TOS: // del rest[key] - _ADDOP_I(c, LOC(p), BUILD_MAP, 0); // [subject, keys, empty] - _ADDOP_I(c, LOC(p), SWAP, 3); // [empty, keys, subject] - _ADDOP_I(c, LOC(p), DICT_UPDATE, 2); // [copy, keys] - _ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); // [copy, keys...] + ADDOP_I(c, LOC(p), BUILD_MAP, 0); // [subject, keys, empty] + ADDOP_I(c, LOC(p), SWAP, 3); // [empty, keys, subject] + ADDOP_I(c, LOC(p), DICT_UPDATE, 2); // [copy, keys] + ADDOP_I(c, LOC(p), UNPACK_SEQUENCE, size); // [copy, keys...] while (size) { - _ADDOP_I(c, LOC(p), COPY, 1 + size--); // [copy, keys..., copy] - _ADDOP_I(c, LOC(p), SWAP, 2); // [copy, keys..., copy, key] - _ADDOP(c, LOC(p), DELETE_SUBSCR); // [copy, keys...] - } - if (pattern_helper_store_name(c, LOC(p), star_target, pc) < 0) { - return 0; + ADDOP_I(c, LOC(p), COPY, 1 + size--); // [copy, keys..., copy] + ADDOP_I(c, LOC(p), SWAP, 2); // [copy, keys..., copy, key] + ADDOP(c, LOC(p), DELETE_SUBSCR); // [copy, keys...] } + RETURN_IF_ERROR(pattern_helper_store_name(c, LOC(p), star_target, pc)); } else { - _ADDOP(c, LOC(p), POP_TOP); // Tuple of keys. - _ADDOP(c, LOC(p), POP_TOP); // Subject. + ADDOP(c, LOC(p), POP_TOP); // Tuple of keys. + ADDOP(c, LOC(p), POP_TOP); // Subject. } - return 1; + return SUCCESS; error: Py_DECREF(seen); - return 0; + return ERROR; } static int @@ -7225,7 +7217,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) case MatchSequence_kind: return compiler_pattern_sequence(c, p, pc); case MatchMapping_kind: - return compiler_pattern_mapping(c, p, pc); + return compiler_pattern_mapping(c, p, pc) == SUCCESS ? 1 : 0; case MatchClass_kind: return compiler_pattern_class(c, p, pc) == SUCCESS ? 1 : 0; case MatchStar_kind: From 31bc6cdead0de4b13e73e225c0427d2a400de1d8 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 21:59:31 +0000 Subject: [PATCH 56/93] compiler_pattern_or returns SUCCESS/ERROR --- Python/compile.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index ba5c3e32367f2b..771513f365b7ea 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -7097,15 +7097,15 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) Py_DECREF(control); // NOTE: Returning macros are safe again. // Pop the copy of the subject: - _ADDOP(c, LOC(p), POP_TOP); - return 1; + ADDOP(c, LOC(p), POP_TOP); + return SUCCESS; diff: compiler_error(c, LOC(p), "alternative patterns bind different names"); error: PyObject_Free(old_pc.fail_pop); Py_DECREF(old_pc.stores); Py_XDECREF(control); - return 0; + return ERROR; } @@ -7225,7 +7225,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) case MatchAs_kind: return compiler_pattern_as(c, p, pc) == SUCCESS ? 1 : 0; case MatchOr_kind: - return compiler_pattern_or(c, p, pc); + return compiler_pattern_or(c, p, pc) == SUCCESS ? 1 : 0; } // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter From 42c36cf88a35a888582578d71a94d1d3dc63a19c Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:03:25 +0000 Subject: [PATCH 57/93] compiler_pattern_sequence returns SUCCESS/ERROR --- Python/compile.c | 45 +++++++++++++++++++-------------------------- 1 file changed, 19 insertions(+), 26 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 771513f365b7ea..2f7a7d96cb0cfb 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -7125,7 +7125,8 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, if (pattern->kind == MatchStar_kind) { if (star >= 0) { const char *e = "multiple starred names in sequence pattern"; - return compiler_error(c, LOC(p), e); + compiler_error(c, LOC(p), e); + return ERROR; } star_wildcard = WILDCARD_STAR_CHECK(pattern); only_wildcard &= star_wildcard; @@ -7136,45 +7137,37 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, } // We need to keep the subject on top during the sequence and length checks: pc->on_top++; - _ADDOP(c, LOC(p), MATCH_SEQUENCE); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP(c, LOC(p), MATCH_SEQUENCE); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); if (star < 0) { // No star: len(subject) == size - _ADDOP(c, LOC(p), GET_LEN); - _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); - _ADDOP_COMPARE(c, LOC(p), Eq); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP(c, LOC(p), GET_LEN); + ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size)); + ADDOP_COMPARE(c, LOC(p), Eq); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } else if (size > 1) { // Star: len(subject) >= size - 1 - _ADDOP(c, LOC(p), GET_LEN); - _ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size - 1)); - _ADDOP_COMPARE(c, LOC(p), GtE); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } + ADDOP(c, LOC(p), GET_LEN); + ADDOP_LOAD_CONST_NEW(c, LOC(p), PyLong_FromSsize_t(size - 1)); + ADDOP_COMPARE(c, LOC(p), GtE); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } // Whatever comes next should consume the subject: pc->on_top--; if (only_wildcard) { // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc. - _ADDOP(c, LOC(p), POP_TOP); + ADDOP(c, LOC(p), POP_TOP); } else if (star_wildcard) { - if (pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc) < 0) { - return 0; - } + RETURN_IF_ERROR( + pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); } else { - if (pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc) < 0) { - return 0; - } + RETURN_IF_ERROR( + pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc)); } - return 1; + return SUCCESS; } static int @@ -7215,7 +7208,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) case MatchSingleton_kind: return compiler_pattern_singleton(c, p, pc); case MatchSequence_kind: - return compiler_pattern_sequence(c, p, pc); + return compiler_pattern_sequence(c, p, pc) == SUCCESS ? 1 : 0; case MatchMapping_kind: return compiler_pattern_mapping(c, p, pc) == SUCCESS ? 1 : 0; case MatchClass_kind: From a0a19dc3dc3930e9d7b80a4e1a8d790c12fc43b1 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:06:29 +0000 Subject: [PATCH 58/93] compiler_pattern_value, compiler_pattern_singleton returns SUCCESS/ERROR --- Python/compile.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 2f7a7d96cb0cfb..fece7dc889ef81 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -7177,26 +7177,23 @@ compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc) expr_ty value = p->v.MatchValue.value; if (!MATCH_VALUE_EXPR(value)) { const char *e = "patterns may only match literals and attribute lookups"; - return compiler_error(c, LOC(p), e); - } - _VISIT(c, expr, value); - _ADDOP_COMPARE(c, LOC(p), Eq); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; + compiler_error(c, LOC(p), e); + return ERROR; } - return 1; + VISIT(c, expr, value); + ADDOP_COMPARE(c, LOC(p), Eq); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + return SUCCESS; } static int compiler_pattern_singleton(struct compiler *c, pattern_ty p, pattern_context *pc) { assert(p->kind == MatchSingleton_kind); - _ADDOP_LOAD_CONST(c, LOC(p), p->v.MatchSingleton.value); - _ADDOP_COMPARE(c, LOC(p), Is); - if (jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE) < 0) { - return 0; - } - return 1; + ADDOP_LOAD_CONST(c, LOC(p), p->v.MatchSingleton.value); + ADDOP_COMPARE(c, LOC(p), Is); + RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); + return SUCCESS; } static int @@ -7204,9 +7201,9 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) { switch (p->kind) { case MatchValue_kind: - return compiler_pattern_value(c, p, pc); + return compiler_pattern_value(c, p, pc) == SUCCESS ? 1 : 0; case MatchSingleton_kind: - return compiler_pattern_singleton(c, p, pc); + return compiler_pattern_singleton(c, p, pc) == SUCCESS ? 1 : 0; case MatchSequence_kind: return compiler_pattern_sequence(c, p, pc) == SUCCESS ? 1 : 0; case MatchMapping_kind: From ac78f3ca54affe3427d309f9931f2d6db569ba79 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:10:18 +0000 Subject: [PATCH 59/93] compiler_pattern return SUCCESS/ERROR --- Python/compile.c | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index fece7dc889ef81..fff5777987d6c6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6684,9 +6684,7 @@ compiler_pattern_subpattern(struct compiler *c, { int allow_irrefutable = pc->allow_irrefutable; pc->allow_irrefutable = 1; - if (!compiler_pattern(c, p, pc)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_pattern(c, p, pc)); pc->allow_irrefutable = allow_irrefutable; return SUCCESS; } @@ -6712,9 +6710,7 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) // Need to make a copy for (possibly) storing later: pc->on_top++; ADDOP_I(c, LOC(p), COPY, 1); - if (!compiler_pattern(c, p->v.MatchAs.pattern, pc)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_pattern(c, p->v.MatchAs.pattern, pc)); // Success! Store it: pc->on_top--; RETURN_IF_ERROR(pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc)); @@ -6984,8 +6980,8 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) pc->fail_pop = NULL; pc->fail_pop_size = 0; pc->on_top = 0; - if ((cfg_builder_addop_i(CFG_BUILDER(c), COPY, 1, LOC(alt)) < 0) || - !compiler_pattern(c, alt, pc)) { + if (cfg_builder_addop_i(CFG_BUILDER(c), COPY, 1, LOC(alt)) < 0 || + compiler_pattern(c, alt, pc) < 0) { goto error; } // Success! @@ -7201,26 +7197,27 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) { switch (p->kind) { case MatchValue_kind: - return compiler_pattern_value(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_value(c, p, pc); case MatchSingleton_kind: - return compiler_pattern_singleton(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_singleton(c, p, pc); case MatchSequence_kind: - return compiler_pattern_sequence(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_sequence(c, p, pc); case MatchMapping_kind: - return compiler_pattern_mapping(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_mapping(c, p, pc); case MatchClass_kind: - return compiler_pattern_class(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_class(c, p, pc); case MatchStar_kind: - return compiler_pattern_star(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_star(c, p, pc); case MatchAs_kind: - return compiler_pattern_as(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_as(c, p, pc); case MatchOr_kind: - return compiler_pattern_or(c, p, pc) == SUCCESS ? 1 : 0; + return compiler_pattern_or(c, p, pc); } // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char *e = "invalid match pattern node in AST (kind=%d)"; - return compiler_error(c, LOC(p), e, p->kind); + compiler_error(c, LOC(p), e, p->kind); + return ERROR; } static int @@ -7245,7 +7242,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) pc->fail_pop_size = 0; pc->on_top = 0; // NOTE: Can't use returning macros here (they'll leak pc->stores)! - if (!compiler_pattern(c, m->pattern, pc)) { + if (compiler_pattern(c, m->pattern, pc) < 0) { Py_DECREF(pc->stores); return 0; } From 57bffdea8cb88b5967265b1ff155882535083ff7 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:15:59 +0000 Subject: [PATCH 60/93] compiler_match, compiler_match_inner return SUCCESS/ERROR --- Python/compile.c | 43 +++++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index fff5777987d6c6..dc6fb5042c07bd 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4231,7 +4231,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case If_kind: return compiler_if(c, s) == SUCCESS ? 1 : 0; case Match_kind: - return compiler_match(c, s); + return compiler_match(c, s) == SUCCESS ? 1 : 0; case Raise_kind: { Py_ssize_t n = 0; @@ -7223,7 +7223,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) static int compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) { - _VISIT(c, expr, s->v.Match.subject); + VISIT(c, expr, s->v.Match.subject); NEW_JUMP_TARGET_LABEL(c, end); Py_ssize_t cases = asdl_seq_LEN(s->v.Match.cases); assert(cases > 0); @@ -7233,9 +7233,12 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) m = asdl_seq_GET(s->v.Match.cases, i); // Only copy the subject if we're *not* on the last case: if (i != cases - has_default - 1) { - _ADDOP_I(c, LOC(m->pattern), COPY, 1); + ADDOP_I(c, LOC(m->pattern), COPY, 1); + } + pc->stores = PyList_New(0); + if (!pc->stores) { + return ERROR; } - RETURN_IF_FALSE(pc->stores = PyList_New(0)); // Irrefutable cases must be either guarded, last, or both: pc->allow_irrefutable = m->guard != NULL || i == cases - 1; pc->fail_pop = NULL; @@ -7244,7 +7247,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) // NOTE: Can't use returning macros here (they'll leak pc->stores)! if (compiler_pattern(c, m->pattern, pc) < 0) { Py_DECREF(pc->stores); - return 0; + return ERROR; } assert(!pc->on_top); // It's a match! Store all of the captured names (they're on the stack). @@ -7253,29 +7256,27 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) PyObject *name = PyList_GET_ITEM(pc->stores, n); if (!compiler_nameop(c, LOC(m->pattern), name, Store)) { Py_DECREF(pc->stores); - return 0; + return ERROR; } } Py_DECREF(pc->stores); // NOTE: Returning macros are safe again. if (m->guard) { - if (ensure_fail_pop(c, pc, 0) < 0) { - return 0; + RETURN_IF_ERROR(ensure_fail_pop(c, pc, 0)); + if (!compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0)) { + return ERROR; } - RETURN_IF_FALSE(compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0)); } // Success! Pop the subject off, we're done with it: if (i != cases - has_default - 1) { - _ADDOP(c, LOC(m->pattern), POP_TOP); + ADDOP(c, LOC(m->pattern), POP_TOP); } - _VISIT_SEQ(c, stmt, m->body); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + VISIT_SEQ(c, stmt, m->body); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); // If the pattern fails to match, we want the line number of the // cleanup to be associated with the failed pattern, not the last line // of the body - if (emit_and_reset_fail_pop(c, LOC(m->pattern), pc) < 0) { - return 0; - } + RETURN_IF_ERROR(emit_and_reset_fail_pop(c, LOC(m->pattern), pc)); } if (has_default) { // A trailing "case _" is common, and lets us save a bit of redundant @@ -7283,19 +7284,21 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) m = asdl_seq_GET(s->v.Match.cases, cases - 1); if (cases == 1) { // No matches. Done with the subject: - _ADDOP(c, LOC(m->pattern), POP_TOP); + ADDOP(c, LOC(m->pattern), POP_TOP); } else { // Show line coverage for default case (it doesn't create bytecode) - _ADDOP(c, LOC(m->pattern), NOP); + ADDOP(c, LOC(m->pattern), NOP); } if (m->guard) { - RETURN_IF_FALSE(compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)); + if (!compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)) { + return ERROR; + } } - _VISIT_SEQ(c, stmt, m->body); + VISIT_SEQ(c, stmt, m->body); } USE_LABEL(c, end); - return 1; + return SUCCESS; } static int From 855cdde3df79d374342c7a18509e765f89a0aa8b Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:21:46 +0000 Subject: [PATCH 61/93] compiler_function return SUCCESS/ERROR --- Python/compile.c | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index dc6fb5042c07bd..e7fd4dd78ab442 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2783,11 +2783,11 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) } if (compiler_check_debug_args(c, args) < 0) { - return 0; + return ERROR; } if (compiler_decorators(c, decos) < 0) { - return 0; + return ERROR; } firstlineno = s->lineno; @@ -2798,19 +2798,18 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) location loc = LOC(s); funcflags = compiler_default_arguments(c, loc, args); if (funcflags == -1) { - return 0; + return ERROR; } annotations = compiler_visit_annotations(c, loc, args, returns); if (annotations == 0) { - return 0; + return ERROR; } else if (annotations > 0) { funcflags |= 0x04; } - if (compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno)); /* if not -OO mode, add docstring */ if (c->c_optimize < 2) { @@ -2818,19 +2817,19 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) } if (compiler_add_const(c, docstring ? docstring : Py_None) < 0) { compiler_exit_scope(c); - return 0; + return ERROR; } c->u->u_argcount = asdl_seq_LEN(args->args); c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs); c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); for (i = docstring ? 1 : 0; i < asdl_seq_LEN(body); i++) { - _VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i)); + VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i)); } if (c->u->u_ste->ste_coroutine || c->u->u_ste->ste_generator) { if (wrap_in_stopiteration_handler(c) < 0) { compiler_exit_scope(c); - return 0; + return ERROR; } } co = assemble(c, 1); @@ -2839,20 +2838,20 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) if (co == NULL) { Py_XDECREF(qualname); Py_XDECREF(co); - return 0; + return ERROR; } if (compiler_make_closure(c, loc, co, funcflags, qualname) < 0) { Py_DECREF(qualname); Py_DECREF(co); - return 0; + return ERROR; } Py_DECREF(qualname); Py_DECREF(co); if (compiler_apply_decorators(c, decos) < 0) { - return 0; + return ERROR; } - return compiler_nameop(c, loc, name, Store); + return compiler_nameop(c, loc, name, Store) ? SUCCESS : ERROR; } static int @@ -4199,7 +4198,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) switch (s->kind) { case FunctionDef_kind: - return compiler_function(c, s, 0); + return compiler_function(c, s, 0) == SUCCESS ? 1 : 0; case ClassDef_kind: return compiler_class(c, s) == SUCCESS ? 1 : 0; case Return_kind: @@ -4279,7 +4278,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case With_kind: return compiler_with(c, s, 0) == SUCCESS ? 1 : 0; case AsyncFunctionDef_kind: - return compiler_function(c, s, 1); + return compiler_function(c, s, 1) == SUCCESS ? 1 : 0; case AsyncWith_kind: return compiler_async_with(c, s, 0) == SUCCESS ? 1 : 0; case AsyncFor_kind: From 45028d58e53b9626496fd016dcf78564aecd7bb2 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:37:43 +0000 Subject: [PATCH 62/93] compiler_call_helper returns SUCCESS/ERROR --- Python/compile.c | 68 +++++++++++++++++++++--------------------------- 1 file changed, 29 insertions(+), 39 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e7fd4dd78ab442..7b936e0f2507a7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2782,13 +2782,8 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) scope_type = COMPILER_SCOPE_FUNCTION; } - if (compiler_check_debug_args(c, args) < 0) { - return ERROR; - } - - if (compiler_decorators(c, decos) < 0) { - return ERROR; - } + RETURN_IF_ERROR(compiler_check_debug_args(c, args)); + RETURN_IF_ERROR(compiler_decorators(c, decos)); firstlineno = s->lineno; if (asdl_seq_LEN(decos)) { @@ -2848,9 +2843,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) Py_DECREF(qualname); Py_DECREF(co); - if (compiler_apply_decorators(c, decos) < 0) { - return ERROR; - } + RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); return compiler_nameop(c, loc, name, Store) ? SUCCESS : ERROR; } @@ -2957,11 +2950,10 @@ compiler_class(struct compiler *c, stmt_ty s) ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name); /* 5. generate the rest of the code for the call */ - if (!compiler_call_helper(c, loc, 2, - s->v.ClassDef.bases, - s->v.ClassDef.keywords)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_call_helper(c, loc, 2, + s->v.ClassDef.bases, + s->v.ClassDef.keywords)); + /* 6. apply decorators */ RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); @@ -5052,23 +5044,23 @@ validate_keywords(struct compiler *c, asdl_keyword_seq *keywords) } location loc = LOC(key); if (forbidden_name(c, loc, key->arg, Store)) { - return -1; + return ERROR; } for (Py_ssize_t j = i + 1; j < nkeywords; j++) { keyword_ty other = ((keyword_ty)asdl_seq_GET(keywords, j)); if (other->arg && !PyUnicode_Compare(key->arg, other->arg)) { compiler_error(c, LOC(other), "keyword argument repeated: %U", key->arg); - return -1; + return ERROR; } } } - return 0; + return SUCCESS; } static int compiler_call(struct compiler *c, expr_ty e) { - if (validate_keywords(c, e->v.Call.keywords) == -1) { + if (validate_keywords(c, e->v.Call.keywords) < 0) { return 0; } int ret = maybe_optimize_method_call(c, e); @@ -5084,7 +5076,7 @@ compiler_call(struct compiler *c, expr_ty e) loc = LOC(e); return compiler_call_helper(c, loc, 0, e->v.Call.args, - e->v.Call.keywords); + e->v.Call.keywords) == SUCCESS ? 1 : 0; } static int @@ -5239,9 +5231,7 @@ compiler_call_helper(struct compiler *c, location loc, { Py_ssize_t i, nseen, nelts, nkwelts; - if (validate_keywords(c, keywords) == -1) { - return 0; - } + RETURN_IF_ERROR(validate_keywords(c, keywords)); nelts = asdl_seq_LEN(args); nkwelts = asdl_seq_LEN(keywords); @@ -5266,26 +5256,26 @@ compiler_call_helper(struct compiler *c, location loc, for (i = 0; i < nelts; i++) { expr_ty elt = asdl_seq_GET(args, i); assert(elt->kind != Starred_kind); - _VISIT(c, expr, elt); + VISIT(c, expr, elt); } if (nkwelts) { - _VISIT_SEQ(c, keyword, keywords); + VISIT_SEQ(c, keyword, keywords); if (!compiler_call_simple_kw_helper(c, loc, keywords, nkwelts)) { - return 0; + return ERROR; }; } - _ADDOP_I(c, loc, CALL, n + nelts + nkwelts); - return 1; + ADDOP_I(c, loc, CALL, n + nelts + nkwelts); + return SUCCESS; ex_call: /* Do positional arguments. */ if (n ==0 && nelts == 1 && ((expr_ty)asdl_seq_GET(args, 0))->kind == Starred_kind) { - _VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value); + VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value); } else if (starunpack_helper(c, loc, args, n, BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1) == 0) { - return 0; + return ERROR; } /* Then keyword arguments */ if (nkwelts) { @@ -5299,20 +5289,20 @@ compiler_call_helper(struct compiler *c, location loc, /* A keyword argument unpacking. */ if (nseen) { if (!compiler_subkwargs(c, loc, keywords, i - nseen, i)) { - return 0; + return ERROR; } if (have_dict) { - _ADDOP_I(c, loc, DICT_MERGE, 1); + ADDOP_I(c, loc, DICT_MERGE, 1); } have_dict = 1; nseen = 0; } if (!have_dict) { - _ADDOP_I(c, loc, BUILD_MAP, 0); + ADDOP_I(c, loc, BUILD_MAP, 0); have_dict = 1; } - _VISIT(c, expr, kw->value); - _ADDOP_I(c, loc, DICT_MERGE, 1); + VISIT(c, expr, kw->value); + ADDOP_I(c, loc, DICT_MERGE, 1); } else { nseen++; @@ -5321,17 +5311,17 @@ compiler_call_helper(struct compiler *c, location loc, if (nseen) { /* Pack up any trailing keyword arguments. */ if (!compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts)) { - return 0; + return ERROR; } if (have_dict) { - _ADDOP_I(c, loc, DICT_MERGE, 1); + ADDOP_I(c, loc, DICT_MERGE, 1); } have_dict = 1; } assert(have_dict); } - _ADDOP_I(c, loc, CALL_FUNCTION_EX, nkwelts > 0); - return 1; + ADDOP_I(c, loc, CALL_FUNCTION_EX, nkwelts > 0); + return SUCCESS; } From 5843200836ba1fa507224c3c086ad1259989beac Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:49:43 +0000 Subject: [PATCH 63/93] check_caller, compiler_call RETURN SUCCESS/ERROR --- Python/compile.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7b936e0f2507a7..aaaac8d6c27468 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4857,12 +4857,13 @@ check_caller(struct compiler *c, expr_ty e) case JoinedStr_kind: case FormattedValue_kind: { location loc = LOC(e); - return compiler_warn(c, loc, "'%.200s' object is not callable; " - "perhaps you missed a comma?", - infer_type(e)->tp_name); + int ret = compiler_warn(c, loc, "'%.200s' object is not callable; " + "perhaps you missed a comma?", + infer_type(e)->tp_name); + return ret == 0 ? ERROR : SUCCESS; } default: - return 1; + return SUCCESS; } } @@ -5060,23 +5061,22 @@ validate_keywords(struct compiler *c, asdl_keyword_seq *keywords) static int compiler_call(struct compiler *c, expr_ty e) { - if (validate_keywords(c, e->v.Call.keywords) < 0) { - return 0; - } + RETURN_IF_ERROR(validate_keywords(c, e->v.Call.keywords)); int ret = maybe_optimize_method_call(c, e); - if (ret >= 0) { - return ret; + if (ret == 1) { + return SUCCESS; } - if (!check_caller(c, e->v.Call.func)) { - return 0; + if (ret == 0) { + return ERROR; } + RETURN_IF_ERROR(check_caller(c, e->v.Call.func)); location loc = LOC(e->v.Call.func); - _ADDOP(c, loc, PUSH_NULL); - _VISIT(c, expr, e->v.Call.func); + ADDOP(c, loc, PUSH_NULL); + VISIT(c, expr, e->v.Call.func); loc = LOC(e); return compiler_call_helper(c, loc, 0, e->v.Call.args, - e->v.Call.keywords) == SUCCESS ? 1 : 0; + e->v.Call.keywords); } static int @@ -6030,7 +6030,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Compare_kind: return compiler_compare(c, e); case Call_kind: - return compiler_call(c, e); + return compiler_call(c, e) == SUCCESS ? 1 : 0; case Constant_kind: _ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); break; From 7611a97b6e3d072ecb1e4036d78c4a1777841b34 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 22:55:32 +0000 Subject: [PATCH 64/93] check_compare, compiler_addcompare return SUCCESS/ERROR --- Python/compile.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index aaaac8d6c27468..28f723b07387c6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2979,9 +2979,8 @@ check_is_arg(expr_ty e) || value == Py_Ellipsis); } -/* Check operands of identity chacks ("is" and "is not"). +/* Check operands of identity checks ("is" and "is not"). Emit a warning if any operand is a constant except named singletons. - Return 0 on error. */ static int check_compare(struct compiler *c, expr_ty e) @@ -2997,12 +2996,13 @@ check_compare(struct compiler *c, expr_ty e) const char *msg = (op == Is) ? "\"is\" with a literal. Did you mean \"==\"?" : "\"is not\" with a literal. Did you mean \"!=\"?"; - return compiler_warn(c, LOC(e), msg); + int ret = compiler_warn(c, LOC(e), msg); + return ret == 0 ? ERROR : SUCCESS; } } left = right; } - return 1; + return SUCCESS; } static int compiler_addcompare(struct compiler *c, location loc, @@ -3105,7 +3105,7 @@ compiler_jump_if(struct compiler *c, location loc, case Compare_kind: { Py_ssize_t n = asdl_seq_LEN(e->v.Compare.ops) - 1; if (n > 0) { - if (!check_compare(c, e)) { + if (check_compare(c, e) < 0) { return 0; } NEW_JUMP_TARGET_LABEL(c, cleanup); @@ -4778,38 +4778,38 @@ compiler_compare(struct compiler *c, expr_ty e) location loc = LOC(e); Py_ssize_t i, n; - if (!check_compare(c, e)) { + if (check_compare(c, e) < 0) { return 0; } - _VISIT(c, expr, e->v.Compare.left); + VISIT(c, expr, e->v.Compare.left); assert(asdl_seq_LEN(e->v.Compare.ops) > 0); n = asdl_seq_LEN(e->v.Compare.ops) - 1; if (n == 0) { - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); - _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, 0)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); + ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, 0)); } else { NEW_JUMP_TARGET_LABEL(c, cleanup); for (i = 0; i < n; i++) { - _VISIT(c, expr, + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP_I(c, loc, COPY, 2); - _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, i)); - _ADDOP_JUMP(c, loc, JUMP_IF_FALSE_OR_POP, cleanup); + ADDOP_I(c, loc, SWAP, 2); + ADDOP_I(c, loc, COPY, 2); + ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, i)); + ADDOP_JUMP(c, loc, JUMP_IF_FALSE_OR_POP, cleanup); } - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); - _ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, n)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); + ADDOP_COMPARE(c, loc, asdl_seq_GET(e->v.Compare.ops, n)); NEW_JUMP_TARGET_LABEL(c, end); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, cleanup); - _ADDOP_I(c, loc, SWAP, 2); - _ADDOP(c, loc, POP_TOP); + ADDOP_I(c, loc, SWAP, 2); + ADDOP(c, loc, POP_TOP); USE_LABEL(c, end); } - return 1; + return SUCCESS; } static PyTypeObject * @@ -6028,7 +6028,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) _ADD_YIELD_FROM(c, loc, 1); break; case Compare_kind: - return compiler_compare(c, e); + return compiler_compare(c, e) == SUCCESS ? 1 : 0; case Call_kind: return compiler_call(c, e) == SUCCESS ? 1 : 0; case Constant_kind: From 31228260d2138c8181a349477badea10a257cec7 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:02:26 +0000 Subject: [PATCH 65/93] compiler_ifexp, compiler_boolop, unpack_helper, assignment_helper return SUCCESS/ERROR --- Python/compile.c | 47 +++++++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 28f723b07387c6..333117165e94f1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3155,16 +3155,16 @@ compiler_ifexp(struct compiler *c, expr_ty e) NEW_JUMP_TARGET_LABEL(c, next); if (!compiler_jump_if(c, LOC(e), e->v.IfExp.test, next, 0)) { - return 0; + return ERROR; } - _VISIT(c, expr, e->v.IfExp.body); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + VISIT(c, expr, e->v.IfExp.body); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next); - _VISIT(c, expr, e->v.IfExp.orelse); + VISIT(c, expr, e->v.IfExp.orelse); USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4482,16 +4482,16 @@ compiler_boolop(struct compiler *c, expr_ty e) n = asdl_seq_LEN(s) - 1; assert(n >= 0); for (i = 0; i < n; ++i) { - _VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); - _ADDOP_JUMP(c, loc, jumpi, end); + VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); + ADDOP_JUMP(c, loc, jumpi, end); NEW_JUMP_TARGET_LABEL(c, next); USE_LABEL(c, next); } - _VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); USE_LABEL(c, end); - return 1; + return SUCCESS; } static int @@ -4588,34 +4588,37 @@ unpack_helper(struct compiler *c, location loc, asdl_expr_seq *elts) expr_ty elt = asdl_seq_GET(elts, i); if (elt->kind == Starred_kind && !seen_star) { if ((i >= (1 << 8)) || - (n-i-1 >= (INT_MAX >> 8))) - return compiler_error(c, loc, + (n-i-1 >= (INT_MAX >> 8))) { + compiler_error(c, loc, "too many expressions in " "star-unpacking assignment"); - _ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); + return ERROR; + } + ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == Starred_kind) { - return compiler_error(c, loc, + compiler_error(c, loc, "multiple starred expressions in assignment"); + return ERROR; } } if (!seen_star) { - _ADDOP_I(c, loc, UNPACK_SEQUENCE, n); + ADDOP_I(c, loc, UNPACK_SEQUENCE, n); } - return 1; + return SUCCESS; } static int assignment_helper(struct compiler *c, location loc, asdl_expr_seq *elts) { Py_ssize_t n = asdl_seq_LEN(elts); - RETURN_IF_FALSE(unpack_helper(c, loc, elts)); + RETURN_IF_ERROR(unpack_helper(c, loc, elts)); for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); - _VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value); + VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value); } - return 1; + return SUCCESS; } static int @@ -4624,7 +4627,7 @@ compiler_list(struct compiler *c, expr_ty e) location loc = LOC(e); asdl_expr_seq *elts = e->v.List.elts; if (e->v.List.ctx == Store) { - return assignment_helper(c, loc, elts); + return assignment_helper(c, loc, elts) == SUCCESS ? 1 : 0; } else if (e->v.List.ctx == Load) { return starunpack_helper(c, loc, elts, 0, @@ -4641,7 +4644,7 @@ compiler_tuple(struct compiler *c, expr_ty e) location loc = LOC(e); asdl_expr_seq *elts = e->v.Tuple.elts; if (e->v.Tuple.ctx == Store) { - return assignment_helper(c, loc, elts); + return assignment_helper(c, loc, elts) == SUCCESS ? 1 : 0; } else if (e->v.Tuple.ctx == Load) { return starunpack_helper(c, loc, elts, 0, @@ -5961,7 +5964,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) _VISIT(c, expr, e->v.NamedExpr.target); break; case BoolOp_kind: - return compiler_boolop(c, e); + return compiler_boolop(c, e) == SUCCESS ? 1 : 0; case BinOp_kind: _VISIT(c, expr, e->v.BinOp.left); _VISIT(c, expr, e->v.BinOp.right); @@ -5974,7 +5977,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Lambda_kind: return compiler_lambda(c, e); case IfExp_kind: - return compiler_ifexp(c, e); + return compiler_ifexp(c, e) == SUCCESS ? 1 : 0; case Dict_kind: return compiler_dict(c, e); case Set_kind: From 46e7471445fb2948c16e9d2dac88eb6510556e93 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:09:59 +0000 Subject: [PATCH 66/93] addop_yield, addop_binary compiler_addcompare return SUCCESS/ERROR --- Python/compile.c | 77 ++++++++++++++++++++++++------------------------ 1 file changed, 38 insertions(+), 39 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 333117165e94f1..7cef21798cfb8c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1653,20 +1653,14 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define ADDOP_JUMP(C, LOC, OP, O) \ RETURN_IF_ERROR(cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))); -#define ADDOP_COMPARE(C, LOC, CMP) { \ - if (!compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))) \ - return ERROR; \ -} +#define ADDOP_COMPARE(C, LOC, CMP) \ + RETURN_IF_ERROR(compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))); -#define ADDOP_BINARY(C, LOC, BINOP) { \ - if (!addop_binary((C), (LOC), (BINOP), false)) \ - return ERROR; \ -} +#define ADDOP_BINARY(C, LOC, BINOP) \ + RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false)); -#define ADDOP_INPLACE(C, LOC, BINOP) { \ - if (!addop_binary((C), (LOC), (BINOP), true)) \ - return ERROR; \ -} +#define ADDOP_INPLACE(C, LOC, BINOP) \ + RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true)); #define ADD_YIELD_FROM(C, LOC, await) \ RETURN_IF_ERROR(compiler_add_yield_from((C), (LOC), (await))); @@ -1675,9 +1669,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))); #define ADDOP_YIELD(C, LOC) { \ - if (!addop_yield((C), (LOC))) \ - return ERROR; \ -} + RETURN_IF_ERROR(addop_yield((C), (LOC))); /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use the ASDL name to synthesize the name of the C type and the visit function. @@ -1778,15 +1770,20 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define _ADDOP_COMPARE(C, LOC, CMP) { \ - if (!compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))) \ + if (compiler_addcompare((C), (LOC), (cmpop_ty)(CMP)) < 0) \ return 0; \ } -#define _ADDOP_BINARY(C, LOC, BINOP) \ - RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), false)) +#define _ADDOP_BINARY(C, LOC, BINOP) { \ + if (addop_binary((C), (LOC), (BINOP), false) < 0) \ + return 0; \ + } + +#define _ADDOP_INPLACE(C, LOC, BINOP) { \ + if (addop_binary((C), (LOC), (BINOP), true) < 0) \ + return 0; \ + } -#define _ADDOP_INPLACE(C, LOC, BINOP) \ - RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), true)) #define _ADD_YIELD_FROM(C, LOC, await) { \ if (compiler_add_yield_from((C), (LOC), (await)) < 0) \ @@ -1798,8 +1795,10 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return 0; \ } -#define _ADDOP_YIELD(C, LOC) \ - RETURN_IF_FALSE(addop_yield((C), (LOC))) +#define _ADDOP_YIELD(C, LOC) { \ + if (addop_yield((C), (LOC)) < 0) \ + return 0; \ + } /* _VISIT and _VISIT_SEQ takes an ASDL type as their second argument. They use the ASDL name to synthesize the name of the C type and the visit function. @@ -3029,22 +3028,22 @@ static int compiler_addcompare(struct compiler *c, location loc, cmp = Py_GE; break; case Is: - _ADDOP_I(c, loc, IS_OP, 0); - return 1; + ADDOP_I(c, loc, IS_OP, 0); + return SUCCESS; case IsNot: - _ADDOP_I(c, loc, IS_OP, 1); - return 1; + ADDOP_I(c, loc, IS_OP, 1); + return SUCCESS; case In: - _ADDOP_I(c, loc, CONTAINS_OP, 0); - return 1; + ADDOP_I(c, loc, CONTAINS_OP, 0); + return SUCCESS; case NotIn: - _ADDOP_I(c, loc, CONTAINS_OP, 1); - return 1; + ADDOP_I(c, loc, CONTAINS_OP, 1); + return SUCCESS; default: Py_UNREACHABLE(); } - _ADDOP_I(c, loc, COMPARE_OP, cmp); - return 1; + ADDOP_I(c, loc, COMPARE_OP, cmp); + return SUCCESS; } @@ -4347,21 +4346,21 @@ addop_binary(struct compiler *c, location loc, operator_ty binop, default: PyErr_Format(PyExc_SystemError, "%s op %d should not be possible", inplace ? "inplace" : "binary", binop); - return 0; + return ERROR; } - _ADDOP_I(c, loc, BINARY_OP, oparg); - return 1; + ADDOP_I(c, loc, BINARY_OP, oparg); + return SUCCESS; } static int addop_yield(struct compiler *c, location loc) { if (c->u->u_ste->ste_generator && c->u->u_ste->ste_coroutine) { - _ADDOP(c, loc, ASYNC_GEN_WRAP); + ADDOP(c, loc, ASYNC_GEN_WRAP); } - _ADDOP_I(c, loc, YIELD_VALUE, 0); - _ADDOP_I(c, loc, RESUME, 1); - return 1; + ADDOP_I(c, loc, YIELD_VALUE, 0); + ADDOP_I(c, loc, RESUME, 1); + return SUCCESS; } static int From a31d07871bc4c0f61b9251d8cd481d1f96cc1829 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:12:49 +0000 Subject: [PATCH 67/93] compiler_with_except_finish return SUCCESS/ERROR --- Python/compile.c | 33 ++++++++++++--------------------- 1 file changed, 12 insertions(+), 21 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7cef21798cfb8c..2488c3e16a0759 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1779,21 +1779,12 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return 0; \ } -#define _ADDOP_INPLACE(C, LOC, BINOP) { \ - if (addop_binary((C), (LOC), (BINOP), true) < 0) \ - return 0; \ - } - #define _ADD_YIELD_FROM(C, LOC, await) { \ if (compiler_add_yield_from((C), (LOC), (await)) < 0) \ return 0; \ } -#define _POP_EXCEPT_AND_RERAISE(C, LOC) { \ - if (compiler_pop_except_and_reraise((C), (LOC)) < 0) \ - return 0; \ -} #define _ADDOP_YIELD(C, LOC) { \ if (addop_yield((C), (LOC)) < 0) \ @@ -5740,23 +5731,23 @@ compiler_visit_keyword(struct compiler *c, keyword_ty k) static int compiler_with_except_finish(struct compiler *c, jump_target_label cleanup) { NEW_JUMP_TARGET_LABEL(c, suppress); - _ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_TRUE, suppress); - _ADDOP_I(c, NO_LOCATION, RERAISE, 2); + ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_TRUE, suppress); + ADDOP_I(c, NO_LOCATION, RERAISE, 2); USE_LABEL(c, suppress); - _ADDOP(c, NO_LOCATION, POP_TOP); /* exc_value */ - _ADDOP(c, NO_LOCATION, POP_BLOCK); - _ADDOP(c, NO_LOCATION, POP_EXCEPT); - _ADDOP(c, NO_LOCATION, POP_TOP); - _ADDOP(c, NO_LOCATION, POP_TOP); + ADDOP(c, NO_LOCATION, POP_TOP); /* exc_value */ + ADDOP(c, NO_LOCATION, POP_BLOCK); + ADDOP(c, NO_LOCATION, POP_EXCEPT); + ADDOP(c, NO_LOCATION, POP_TOP); + ADDOP(c, NO_LOCATION, POP_TOP); NEW_JUMP_TARGET_LABEL(c, exit); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); + ADDOP_JUMP(c, NO_LOCATION, JUMP, exit); USE_LABEL(c, cleanup); - _POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); + POP_EXCEPT_AND_RERAISE(c, NO_LOCATION); USE_LABEL(c, exit); - return 1; + return SUCCESS; } /* @@ -5859,7 +5850,7 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) ADDOP_I(c, loc, GET_AWAITABLE, 2); ADDOP_LOAD_CONST(c, loc, Py_None); ADD_YIELD_FROM(c, loc, 1); - compiler_with_except_finish(c, cleanup); + RETURN_IF_ERROR(compiler_with_except_finish(c, cleanup)); USE_LABEL(c, exit); return SUCCESS; @@ -5946,7 +5937,7 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) ADDOP_JUMP(c, loc, SETUP_CLEANUP, cleanup); ADDOP(c, loc, PUSH_EXC_INFO); ADDOP(c, loc, WITH_EXCEPT_START); - compiler_with_except_finish(c, cleanup); + RETURN_IF_ERROR(compiler_with_except_finish(c, cleanup)); USE_LABEL(c, exit); return SUCCESS; From 95a47a6a27a1097ad0cd9711858139905698475e Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:17:51 +0000 Subject: [PATCH 68/93] compiler_lambda return SUCCESS/ERROR --- Python/compile.c | 50 ++++++++++++------------------------------------ 1 file changed, 12 insertions(+), 38 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 2488c3e16a0759..e4ca9308d27871 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1800,13 +1800,6 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return 0; \ } -#define _VISIT_IN_SCOPE(C, TYPE, V) {\ - if (!compiler_visit_ ## TYPE((C), (V))) { \ - compiler_exit_scope(c); \ - return 0; \ - } \ -} - #define _VISIT_SEQ(C, TYPE, SEQ) { \ int _i; \ asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ @@ -1817,22 +1810,6 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } \ } -#define _VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ - int _i; \ - asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ - for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ - TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ - if (!compiler_visit_ ## TYPE((C), elt)) { \ - compiler_exit_scope(c); \ - return 0; \ - } \ - } \ -} - -#define RETURN_IF_FALSE(X) \ - if (!(X)) { \ - return 0; \ - } static int compiler_enter_scope(struct compiler *c, identifier name, @@ -3166,9 +3143,7 @@ compiler_lambda(struct compiler *c, expr_ty e) arguments_ty args = e->v.Lambda.args; assert(e->kind == Lambda_kind); - if (compiler_check_debug_args(c, args) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_check_debug_args(c, args)); location loc = LOC(e); funcflags = compiler_default_arguments(c, loc, args); @@ -3177,43 +3152,42 @@ compiler_lambda(struct compiler *c, expr_ty e) } _Py_DECLARE_STR(anon_lambda, ""); - if (compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA, - (void *)e, e->lineno) < 0) { - return 0; - } + RETURN_IF_ERROR( + compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA, + (void *)e, e->lineno)); + /* Make None the first constant, so the lambda can't have a docstring. */ - if (compiler_add_const(c, Py_None) < 0) - return 0; + RETURN_IF_ERROR(compiler_add_const(c, Py_None)); c->u->u_argcount = asdl_seq_LEN(args->args); c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs); c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); - _VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); + VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); if (c->u->u_ste->ste_generator) { co = assemble(c, 0); } else { location loc = LOCATION(e->lineno, e->lineno, 0, 0); - _ADDOP_IN_SCOPE(c, loc, RETURN_VALUE); + ADDOP_IN_SCOPE(c, loc, RETURN_VALUE); co = assemble(c, 1); } qualname = Py_NewRef(c->u->u_qualname); compiler_exit_scope(c); if (co == NULL) { Py_DECREF(qualname); - return 0; + return ERROR; } if (compiler_make_closure(c, loc, co, funcflags, qualname) < 0) { Py_DECREF(qualname); Py_DECREF(co); - return 0; + return ERROR; } Py_DECREF(qualname); Py_DECREF(co); - return 1; + return SUCCESS; } static int @@ -5965,7 +5939,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) _ADDOP(c, loc, unaryop(e->v.UnaryOp.op)); break; case Lambda_kind: - return compiler_lambda(c, e); + return compiler_lambda(c, e) == SUCCESS ? 1 : 0; case IfExp_kind: return compiler_ifexp(c, e) == SUCCESS ? 1 : 0; case Dict_kind: From 56178d36f89c4b5e49c416c59d3d717cb4a59723 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:27:44 +0000 Subject: [PATCH 69/93] compiler_visit_defaults return SUCCESS/ERROR --- Python/compile.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e4ca9308d27871..6162fa3480c91a 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2601,9 +2601,9 @@ static int compiler_visit_defaults(struct compiler *c, arguments_ty args, location loc) { - _VISIT_SEQ(c, expr, args->defaults); - _ADDOP_I(c, loc, BUILD_TUPLE, asdl_seq_LEN(args->defaults)); - return 1; + VISIT_SEQ(c, expr, args->defaults); + ADDOP_I(c, loc, BUILD_TUPLE, asdl_seq_LEN(args->defaults)); + return SUCCESS; } static Py_ssize_t @@ -2612,8 +2612,7 @@ compiler_default_arguments(struct compiler *c, location loc, { Py_ssize_t funcflags = 0; if (args->defaults && asdl_seq_LEN(args->defaults) > 0) { - if (!compiler_visit_defaults(c, args, loc)) - return -1; + RETURN_IF_ERROR(compiler_visit_defaults(c, args, loc)); funcflags |= 0x01; } if (args->kwonlyargs) { From 0c6687d3afabeac4aabe357319109d361b998c94 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Sun, 4 Dec 2022 23:43:24 +0000 Subject: [PATCH 70/93] compiler_visit_*annotation(s) return SUCCESS/ERROR --- Python/compile.c | 62 ++++++++++++++++++++++++------------------------ 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 6162fa3480c91a..6c411651baddb1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2511,17 +2511,17 @@ compiler_visit_argannotation(struct compiler *c, identifier id, expr_ty annotation, Py_ssize_t *annotations_len, location loc) { if (!annotation) { - return 1; + return SUCCESS; } PyObject *mangled = _Py_Mangle(c->u->u_private, id); if (!mangled) { - return 0; + return ERROR; } - _ADDOP_LOAD_CONST(c, loc, mangled); + ADDOP_LOAD_CONST(c, loc, mangled); Py_DECREF(mangled); if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) { - _VISIT(c, annexpr, annotation); + VISIT(c, annexpr, annotation); } else { if (annotation->kind == Starred_kind) { @@ -2529,15 +2529,15 @@ compiler_visit_argannotation(struct compiler *c, identifier id, // Do [annotation_value] = [*Ts]. // (Note that in theory we could end up here even for an argument // other than *args, but in practice the grammar doesn't allow it.) - _VISIT(c, expr, annotation->v.Starred.value); - _ADDOP_I(c, loc, UNPACK_SEQUENCE, (Py_ssize_t) 1); + VISIT(c, expr, annotation->v.Starred.value); + ADDOP_I(c, loc, UNPACK_SEQUENCE, (Py_ssize_t) 1); } else { - _VISIT(c, expr, annotation); + VISIT(c, expr, annotation); } } *annotations_len += 2; - return 1; + return SUCCESS; } static int @@ -2547,15 +2547,15 @@ compiler_visit_argannotations(struct compiler *c, asdl_arg_seq* args, int i; for (i = 0; i < asdl_seq_LEN(args); i++) { arg_ty arg = (arg_ty)asdl_seq_GET(args, i); - if (!compiler_visit_argannotation( + RETURN_IF_ERROR( + compiler_visit_argannotation( c, arg->arg, arg->annotation, annotations_len, - loc)) - return 0; + loc)); } - return 1; + return SUCCESS; } static int @@ -2565,36 +2565,36 @@ compiler_visit_annotations(struct compiler *c, location loc, /* Push arg annotation names and values. The expressions are evaluated out-of-order wrt the source code. - Return 0 on error, -1 if no annotations pushed, 1 if a annotations is pushed. + Return -1 on error, 0 if no annotations pushed, 1 if a annotations is pushed. */ Py_ssize_t annotations_len = 0; - if (!compiler_visit_argannotations(c, args->args, &annotations_len, loc)) - return 0; - if (!compiler_visit_argannotations(c, args->posonlyargs, &annotations_len, loc)) - return 0; + if (compiler_visit_argannotations(c, args->args, &annotations_len, loc) < 0) + return ERROR; + if (compiler_visit_argannotations(c, args->posonlyargs, &annotations_len, loc) < 0) + return ERROR; if (args->vararg && args->vararg->annotation && - !compiler_visit_argannotation(c, args->vararg->arg, - args->vararg->annotation, &annotations_len, loc)) - return 0; - if (!compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len, loc)) - return 0; + compiler_visit_argannotation(c, args->vararg->arg, + args->vararg->annotation, &annotations_len, loc) < 0) + return ERROR; + if (compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len, loc) < 0) + return ERROR; if (args->kwarg && args->kwarg->annotation && - !compiler_visit_argannotation(c, args->kwarg->arg, - args->kwarg->annotation, &annotations_len, loc)) - return 0; + compiler_visit_argannotation(c, args->kwarg->arg, + args->kwarg->annotation, &annotations_len, loc) < 0) + return ERROR; - if (!compiler_visit_argannotation(c, &_Py_ID(return), returns, - &annotations_len, loc)) { - return 0; + if (compiler_visit_argannotation(c, &_Py_ID(return), returns, + &annotations_len, loc) < 0) { + return ERROR; } if (annotations_len) { - _ADDOP_I(c, loc, BUILD_TUPLE, annotations_len); + ADDOP_I(c, loc, BUILD_TUPLE, annotations_len); return 1; } - return -1; + return 0; } static int @@ -2762,7 +2762,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) return ERROR; } annotations = compiler_visit_annotations(c, loc, args, returns); - if (annotations == 0) { + if (annotations == ERROR) { return ERROR; } else if (annotations > 0) { From 0ee940f7d16d4bb4230a2ff7824c657e6ed17ff8 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 00:03:37 +0000 Subject: [PATCH 71/93] compiler_comprehension_* return SUCCESS/ERROR --- Python/compile.c | 116 +++++++++++++++++++++++------------------------ 1 file changed, 57 insertions(+), 59 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 6c411651baddb1..a03333869ae40c 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1668,7 +1668,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, #define POP_EXCEPT_AND_RERAISE(C, LOC) \ RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))); -#define ADDOP_YIELD(C, LOC) { \ +#define ADDOP_YIELD(C, LOC) \ RETURN_IF_ERROR(addop_yield((C), (LOC))); /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use @@ -5341,7 +5341,7 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, if (gen_index == 0) { /* Receive outermost iter as an implicit argument */ c->u->u_argcount = 1; - _ADDOP_I(c, loc, LOAD_FAST, 0); + ADDOP_I(c, loc, LOAD_FAST, 0); } else { /* Sub-iter - calculate on the fly */ @@ -5362,37 +5362,36 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, if (asdl_seq_LEN(elts) == 1) { expr_ty elt = asdl_seq_GET(elts, 0); if (elt->kind != Starred_kind) { - _VISIT(c, expr, elt); + VISIT(c, expr, elt); start = NO_LABEL; } } if (IS_LABEL(start)) { - _VISIT(c, expr, gen->iter); - _ADDOP(c, loc, GET_ITER); + VISIT(c, expr, gen->iter); + ADDOP(c, loc, GET_ITER); } } if (IS_LABEL(start)) { depth++; USE_LABEL(c, start); - _ADDOP_JUMP(c, loc, FOR_ITER, anchor); + ADDOP_JUMP(c, loc, FOR_ITER, anchor); } - _VISIT(c, expr, gen->target); + VISIT(c, expr, gen->target); /* XXX this needs to be cleaned up...a lot! */ Py_ssize_t n = asdl_seq_LEN(gen->ifs); for (Py_ssize_t i = 0; i < n; i++) { expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i); if (!compiler_jump_if(c, loc, e, if_cleanup, 0)) { - return 0; + return ERROR; } } if (++gen_index < asdl_seq_LEN(generators)) { - if (!compiler_comprehension_generator(c, loc, - generators, gen_index, depth, - elt, val, type)) { - return 0; - } + RETURN_IF_ERROR( + compiler_comprehension_generator(c, loc, + generators, gen_index, depth, + elt, val, type)); } location elt_loc = LOC(elt); @@ -5402,43 +5401,43 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - _VISIT(c, expr, elt); - _ADDOP_YIELD(c, elt_loc); - _ADDOP(c, elt_loc, POP_TOP); + VISIT(c, expr, elt); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); break; case COMP_LISTCOMP: - _VISIT(c, expr, elt); - _ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); break; case COMP_SETCOMP: - _VISIT(c, expr, elt); - _ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, SET_ADD, depth + 1); break; case COMP_DICTCOMP: /* With '{k: v}', k is evaluated before v, so we do the same. */ - _VISIT(c, expr, elt); - _VISIT(c, expr, val); + VISIT(c, expr, elt); + VISIT(c, expr, val); elt_loc = LOCATION(elt->lineno, val->end_lineno, elt->col_offset, val->end_col_offset); - _ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); break; default: - return 0; + return ERROR; } } USE_LABEL(c, if_cleanup); if (IS_LABEL(start)) { - _ADDOP_JUMP(c, elt_loc, JUMP, start); + ADDOP_JUMP(c, elt_loc, JUMP, start); USE_LABEL(c, anchor); - _ADDOP(c, NO_LOCATION, END_FOR); + ADDOP(c, NO_LOCATION, END_FOR); } - return 1; + return SUCCESS; } static int @@ -5457,43 +5456,42 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, if (gen_index == 0) { /* Receive outermost iter as an implicit argument */ c->u->u_argcount = 1; - _ADDOP_I(c, loc, LOAD_FAST, 0); + ADDOP_I(c, loc, LOAD_FAST, 0); } else { /* Sub-iter - calculate on the fly */ - _VISIT(c, expr, gen->iter); - _ADDOP(c, loc, GET_AITER); + VISIT(c, expr, gen->iter); + ADDOP(c, loc, GET_AITER); } USE_LABEL(c, start); /* Runtime will push a block here, so we need to account for that */ if (compiler_push_fblock(c, loc, ASYNC_COMPREHENSION_GENERATOR, start, NO_LABEL, NULL) < 0) { - return 0; + return ERROR; } - _ADDOP_JUMP(c, loc, SETUP_FINALLY, except); - _ADDOP(c, loc, GET_ANEXT); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); - _ADDOP(c, loc, POP_BLOCK); - _VISIT(c, expr, gen->target); + ADDOP_JUMP(c, loc, SETUP_FINALLY, except); + ADDOP(c, loc, GET_ANEXT); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); + ADDOP(c, loc, POP_BLOCK); + VISIT(c, expr, gen->target); Py_ssize_t n = asdl_seq_LEN(gen->ifs); for (Py_ssize_t i = 0; i < n; i++) { expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i); if (!compiler_jump_if(c, loc, e, if_cleanup, 0)) { - return 0; + return ERROR; } } depth++; if (++gen_index < asdl_seq_LEN(generators)) { - if (!compiler_comprehension_generator(c, loc, - generators, gen_index, depth, - elt, val, type)) { - return 0; - } + RETURN_IF_ERROR( + compiler_comprehension_generator(c, loc, + generators, gen_index, depth, + elt, val, type)); } location elt_loc = LOC(elt); @@ -5502,44 +5500,44 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - _VISIT(c, expr, elt); - _ADDOP_YIELD(c, elt_loc); - _ADDOP(c, elt_loc, POP_TOP); + VISIT(c, expr, elt); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); break; case COMP_LISTCOMP: - _VISIT(c, expr, elt); - _ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); break; case COMP_SETCOMP: - _VISIT(c, expr, elt); - _ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, SET_ADD, depth + 1); break; case COMP_DICTCOMP: /* With '{k: v}', k is evaluated before v, so we do the same. */ - _VISIT(c, expr, elt); - _VISIT(c, expr, val); + VISIT(c, expr, elt); + VISIT(c, expr, val); elt_loc = LOCATION(elt->lineno, val->end_lineno, elt->col_offset, val->end_col_offset); - _ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); break; default: - return 0; + return ERROR; } } USE_LABEL(c, if_cleanup); - _ADDOP_JUMP(c, elt_loc, JUMP, start); + ADDOP_JUMP(c, elt_loc, JUMP, start); compiler_pop_fblock(c, ASYNC_COMPREHENSION_GENERATOR, start); USE_LABEL(c, except); - _ADDOP(c, loc, END_ASYNC_FOR); + ADDOP(c, loc, END_ASYNC_FOR); - return 1; + return SUCCESS; } static int @@ -5595,8 +5593,8 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, _ADDOP_I(c, loc, op, 0); } - if (!compiler_comprehension_generator(c, loc, generators, 0, 0, - elt, val, type)) { + if (compiler_comprehension_generator(c, loc, generators, 0, 0, + elt, val, type) < 0) { goto error_in_scope; } From 6a37392febe927a934055b101f1f4d04556aff21 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:12:04 +0000 Subject: [PATCH 72/93] starunpack_helper return SUCCESS/ERROR --- Python/compile.c | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a03333869ae40c..a04f074d857962 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4466,7 +4466,7 @@ starunpack_helper(struct compiler *c, location loc, if (n > 2 && are_all_items_const(elts, 0, n)) { PyObject *folded = PyTuple_New(n); if (folded == NULL) { - return 0; + return ERROR; } PyObject *val; for (Py_ssize_t i = 0; i < n; i++) { @@ -4474,22 +4474,22 @@ starunpack_helper(struct compiler *c, location loc, PyTuple_SET_ITEM(folded, i, Py_NewRef(val)); } if (tuple && !pushed) { - _ADDOP_LOAD_CONST_NEW(c, loc, folded); + ADDOP_LOAD_CONST_NEW(c, loc, folded); } else { if (add == SET_ADD) { Py_SETREF(folded, PyFrozenSet_New(folded)); if (folded == NULL) { - return 0; + return ERROR; } } - _ADDOP_I(c, loc, build, pushed); - _ADDOP_LOAD_CONST_NEW(c, loc, folded); - _ADDOP_I(c, loc, extend, 1); + ADDOP_I(c, loc, build, pushed); + ADDOP_LOAD_CONST_NEW(c, loc, folded); + ADDOP_I(c, loc, extend, 1); if (tuple) { - _ADDOP(c, loc, LIST_TO_TUPLE); + ADDOP(c, loc, LIST_TO_TUPLE); } } - return 1; + return SUCCESS; } int big = n+pushed > STACK_USE_GUIDELINE; @@ -4504,42 +4504,42 @@ starunpack_helper(struct compiler *c, location loc, if (!seen_star && !big) { for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); - _VISIT(c, expr, elt); + VISIT(c, expr, elt); } if (tuple) { - _ADDOP_I(c, loc, BUILD_TUPLE, n+pushed); + ADDOP_I(c, loc, BUILD_TUPLE, n+pushed); } else { - _ADDOP_I(c, loc, build, n+pushed); + ADDOP_I(c, loc, build, n+pushed); } - return 1; + return SUCCESS; } int sequence_built = 0; if (big) { - _ADDOP_I(c, loc, build, pushed); + ADDOP_I(c, loc, build, pushed); sequence_built = 1; } for (Py_ssize_t i = 0; i < n; i++) { expr_ty elt = asdl_seq_GET(elts, i); if (elt->kind == Starred_kind) { if (sequence_built == 0) { - _ADDOP_I(c, loc, build, i+pushed); + ADDOP_I(c, loc, build, i+pushed); sequence_built = 1; } - _VISIT(c, expr, elt->v.Starred.value); - _ADDOP_I(c, loc, extend, 1); + VISIT(c, expr, elt->v.Starred.value); + ADDOP_I(c, loc, extend, 1); } else { - _VISIT(c, expr, elt); + VISIT(c, expr, elt); if (sequence_built) { - _ADDOP_I(c, loc, add, 1); + ADDOP_I(c, loc, add, 1); } } } assert(sequence_built); if (tuple) { - _ADDOP(c, loc, LIST_TO_TUPLE); + ADDOP(c, loc, LIST_TO_TUPLE); } - return 1; + return SUCCESS; } static int @@ -4594,7 +4594,7 @@ compiler_list(struct compiler *c, expr_ty e) } else if (e->v.List.ctx == Load) { return starunpack_helper(c, loc, elts, 0, - BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0); + BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0) == SUCCESS ? 1 : 0; } else _VISIT_SEQ(c, expr, elts); @@ -4611,7 +4611,7 @@ compiler_tuple(struct compiler *c, expr_ty e) } else if (e->v.Tuple.ctx == Load) { return starunpack_helper(c, loc, elts, 0, - BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1); + BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1) == SUCCESS ? 1 : 0; } else _VISIT_SEQ(c, expr, elts); @@ -4623,7 +4623,7 @@ compiler_set(struct compiler *c, expr_ty e) { location loc = LOC(e); return starunpack_helper(c, loc, e->v.Set.elts, 0, - BUILD_SET, SET_ADD, SET_UPDATE, 0); + BUILD_SET, SET_ADD, SET_UPDATE, 0) == SUCCESS ? 1 : 0; } static int @@ -5240,7 +5240,7 @@ compiler_call_helper(struct compiler *c, location loc, VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value); } else if (starunpack_helper(c, loc, args, n, BUILD_LIST, - LIST_APPEND, LIST_EXTEND, 1) == 0) { + LIST_APPEND, LIST_EXTEND, 1) < 0) { return ERROR; } /* Then keyword arguments */ From 40cb86c7c67356607f92ecfd5b2cfdd653c60018 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:20:55 +0000 Subject: [PATCH 73/93] compiler_list, compiler_tuple, compiler_subdict, compiler_dict return SUCCESS/ERROR --- Python/compile.c | 82 +++++++++++++++++++++++------------------------- 1 file changed, 39 insertions(+), 43 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a04f074d857962..f5dfd23e7912ed 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4590,15 +4590,16 @@ compiler_list(struct compiler *c, expr_ty e) location loc = LOC(e); asdl_expr_seq *elts = e->v.List.elts; if (e->v.List.ctx == Store) { - return assignment_helper(c, loc, elts) == SUCCESS ? 1 : 0; + return assignment_helper(c, loc, elts); } else if (e->v.List.ctx == Load) { return starunpack_helper(c, loc, elts, 0, - BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0) == SUCCESS ? 1 : 0; + BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0); } - else - _VISIT_SEQ(c, expr, elts); - return 1; + else { + VISIT_SEQ(c, expr, elts); + } + return SUCCESS; } static int @@ -4607,15 +4608,16 @@ compiler_tuple(struct compiler *c, expr_ty e) location loc = LOC(e); asdl_expr_seq *elts = e->v.Tuple.elts; if (e->v.Tuple.ctx == Store) { - return assignment_helper(c, loc, elts) == SUCCESS ? 1 : 0; + return assignment_helper(c, loc, elts); } else if (e->v.Tuple.ctx == Load) { return starunpack_helper(c, loc, elts, 0, - BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1) == SUCCESS ? 1 : 0; + BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1); } - else - _VISIT_SEQ(c, expr, elts); - return 1; + else { + VISIT_SEQ(c, expr, elts); + } + return SUCCESS; } static int @@ -4623,7 +4625,7 @@ compiler_set(struct compiler *c, expr_ty e) { location loc = LOC(e); return starunpack_helper(c, loc, e->v.Set.elts, 0, - BUILD_SET, SET_ADD, SET_UPDATE, 0) == SUCCESS ? 1 : 0; + BUILD_SET, SET_ADD, SET_UPDATE, 0); } static int @@ -4647,34 +4649,34 @@ compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end location loc = LOC(e); if (n > 1 && !big && are_all_items_const(e->v.Dict.keys, begin, end)) { for (i = begin; i < end; i++) { - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); } keys = PyTuple_New(n); if (keys == NULL) { - return 0; + return SUCCESS; } for (i = begin; i < end; i++) { key = ((expr_ty)asdl_seq_GET(e->v.Dict.keys, i))->v.Constant.value; PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key)); } - _ADDOP_LOAD_CONST_NEW(c, loc, keys); - _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); - return 1; + ADDOP_LOAD_CONST_NEW(c, loc, keys); + ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); + return SUCCESS; } if (big) { - _ADDOP_I(c, loc, BUILD_MAP, 0); + ADDOP_I(c, loc, BUILD_MAP, 0); } for (i = begin; i < end; i++) { - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); if (big) { - _ADDOP_I(c, loc, MAP_ADD, 1); + ADDOP_I(c, loc, MAP_ADD, 1); } } if (!big) { - _ADDOP_I(c, loc, BUILD_MAP, n); + ADDOP_I(c, loc, BUILD_MAP, n); } - return 1; + return SUCCESS; } static int @@ -4691,29 +4693,25 @@ compiler_dict(struct compiler *c, expr_ty e) is_unpacking = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i) == NULL; if (is_unpacking) { if (elements) { - if (!compiler_subdict(c, e, i - elements, i)) { - return 0; - } + RETURN_IF_ERROR(compiler_subdict(c, e, i - elements, i)); if (have_dict) { - _ADDOP_I(c, loc, DICT_UPDATE, 1); + ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; elements = 0; } if (have_dict == 0) { - _ADDOP_I(c, loc, BUILD_MAP, 0); + ADDOP_I(c, loc, BUILD_MAP, 0); have_dict = 1; } - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); - _ADDOP_I(c, loc, DICT_UPDATE, 1); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + ADDOP_I(c, loc, DICT_UPDATE, 1); } else { if (elements*2 > STACK_USE_GUIDELINE) { - if (!compiler_subdict(c, e, i - elements, i + 1)) { - return 0; - } + RETURN_IF_ERROR(compiler_subdict(c, e, i - elements, i + 1)); if (have_dict) { - _ADDOP_I(c, loc, DICT_UPDATE, 1); + ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; elements = 0; @@ -4724,18 +4722,16 @@ compiler_dict(struct compiler *c, expr_ty e) } } if (elements) { - if (!compiler_subdict(c, e, n - elements, n)) { - return 0; - } + RETURN_IF_ERROR(compiler_subdict(c, e, n - elements, n)); if (have_dict) { - _ADDOP_I(c, loc, DICT_UPDATE, 1); + ADDOP_I(c, loc, DICT_UPDATE, 1); } have_dict = 1; } if (!have_dict) { - _ADDOP_I(c, loc, BUILD_MAP, 0); + ADDOP_I(c, loc, BUILD_MAP, 0); } - return 1; + return SUCCESS; } static int @@ -5940,9 +5936,9 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case IfExp_kind: return compiler_ifexp(c, e) == SUCCESS ? 1 : 0; case Dict_kind: - return compiler_dict(c, e); + return compiler_dict(c, e) == SUCCESS ? 1 : 0; case Set_kind: - return compiler_set(c, e); + return compiler_set(c, e) == SUCCESS ? 1 : 0; case GeneratorExp_kind: return compiler_genexp(c, e); case ListComp_kind: @@ -6049,9 +6045,9 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx); /* child nodes of List and Tuple will have expr_context set */ case List_kind: - return compiler_list(c, e); + return compiler_list(c, e) == SUCCESS ? 1 : 0; case Tuple_kind: - return compiler_tuple(c, e); + return compiler_tuple(c, e) == SUCCESS ? 1 : 0; } return 1; } From b8cd5a36563a4994b0714c856099c833905f1002 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:24:14 +0000 Subject: [PATCH 74/93] are_all_items_const returns bool --- Python/compile.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index f5dfd23e7912ed..a1aeba9a3545b3 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -511,7 +511,7 @@ static int compiler_annassign(struct compiler *, stmt_ty); static int compiler_subscript(struct compiler *, expr_ty); static int compiler_slice(struct compiler *, expr_ty); -static int are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t); +static bool are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t); static int compiler_with(struct compiler *, stmt_ty, int); @@ -4628,16 +4628,16 @@ compiler_set(struct compiler *c, expr_ty e) BUILD_SET, SET_ADD, SET_UPDATE, 0); } -static int +static bool are_all_items_const(asdl_expr_seq *seq, Py_ssize_t begin, Py_ssize_t end) { - Py_ssize_t i; - for (i = begin; i < end; i++) { + for (Py_ssize_t i = begin; i < end; i++) { expr_ty key = (expr_ty)asdl_seq_GET(seq, i); - if (key == NULL || key->kind != Constant_kind) - return 0; + if (key == NULL || key->kind != Constant_kind) { + return false; + } } - return 1; + return true; } static int From 1bc7cc69adf89fd130ac0a4e422605b1517702da Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:28:56 +0000 Subject: [PATCH 75/93] compiler_comprehension/listcomp/dictcomp/setcomp/genexp return SUCCESS/ERROR --- Python/compile.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index a1aeba9a3545b3..07e65bc9a43233 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -5586,7 +5586,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, goto error_in_scope; } - _ADDOP_I(c, loc, op, 0); + ADDOP_I(c, loc, op, 0); } if (compiler_comprehension_generator(c, loc, generators, 0, 0, @@ -5595,7 +5595,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, } if (type != COMP_GENEXP) { - _ADDOP(c, LOC(e), RETURN_VALUE); + ADDOP(c, LOC(e), RETURN_VALUE); } if (type == COMP_GENEXP) { if (wrap_in_stopiteration_handler(c) < 0) { @@ -5609,8 +5609,9 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, if (is_top_level_await && is_async_generator){ c->u->u_ste->ste_coroutine = 1; } - if (co == NULL) + if (co == NULL) { goto error; + } loc = LOC(e); if (compiler_make_closure(c, loc, co, 0, qualname) < 0) { @@ -5619,30 +5620,30 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, Py_DECREF(qualname); Py_DECREF(co); - _VISIT(c, expr, outermost->iter); + VISIT(c, expr, outermost->iter); loc = LOC(e); if (outermost->is_async) { - _ADDOP(c, loc, GET_AITER); + ADDOP(c, loc, GET_AITER); } else { - _ADDOP(c, loc, GET_ITER); + ADDOP(c, loc, GET_ITER); } - _ADDOP_I(c, loc, CALL, 0); + ADDOP_I(c, loc, CALL, 0); if (is_async_generator && type != COMP_GENEXP) { - _ADDOP_I(c, loc, GET_AWAITABLE, 0); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); + ADDOP_I(c, loc, GET_AWAITABLE, 0); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); } - return 1; + return SUCCESS; error_in_scope: compiler_exit_scope(c); error: Py_XDECREF(qualname); Py_XDECREF(co); - return 0; + return ERROR; } static int @@ -5940,13 +5941,13 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Set_kind: return compiler_set(c, e) == SUCCESS ? 1 : 0; case GeneratorExp_kind: - return compiler_genexp(c, e); + return compiler_genexp(c, e) == SUCCESS ? 1 : 0; case ListComp_kind: - return compiler_listcomp(c, e); + return compiler_listcomp(c, e) == SUCCESS ? 1 : 0; case SetComp_kind: - return compiler_setcomp(c, e); + return compiler_setcomp(c, e) == SUCCESS ? 1 : 0; case DictComp_kind: - return compiler_dictcomp(c, e); + return compiler_dictcomp(c, e) == SUCCESS ? 1 : 0; case Yield_kind: if (c->u->u_ste->ste_type != FunctionBlock) return compiler_error(c, loc, "'yield' outside function"); From 93af682aa0ab57b1ef640e62b0c1a12b7d39b21b Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:40:11 +0000 Subject: [PATCH 76/93] compiler_jump_if returns SUCCESS/ERROR --- Python/compile.c | 125 +++++++++++++++++++---------------------------- 1 file changed, 49 insertions(+), 76 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 07e65bc9a43233..52c4ddbdc0bb9f 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1636,7 +1636,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_N(C, LOC, OP, O, TYPE) { \ - assert(!HAS_CONST(OP)); /* use _ADDOP_LOAD_CONST_NEW */ \ + assert(!HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \ if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \ Py_DECREF((O)); \ return ERROR; \ @@ -1720,13 +1720,6 @@ cfg_builder_addop_j(cfg_builder *g, location loc, return 0; \ } -#define _ADDOP_IN_SCOPE(C, LOC, OP) { \ - if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \ - compiler_exit_scope(c); \ - return 0; \ - } \ -} - #define _ADDOP_LOAD_CONST(C, LOC, O) { \ if (compiler_addop_load_const((C), (LOC), (O)) < 0) \ return 0; \ @@ -3037,67 +3030,60 @@ compiler_jump_if(struct compiler *c, location loc, next2 = new_next2; } for (i = 0; i < n; ++i) { - if (!compiler_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, i), next2, cond2)) { - return 0; - } - } - if (!compiler_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, n), next, cond)) { - return 0; + RETURN_IF_ERROR( + compiler_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, i), next2, cond2)); } + RETURN_IF_ERROR( + compiler_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, n), next, cond)); if (!SAME_LABEL(next2, next)) { USE_LABEL(c, next2); } - return 1; + return SUCCESS; } case IfExp_kind: { NEW_JUMP_TARGET_LABEL(c, end); NEW_JUMP_TARGET_LABEL(c, next2); - if (!compiler_jump_if(c, loc, e->v.IfExp.test, next2, 0)) { - return 0; - } - if (!compiler_jump_if(c, loc, e->v.IfExp.body, next, cond)) { - return 0; - } - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + RETURN_IF_ERROR( + compiler_jump_if(c, loc, e->v.IfExp.test, next2, 0)); + RETURN_IF_ERROR( + compiler_jump_if(c, loc, e->v.IfExp.body, next, cond)); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, next2); - if (!compiler_jump_if(c, loc, e->v.IfExp.orelse, next, cond)) { - return 0; - } + RETURN_IF_ERROR( + compiler_jump_if(c, loc, e->v.IfExp.orelse, next, cond)); USE_LABEL(c, end); - return 1; + return SUCCESS; } case Compare_kind: { Py_ssize_t n = asdl_seq_LEN(e->v.Compare.ops) - 1; if (n > 0) { - if (check_compare(c, e) < 0) { - return 0; - } + RETURN_IF_ERROR(check_compare(c, e)); NEW_JUMP_TARGET_LABEL(c, cleanup); - _VISIT(c, expr, e->v.Compare.left); + VISIT(c, expr, e->v.Compare.left); for (Py_ssize_t i = 0; i < n; i++) { - _VISIT(c, expr, + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); - _ADDOP_I(c, LOC(e), SWAP, 2); - _ADDOP_I(c, LOC(e), COPY, 2); - _ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, i)); - _ADDOP_JUMP(c, LOC(e), POP_JUMP_IF_FALSE, cleanup); - } - _VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); - _ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, n)); - _ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); + ADDOP_I(c, LOC(e), SWAP, 2); + ADDOP_I(c, LOC(e), COPY, 2); + ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, i)); + ADDOP_JUMP(c, LOC(e), POP_JUMP_IF_FALSE, cleanup); + } + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n)); + ADDOP_COMPARE(c, LOC(e), asdl_seq_GET(e->v.Compare.ops, n)); + ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); NEW_JUMP_TARGET_LABEL(c, end); - _ADDOP_JUMP(c, NO_LOCATION, JUMP, end); + ADDOP_JUMP(c, NO_LOCATION, JUMP, end); USE_LABEL(c, cleanup); - _ADDOP(c, LOC(e), POP_TOP); + ADDOP(c, LOC(e), POP_TOP); if (!cond) { - _ADDOP_JUMP(c, NO_LOCATION, JUMP, next); + ADDOP_JUMP(c, NO_LOCATION, JUMP, next); } USE_LABEL(c, end); - return 1; + return SUCCESS; } /* fallback to general implementation */ break; @@ -3108,9 +3094,9 @@ compiler_jump_if(struct compiler *c, location loc, } /* general implementation */ - _VISIT(c, expr, e); - _ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); - return 1; + VISIT(c, expr, e); + ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next); + return SUCCESS; } static int @@ -3120,9 +3106,9 @@ compiler_ifexp(struct compiler *c, expr_ty e) NEW_JUMP_TARGET_LABEL(c, end); NEW_JUMP_TARGET_LABEL(c, next); - if (!compiler_jump_if(c, LOC(e), e->v.IfExp.test, next, 0)) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_jump_if(c, LOC(e), e->v.IfExp.test, next, 0)); + VISIT(c, expr, e->v.IfExp.body); ADDOP_JUMP(c, NO_LOCATION, JUMP, end); @@ -3202,9 +3188,9 @@ compiler_if(struct compiler *c, stmt_ty s) else { next = end; } - if (!compiler_jump_if(c, LOC(s), s->v.If.test, next, 0)) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_jump_if(c, LOC(s), s->v.If.test, next, 0)); + VISIT_SEQ(c, stmt, s->v.If.body); if (asdl_seq_LEN(s->v.If.orelse)) { ADDOP_JUMP(c, NO_LOCATION, JUMP, end); @@ -3314,15 +3300,11 @@ compiler_while(struct compiler *c, stmt_ty s) USE_LABEL(c, loop); RETURN_IF_ERROR(compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL)); - if (!compiler_jump_if(c, LOC(s), s->v.While.test, anchor, 0)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_jump_if(c, LOC(s), s->v.While.test, anchor, 0)); USE_LABEL(c, body); VISIT_SEQ(c, stmt, s->v.While.body); - if (!compiler_jump_if(c, LOC(s), s->v.While.test, body, 1)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_jump_if(c, LOC(s), s->v.While.test, body, 1)); compiler_pop_fblock(c, WHILE_LOOP, loop); @@ -4113,9 +4095,7 @@ compiler_assert(struct compiler *c, stmt_ty s) return SUCCESS; } NEW_JUMP_TARGET_LABEL(c, end); - if (!compiler_jump_if(c, LOC(s), s->v.Assert.test, end, 1)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_jump_if(c, LOC(s), s->v.Assert.test, end, 1)); ADDOP(c, LOC(s), LOAD_ASSERTION_ERROR); if (s->v.Assert.msg) { VISIT(c, expr, s->v.Assert.msg); @@ -4740,9 +4720,7 @@ compiler_compare(struct compiler *c, expr_ty e) location loc = LOC(e); Py_ssize_t i, n; - if (check_compare(c, e) < 0) { - return 0; - } + RETURN_IF_ERROR(check_compare(c, e)); VISIT(c, expr, e->v.Compare.left); assert(asdl_seq_LEN(e->v.Compare.ops) > 0); n = asdl_seq_LEN(e->v.Compare.ops) - 1; @@ -5378,9 +5356,7 @@ compiler_sync_comprehension_generator(struct compiler *c, location loc, Py_ssize_t n = asdl_seq_LEN(gen->ifs); for (Py_ssize_t i = 0; i < n; i++) { expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i); - if (!compiler_jump_if(c, loc, e, if_cleanup, 0)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0)); } if (++gen_index < asdl_seq_LEN(generators)) { @@ -5477,9 +5453,7 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, Py_ssize_t n = asdl_seq_LEN(gen->ifs); for (Py_ssize_t i = 0; i < n; i++) { expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i); - if (!compiler_jump_if(c, loc, e, if_cleanup, 0)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0)); } depth++; @@ -7213,9 +7187,9 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) // NOTE: Returning macros are safe again. if (m->guard) { RETURN_IF_ERROR(ensure_fail_pop(c, pc, 0)); - if (!compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0)) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_jump_if(c, LOC(m->pattern), m->guard, + pc->fail_pop[0], 0)); } // Success! Pop the subject off, we're done with it: if (i != cases - has_default - 1) { @@ -7241,9 +7215,8 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) ADDOP(c, LOC(m->pattern), NOP); } if (m->guard) { - if (!compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)); } VISIT_SEQ(c, stmt, m->body); } From 13b6f8d3f65039f7e55117b8df10aa116ae2ed95 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 09:56:06 +0000 Subject: [PATCH 77/93] maybe_optimize_method_call, compiler_call_simple_kw_helper return SUCCESS/ERROR --- Python/compile.c | 52 ++++++++++++++++++++---------------------------- 1 file changed, 22 insertions(+), 30 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 52c4ddbdc0bb9f..fd7bd442447ea7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -63,11 +63,6 @@ return -1; \ } -#define RETURN_NULL_IF_ERROR(X) \ - if ((X) == -1) { \ - return NULL; \ - } - /* If we exceed this limit, it should * be considered a compiler bug. * Currently it should be impossible @@ -4917,7 +4912,7 @@ update_start_location_to_match_attr(struct compiler *c, location loc, return loc; } -// Return 1 if the method call was optimized, -1 if not, and 0 on error. +// Return 1 if the method call was optimized, 0 if not, and -1 on error. static int maybe_optimize_method_call(struct compiler *c, expr_ty e) { @@ -4928,49 +4923,48 @@ maybe_optimize_method_call(struct compiler *c, expr_ty e) /* Check that the call node is an attribute access */ if (meth->kind != Attribute_kind || meth->v.Attribute.ctx != Load) { - return -1; + return 0; } /* Check that the base object is not something that is imported */ if (is_import_originated(c, meth->v.Attribute.value)) { - return -1; + return 0; } /* Check that there aren't too many arguments */ argsl = asdl_seq_LEN(args); kwdsl = asdl_seq_LEN(kwds); if (argsl + kwdsl + (kwdsl != 0) >= STACK_USE_GUIDELINE) { - return -1; + return 0; } /* Check that there are no *varargs types of arguments. */ for (i = 0; i < argsl; i++) { expr_ty elt = asdl_seq_GET(args, i); if (elt->kind == Starred_kind) { - return -1; + return 0; } } for (i = 0; i < kwdsl; i++) { keyword_ty kw = asdl_seq_GET(kwds, i); if (kw->arg == NULL) { - return -1; + return 0; } } /* Alright, we can optimize the code. */ - _VISIT(c, expr, meth->v.Attribute.value); + VISIT(c, expr, meth->v.Attribute.value); location loc = LOC(meth); loc = update_start_location_to_match_attr(c, loc, meth); - _ADDOP_NAME(c, loc, LOAD_METHOD, meth->v.Attribute.attr, names); - _VISIT_SEQ(c, expr, e->v.Call.args); + ADDOP_NAME(c, loc, LOAD_METHOD, meth->v.Attribute.attr, names); + VISIT_SEQ(c, expr, e->v.Call.args); if (kwdsl) { - _VISIT_SEQ(c, keyword, kwds); - if (!compiler_call_simple_kw_helper(c, loc, kwds, kwdsl)) { - return 0; - }; + VISIT_SEQ(c, keyword, kwds); + RETURN_IF_ERROR( + compiler_call_simple_kw_helper(c, loc, kwds, kwdsl)); } loc = update_start_location_to_match_attr(c, LOC(e), meth); - _ADDOP_I(c, loc, CALL, argsl + kwdsl); + ADDOP_I(c, loc, CALL, argsl + kwdsl); return 1; } @@ -5003,12 +4997,12 @@ compiler_call(struct compiler *c, expr_ty e) { RETURN_IF_ERROR(validate_keywords(c, e->v.Call.keywords)); int ret = maybe_optimize_method_call(c, e); + if (ret < 0) { + return ERROR; + } if (ret == 1) { return SUCCESS; } - if (ret == 0) { - return ERROR; - } RETURN_IF_ERROR(check_caller(c, e->v.Call.func)); location loc = LOC(e->v.Call.func); ADDOP(c, loc, PUSH_NULL); @@ -5137,7 +5131,6 @@ compiler_subkwargs(struct compiler *c, location loc, /* Used by compiler_call_helper and maybe_optimize_method_call to emit * KW_NAMES before CALL. - * Returns 1 on success, 0 on error. */ static int compiler_call_simple_kw_helper(struct compiler *c, location loc, @@ -5146,7 +5139,7 @@ compiler_call_simple_kw_helper(struct compiler *c, location loc, PyObject *names; names = PyTuple_New(nkwelts); if (names == NULL) { - return 0; + return ERROR; } for (int i = 0; i < nkwelts; i++) { keyword_ty kw = asdl_seq_GET(keywords, i); @@ -5154,11 +5147,11 @@ compiler_call_simple_kw_helper(struct compiler *c, location loc, } Py_ssize_t arg = compiler_add_const(c, names); if (arg < 0) { - return 0; + return ERROR; } Py_DECREF(names); - _ADDOP_I(c, loc, KW_NAMES, arg); - return 1; + ADDOP_I(c, loc, KW_NAMES, arg); + return SUCCESS; } @@ -5200,9 +5193,8 @@ compiler_call_helper(struct compiler *c, location loc, } if (nkwelts) { VISIT_SEQ(c, keyword, keywords); - if (!compiler_call_simple_kw_helper(c, loc, keywords, nkwelts)) { - return ERROR; - }; + RETURN_IF_ERROR( + compiler_call_simple_kw_helper(c, loc, keywords, nkwelts)); } ADDOP_I(c, loc, CALL, n + nelts + nkwelts); return SUCCESS; From 3bfb5d7197b0556375ee4561a75192f1263940af Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 10:00:59 +0000 Subject: [PATCH 78/93] compiler_joined_str, compiler_formatted_value return SUCCESS/ERROR --- Python/compile.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index fd7bd442447ea7..d1ff112244aa7e 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -5020,22 +5020,22 @@ compiler_joined_str(struct compiler *c, expr_ty e) Py_ssize_t value_count = asdl_seq_LEN(e->v.JoinedStr.values); if (value_count > STACK_USE_GUIDELINE) { _Py_DECLARE_STR(empty, ""); - _ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); - _ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); - _ADDOP_I(c, loc, BUILD_LIST, 0); + ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); + ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); + ADDOP_I(c, loc, BUILD_LIST, 0); for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.JoinedStr.values); i++) { - _VISIT(c, expr, asdl_seq_GET(e->v.JoinedStr.values, i)); - _ADDOP_I(c, loc, LIST_APPEND, 1); + VISIT(c, expr, asdl_seq_GET(e->v.JoinedStr.values, i)); + ADDOP_I(c, loc, LIST_APPEND, 1); } - _ADDOP_I(c, loc, CALL, 1); + ADDOP_I(c, loc, CALL, 1); } else { - _VISIT_SEQ(c, expr, e->v.JoinedStr.values); + VISIT_SEQ(c, expr, e->v.JoinedStr.values); if (asdl_seq_LEN(e->v.JoinedStr.values) != 1) { - _ADDOP_I(c, loc, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values)); + ADDOP_I(c, loc, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values)); } } - return 1; + return SUCCESS; } /* Used to implement f-strings. Format a single value. */ @@ -5060,7 +5060,7 @@ compiler_formatted_value(struct compiler *c, expr_ty e) int oparg; /* The expression to be formatted. */ - _VISIT(c, expr, e->v.FormattedValue.value); + VISIT(c, expr, e->v.FormattedValue.value); switch (conversion) { case 's': oparg = FVC_STR; break; @@ -5070,19 +5070,19 @@ compiler_formatted_value(struct compiler *c, expr_ty e) default: PyErr_Format(PyExc_SystemError, "Unrecognized conversion character %d", conversion); - return 0; + return ERROR; } if (e->v.FormattedValue.format_spec) { /* Evaluate the format spec, and update our opcode arg. */ - _VISIT(c, expr, e->v.FormattedValue.format_spec); + VISIT(c, expr, e->v.FormattedValue.format_spec); oparg |= FVS_HAVE_SPEC; } /* And push our opcode and oparg */ location loc = LOC(e); - _ADDOP_I(c, loc, FORMAT_VALUE, oparg); + ADDOP_I(c, loc, FORMAT_VALUE, oparg); - return 1; + return SUCCESS; } static int @@ -5962,9 +5962,9 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) _ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); break; case JoinedStr_kind: - return compiler_joined_str(c, e); + return compiler_joined_str(c, e) == SUCCESS ? 1 : 0; case FormattedValue_kind: - return compiler_formatted_value(c, e); + return compiler_formatted_value(c, e) == SUCCESS ? 1 : 0; /* The following exprs can be assignment targets. */ case Attribute_kind: _VISIT(c, expr, e->v.Attribute.value); From 6d40de71e28fca438963f79c75cf7f4068bd1d7f Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 10:02:58 +0000 Subject: [PATCH 79/93] compiler_slice returns SUCCESS/ERROR --- Python/compile.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index d1ff112244aa7e..96766da23fc8e9 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6002,7 +6002,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Slice_kind: { int n = compiler_slice(c, e); - if (n == 0) { + if (n < 0) { return 0; } _ADDOP_I(c, loc, BUILD_SLICE, n); @@ -6051,9 +6051,7 @@ compiler_augassign(struct compiler *c, stmt_ty s) case Subscript_kind: VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice)) { - if (!compiler_slice(c, e->v.Subscript.slice)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_slice(c, e->v.Subscript.slice)); ADDOP_I(c, loc, COPY, 3); ADDOP_I(c, loc, COPY, 3); ADDOP_I(c, loc, COPY, 3); @@ -6315,7 +6313,7 @@ compiler_subscript(struct compiler *c, expr_ty e) _VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice) && ctx != Del) { - if (!compiler_slice(c, e->v.Subscript.slice)) { + if (compiler_slice(c, e->v.Subscript.slice) < 0) { return 0; } if (ctx == Load) { @@ -6349,22 +6347,22 @@ compiler_slice(struct compiler *c, expr_ty s) /* only handles the cases where BUILD_SLICE is emitted */ if (s->v.Slice.lower) { - _VISIT(c, expr, s->v.Slice.lower); + VISIT(c, expr, s->v.Slice.lower); } else { - _ADDOP_LOAD_CONST(c, LOC(s), Py_None); + ADDOP_LOAD_CONST(c, LOC(s), Py_None); } if (s->v.Slice.upper) { - _VISIT(c, expr, s->v.Slice.upper); + VISIT(c, expr, s->v.Slice.upper); } else { - _ADDOP_LOAD_CONST(c, LOC(s), Py_None); + ADDOP_LOAD_CONST(c, LOC(s), Py_None); } if (s->v.Slice.step) { n++; - _VISIT(c, expr, s->v.Slice.step); + VISIT(c, expr, s->v.Slice.step); } return n; } From 49da813658a87cc184f70822fe81c7f7f78d83fa Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 10:37:21 +0000 Subject: [PATCH 80/93] compiler_nameop returns SUCCESS/ERROR --- Python/compile.c | 91 ++++++++++++++++++++++++------------------------ 1 file changed, 45 insertions(+), 46 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 96766da23fc8e9..ad61cbf87394c3 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2172,8 +2172,8 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, ADDOP(c, *ploc, POP_EXCEPT); if (info->fb_datum) { ADDOP_LOAD_CONST(c, *ploc, Py_None); - compiler_nameop(c, *ploc, info->fb_datum, Store); - compiler_nameop(c, *ploc, info->fb_datum, Del); + RETURN_IF_ERROR(compiler_nameop(c, *ploc, info->fb_datum, Store)); + RETURN_IF_ERROR(compiler_nameop(c, *ploc, info->fb_datum, Del)); } return SUCCESS; } @@ -2250,9 +2250,7 @@ compiler_body(struct compiler *c, location loc, asdl_stmt_seq *stmts) st = (stmt_ty)asdl_seq_GET(stmts, 0); assert(st->kind == Expr_kind); VISIT(c, expr, st->v.Expr.value); - if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store)); } } for (; i < asdl_seq_LEN(stmts); i++) { @@ -2798,7 +2796,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) Py_DECREF(co); RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); - return compiler_nameop(c, loc, name, Store) ? SUCCESS : ERROR; + return compiler_nameop(c, loc, name, Store); } static int @@ -2836,18 +2834,18 @@ compiler_class(struct compiler *c, stmt_ty s) /* use the class name for name mangling */ Py_XSETREF(c->u->u_private, Py_NewRef(s->v.ClassDef.name)); /* load (global) __name__ ... */ - if (!compiler_nameop(c, loc, &_Py_ID(__name__), Load)) { + if (compiler_nameop(c, loc, &_Py_ID(__name__), Load) < 0) { compiler_exit_scope(c); return ERROR; } /* ... and store it as __module__ */ - if (!compiler_nameop(c, loc, &_Py_ID(__module__), Store)) { + if (compiler_nameop(c, loc, &_Py_ID(__module__), Store) < 0) { compiler_exit_scope(c); return ERROR; } assert(c->u->u_qualname); ADDOP_LOAD_CONST(c, loc, c->u->u_qualname); - if (!compiler_nameop(c, loc, &_Py_ID(__qualname__), Store)) { + if (compiler_nameop(c, loc, &_Py_ID(__qualname__), Store) < 0) { compiler_exit_scope(c); return ERROR; } @@ -2868,7 +2866,7 @@ compiler_class(struct compiler *c, stmt_ty s) assert(i == 0); ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i); ADDOP_I(c, NO_LOCATION, COPY, 1); - if (!compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store)) { + if (compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store) < 0) { compiler_exit_scope(c); return ERROR; } @@ -2912,10 +2910,7 @@ compiler_class(struct compiler *c, stmt_ty s) RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); /* 7. store into */ - if (!compiler_nameop(c, loc, s->v.ClassDef.name, Store)) { - return ERROR; - } - return SUCCESS; + return compiler_nameop(c, loc, s->v.ClassDef.name, Store); } /* Return 0 if the expression is a constant value except named singletons. @@ -3612,7 +3607,8 @@ compiler_try_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup_end); NEW_JUMP_TARGET_LABEL(c, cleanup_body); - compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store); + RETURN_IF_ERROR( + compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store)); /* try: @@ -3641,8 +3637,10 @@ compiler_try_except(struct compiler *c, stmt_ty s) ADDOP(c, NO_LOCATION, POP_BLOCK); ADDOP(c, NO_LOCATION, POP_EXCEPT); ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store)); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del)); ADDOP_JUMP(c, NO_LOCATION, JUMP, end); /* except: */ @@ -3650,8 +3648,10 @@ compiler_try_except(struct compiler *c, stmt_ty s) /* name = None; del name; # artificial */ ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store)); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del)); ADDOP_I(c, NO_LOCATION, RERAISE, 1); } @@ -3806,7 +3806,8 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) NEW_JUMP_TARGET_LABEL(c, cleanup_body); if (handler->v.ExceptHandler.name) { - compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store); + RETURN_IF_ERROR( + compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store)); } else { ADDOP(c, loc, POP_TOP); // match @@ -3837,8 +3838,10 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) ADDOP(c, NO_LOCATION, POP_BLOCK); if (handler->v.ExceptHandler.name) { ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store)); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del)); } ADDOP_JUMP(c, NO_LOCATION, JUMP, except); @@ -3848,8 +3851,10 @@ compiler_try_star_except(struct compiler *c, stmt_ty s) /* name = None; del name; # artificial */ if (handler->v.ExceptHandler.name) { ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store); - compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Store)); + RETURN_IF_ERROR( + compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name, Del)); } /* add exception raised to the res list */ @@ -3950,13 +3955,11 @@ compiler_import_as(struct compiler *c, location loc, ADDOP_I(c, loc, SWAP, 2); ADDOP(c, loc, POP_TOP); } - if (!compiler_nameop(c, loc, asname, Store)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_nameop(c, loc, asname, Store)); ADDOP(c, loc, POP_TOP); return SUCCESS; } - return compiler_nameop(c, loc, asname, Store) ? SUCCESS : ERROR; + return compiler_nameop(c, loc, asname, Store); } static int @@ -4001,9 +4004,7 @@ compiler_import(struct compiler *c, stmt_ty s) if (dot != -1) { Py_DECREF(tmp); } - if (!r) { - return ERROR; - } + RETURN_IF_ERROR(r); } } return SUCCESS; @@ -4061,9 +4062,7 @@ compiler_from_import(struct compiler *c, stmt_ty s) store_name = alias->asname; } - if (!compiler_nameop(c, LOC(s), store_name, Store)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_nameop(c, LOC(s), store_name, Store)); } /* remove imported module */ ADDOP(c, LOC(s), POP_TOP); @@ -4318,12 +4317,13 @@ compiler_nameop(struct compiler *c, location loc, !_PyUnicode_EqualToASCIIString(name, "False")); if (forbidden_name(c, loc, name, ctx)) { - return 0; + return ERROR; } mangled = _Py_Mangle(c->u->u_private, name); - if (!mangled) - return 0; + if (!mangled) { + return ERROR; + } op = 0; optype = OP_NAME; @@ -4372,8 +4372,8 @@ compiler_nameop(struct compiler *c, location loc, case Store: op = STORE_FAST; break; case Del: op = DELETE_FAST; break; } - _ADDOP_N(c, loc, op, mangled, varnames); - return 1; + ADDOP_N(c, loc, op, mangled, varnames); + return SUCCESS; case OP_GLOBAL: switch (ctx) { case Load: op = LOAD_GLOBAL; break; @@ -4394,12 +4394,12 @@ compiler_nameop(struct compiler *c, location loc, arg = dict_add_o(dict, mangled); Py_DECREF(mangled); if (arg < 0) { - return 0; + return ERROR; } if (op == LOAD_GLOBAL) { arg <<= 1; } - return cfg_builder_addop_i(CFG_BUILDER(c), op, arg, loc) == SUCCESS ? 1 : 0; + return cfg_builder_addop_i(CFG_BUILDER(c), op, arg, loc); } static int @@ -6009,7 +6009,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) break; } case Name_kind: - return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx); + return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx) == SUCCESS ? 1 : 0; /* child nodes of List and Tuple will have expr_context set */ case List_kind: return compiler_list(c, e) == SUCCESS ? 1 : 0; @@ -6065,8 +6065,7 @@ compiler_augassign(struct compiler *c, stmt_ty s) } break; case Name_kind: - if (!compiler_nameop(c, loc, e->v.Name.id, Load)) - return ERROR; + RETURN_IF_ERROR(compiler_nameop(c, loc, e->v.Name.id, Load)); break; default: PyErr_Format(PyExc_SystemError, @@ -6102,7 +6101,7 @@ compiler_augassign(struct compiler *c, stmt_ty s) } break; case Name_kind: - return compiler_nameop(c, loc, e->v.Name.id, Store) ? SUCCESS : ERROR; + return compiler_nameop(c, loc, e->v.Name.id, Store); default: Py_UNREACHABLE(); } @@ -7168,7 +7167,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) Py_ssize_t nstores = PyList_GET_SIZE(pc->stores); for (Py_ssize_t n = 0; n < nstores; n++) { PyObject *name = PyList_GET_ITEM(pc->stores, n); - if (!compiler_nameop(c, LOC(m->pattern), name, Store)) { + if (compiler_nameop(c, LOC(m->pattern), name, Store) < 0) { Py_DECREF(pc->stores); return ERROR; } From adea67e46a551e6d61093cea24611ae49a0fe65d Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 10:47:02 +0000 Subject: [PATCH 81/93] compiler_subscript and helpers return SUCCES/ERROR --- Python/compile.c | 54 ++++++++++++++++++++++-------------------------- 1 file changed, 25 insertions(+), 29 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index ad61cbf87394c3..7a497cc06e9e33 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -4814,7 +4814,7 @@ check_subscripter(struct compiler *c, expr_ty e) PyLong_Check(v) || PyFloat_Check(v) || PyComplex_Check(v) || PyAnySet_Check(v))) { - return 1; + return SUCCESS; } /* fall through */ case Set_kind: @@ -4822,12 +4822,13 @@ check_subscripter(struct compiler *c, expr_ty e) case GeneratorExp_kind: case Lambda_kind: { location loc = LOC(e); - return compiler_warn(c, loc, "'%.200s' object is not subscriptable; " - "perhaps you missed a comma?", - infer_type(e)->tp_name); + int ret = compiler_warn(c, loc, "'%.200s' object is not subscriptable; " + "perhaps you missed a comma?", + infer_type(e)->tp_name); + return ret == 0 ? ERROR : SUCCESS; } default: - return 1; + return SUCCESS; } } @@ -4840,14 +4841,14 @@ check_index(struct compiler *c, expr_ty e, expr_ty s) if (index_type == NULL || PyType_FastSubclass(index_type, Py_TPFLAGS_LONG_SUBCLASS) || index_type == &PySlice_Type) { - return 1; + return SUCCESS; } switch (e->kind) { case Constant_kind: v = e->v.Constant.value; if (!(PyUnicode_Check(v) || PyBytes_Check(v) || PyTuple_Check(v))) { - return 1; + return SUCCESS; } /* fall through */ case Tuple_kind: @@ -4856,14 +4857,15 @@ check_index(struct compiler *c, expr_ty e, expr_ty s) case JoinedStr_kind: case FormattedValue_kind: { location loc = LOC(e); - return compiler_warn(c, loc, "%.200s indices must be integers " - "or slices, not %.200s; " - "perhaps you missed a comma?", - infer_type(e)->tp_name, - index_type->tp_name); + int ret = compiler_warn(c, loc, "%.200s indices must be integers " + "or slices, not %.200s; " + "perhaps you missed a comma?", + infer_type(e)->tp_name, + index_type->tp_name); + return ret == 0 ? ERROR : SUCCESS; } default: - return 1; + return SUCCESS; } } @@ -5986,7 +5988,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) } break; case Subscript_kind: - return compiler_subscript(c, e); + return compiler_subscript(c, e) == SUCCESS ? 1 : 0; case Starred_kind: switch (e->v.Starred.ctx) { case Store: @@ -6302,38 +6304,32 @@ compiler_subscript(struct compiler *c, expr_ty e) int op = 0; if (ctx == Load) { - if (!check_subscripter(c, e->v.Subscript.value)) { - return 0; - } - if (!check_index(c, e->v.Subscript.value, e->v.Subscript.slice)) { - return 0; - } + RETURN_IF_ERROR(check_subscripter(c, e->v.Subscript.value)); + RETURN_IF_ERROR(check_index(c, e->v.Subscript.value, e->v.Subscript.slice)); } - _VISIT(c, expr, e->v.Subscript.value); + VISIT(c, expr, e->v.Subscript.value); if (is_two_element_slice(e->v.Subscript.slice) && ctx != Del) { - if (compiler_slice(c, e->v.Subscript.slice) < 0) { - return 0; - } + RETURN_IF_ERROR(compiler_slice(c, e->v.Subscript.slice)); if (ctx == Load) { - _ADDOP(c, loc, BINARY_SLICE); + ADDOP(c, loc, BINARY_SLICE); } else { assert(ctx == Store); - _ADDOP(c, loc, STORE_SLICE); + ADDOP(c, loc, STORE_SLICE); } } else { - _VISIT(c, expr, e->v.Subscript.slice); + VISIT(c, expr, e->v.Subscript.slice); switch (ctx) { case Load: op = BINARY_SUBSCR; break; case Store: op = STORE_SUBSCR; break; case Del: op = DELETE_SUBSCR; break; } assert(op); - _ADDOP(c, loc, op); + ADDOP(c, loc, op); } - return 1; + return SUCCESS; } /* Returns the number of the values emitted, From 40f7d1563eb3fc985ccb95ff73896cc543a52824 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 10:57:45 +0000 Subject: [PATCH 82/93] annotations related functions return SUCCESS/ERROR --- Python/compile.c | 58 ++++++++++++++++++++---------------------------- 1 file changed, 24 insertions(+), 34 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 7a497cc06e9e33..29ad90187579e4 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1733,14 +1733,6 @@ cfg_builder_addop_j(cfg_builder *g, location loc, Py_DECREF(__new_const); \ } -#define _ADDOP_N(C, LOC, OP, O, TYPE) { \ - assert(!HAS_CONST(OP)); /* use _ADDOP_LOAD_CONST_NEW */ \ - if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \ - Py_DECREF((O)); \ - return 0; \ - } \ - Py_DECREF((O)); \ -} #define _ADDOP_NAME(C, LOC, OP, O, TYPE) { \ if (compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) \ @@ -2913,13 +2905,13 @@ compiler_class(struct compiler *c, stmt_ty s) return compiler_nameop(c, loc, s->v.ClassDef.name, Store); } -/* Return 0 if the expression is a constant value except named singletons. - Return 1 otherwise. */ -static int +/* Return false if the expression is a constant value except named singletons. + Return true otherwise. */ +static bool check_is_arg(expr_ty e) { if (e->kind != Constant_kind) { - return 1; + return true; } PyObject *value = e->v.Constant.value; return (value == Py_None @@ -2935,11 +2927,11 @@ static int check_compare(struct compiler *c, expr_ty e) { Py_ssize_t i, n; - int left = check_is_arg(e->v.Compare.left); + bool left = check_is_arg(e->v.Compare.left); n = asdl_seq_LEN(e->v.Compare.ops); for (i = 0; i < n; i++) { cmpop_ty op = (cmpop_ty)asdl_seq_GET(e->v.Compare.ops, i); - int right = check_is_arg((expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); + bool right = check_is_arg((expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); if (op == Is || op == IsNot) { if (!right || !left) { const char *msg = (op == Is) @@ -6113,9 +6105,9 @@ compiler_augassign(struct compiler *c, stmt_ty s) static int check_ann_expr(struct compiler *c, expr_ty e) { - _VISIT(c, expr, e); - _ADDOP(c, LOC(e), POP_TOP); - return 1; + VISIT(c, expr, e); + ADDOP(c, LOC(e), POP_TOP); + return SUCCESS; } static int @@ -6124,7 +6116,7 @@ check_annotation(struct compiler *c, stmt_ty s) /* Annotations of complex targets does not produce anything under annotations future */ if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) { - return 1; + return SUCCESS; } /* Annotations are only evaluated in a module or class. */ @@ -6132,7 +6124,7 @@ check_annotation(struct compiler *c, stmt_ty s) c->u->u_scope_type == COMPILER_SCOPE_CLASS) { return check_ann_expr(c, s->v.AnnAssign.annotation); } - return 1; + return SUCCESS; } static int @@ -6141,26 +6133,24 @@ check_ann_subscr(struct compiler *c, expr_ty e) /* We check that everything in a subscript is defined at runtime. */ switch (e->kind) { case Slice_kind: - if (e->v.Slice.lower && !check_ann_expr(c, e->v.Slice.lower)) { - return 0; + if (e->v.Slice.lower && check_ann_expr(c, e->v.Slice.lower) < 0) { + return ERROR; } - if (e->v.Slice.upper && !check_ann_expr(c, e->v.Slice.upper)) { - return 0; + if (e->v.Slice.upper && check_ann_expr(c, e->v.Slice.upper) < 0) { + return ERROR; } - if (e->v.Slice.step && !check_ann_expr(c, e->v.Slice.step)) { - return 0; + if (e->v.Slice.step && check_ann_expr(c, e->v.Slice.step) < 0) { + return ERROR; } - return 1; + return SUCCESS; case Tuple_kind: { /* extended slice */ asdl_expr_seq *elts = e->v.Tuple.elts; Py_ssize_t i, n = asdl_seq_LEN(elts); for (i = 0; i < n; i++) { - if (!check_ann_subscr(c, asdl_seq_GET(elts, i))) { - return 0; - } + RETURN_IF_ERROR(check_ann_subscr(c, asdl_seq_GET(elts, i))); } - return 1; + return SUCCESS; } default: return check_ann_expr(c, e); @@ -6207,14 +6197,14 @@ compiler_annassign(struct compiler *c, stmt_ty s) return ERROR; } if (!s->v.AnnAssign.value && - !check_ann_expr(c, targ->v.Attribute.value)) { + check_ann_expr(c, targ->v.Attribute.value) < 0) { return ERROR; } break; case Subscript_kind: if (!s->v.AnnAssign.value && - (!check_ann_expr(c, targ->v.Subscript.value) || - !check_ann_subscr(c, targ->v.Subscript.slice))) { + (check_ann_expr(c, targ->v.Subscript.value) < 0 || + check_ann_subscr(c, targ->v.Subscript.slice) < 0)) { return ERROR; } break; @@ -6225,7 +6215,7 @@ compiler_annassign(struct compiler *c, stmt_ty s) return ERROR; } /* Annotation is evaluated last. */ - if (!s->v.AnnAssign.simple && !check_annotation(c, s)) { + if (!s->v.AnnAssign.simple && check_annotation(c, s) < 0) { return ERROR; } return SUCCESS; From 07756b4cc24ecd152d4b9082b3117e15c222e38f Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 11:10:45 +0000 Subject: [PATCH 83/93] compiler_subkwargs return SUCCESS/ERROR --- Python/compile.c | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 29ad90187579e4..b78f63c54d0880 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -5092,35 +5092,35 @@ compiler_subkwargs(struct compiler *c, location loc, if (n > 1 && !big) { for (i = begin; i < end; i++) { kw = asdl_seq_GET(keywords, i); - _VISIT(c, expr, kw->value); + VISIT(c, expr, kw->value); } keys = PyTuple_New(n); if (keys == NULL) { - return 0; + return ERROR; } for (i = begin; i < end; i++) { key = ((keyword_ty) asdl_seq_GET(keywords, i))->arg; PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key)); } - _ADDOP_LOAD_CONST_NEW(c, loc, keys); - _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); - return 1; + ADDOP_LOAD_CONST_NEW(c, loc, keys); + ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n); + return SUCCESS; } if (big) { - _ADDOP_I(c, NO_LOCATION, BUILD_MAP, 0); + ADDOP_I(c, NO_LOCATION, BUILD_MAP, 0); } for (i = begin; i < end; i++) { kw = asdl_seq_GET(keywords, i); - _ADDOP_LOAD_CONST(c, loc, kw->arg); - _VISIT(c, expr, kw->value); + ADDOP_LOAD_CONST(c, loc, kw->arg); + VISIT(c, expr, kw->value); if (big) { - _ADDOP_I(c, NO_LOCATION, MAP_ADD, 1); + ADDOP_I(c, NO_LOCATION, MAP_ADD, 1); } } if (!big) { - _ADDOP_I(c, loc, BUILD_MAP, n); + ADDOP_I(c, loc, BUILD_MAP, n); } - return 1; + return SUCCESS; } /* Used by compiler_call_helper and maybe_optimize_method_call to emit @@ -5214,9 +5214,7 @@ compiler_call_helper(struct compiler *c, location loc, if (kw->arg == NULL) { /* A keyword argument unpacking. */ if (nseen) { - if (!compiler_subkwargs(c, loc, keywords, i - nseen, i)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, i - nseen, i)); if (have_dict) { ADDOP_I(c, loc, DICT_MERGE, 1); } @@ -5236,9 +5234,7 @@ compiler_call_helper(struct compiler *c, location loc, } if (nseen) { /* Pack up any trailing keyword arguments. */ - if (!compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts)) { - return ERROR; - } + RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts)); if (have_dict) { ADDOP_I(c, loc, DICT_MERGE, 1); } From 45d26ef88e25c1d4cbc6e45d1f2d7a9e253f4d78 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 11:34:47 +0000 Subject: [PATCH 84/93] visitor functions return SUCCESS/ERROR --- Python/compile.c | 337 ++++++++++++++++++----------------------------- 1 file changed, 128 insertions(+), 209 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index b78f63c54d0880..e44cef17b184b1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1670,13 +1670,11 @@ cfg_builder_addop_j(cfg_builder *g, location loc, the ASDL name to synthesize the name of the C type and the visit function. */ -#define VISIT(C, TYPE, V) {\ - if (!compiler_visit_ ## TYPE((C), (V))) \ - return ERROR; \ -} +#define VISIT(C, TYPE, V) \ + RETURN_IF_ERROR(compiler_visit_ ## TYPE((C), (V))); #define VISIT_IN_SCOPE(C, TYPE, V) {\ - if (!compiler_visit_ ## TYPE((C), (V))) { \ + if (compiler_visit_ ## TYPE((C), (V)) < 0) { \ compiler_exit_scope(c); \ return ERROR; \ } \ @@ -1687,7 +1685,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ - if (!compiler_visit_ ## TYPE((C), elt)) \ + if (compiler_visit_ ## TYPE((C), elt) < 0) \ return ERROR; \ } \ } @@ -1697,7 +1695,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ - if (!compiler_visit_ ## TYPE((C), elt)) { \ + if (compiler_visit_ ## TYPE((C), elt) < 0) { \ compiler_exit_scope(c); \ return ERROR; \ } \ @@ -1705,92 +1703,6 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } -/*******************/ - - - - -#define _ADDOP(C, LOC, OP) { \ - if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) \ - return 0; \ -} - -#define _ADDOP_LOAD_CONST(C, LOC, O) { \ - if (compiler_addop_load_const((C), (LOC), (O)) < 0) \ - return 0; \ -} - -/* Same as _ADDOP_LOAD_CONST, but steals a reference. */ -#define _ADDOP_LOAD_CONST_NEW(C, LOC, O) { \ - PyObject *__new_const = (O); \ - if (__new_const == NULL) { \ - return 0; \ - } \ - if (compiler_addop_load_const((C), (LOC), __new_const) < 0) { \ - Py_DECREF(__new_const); \ - return 0; \ - } \ - Py_DECREF(__new_const); \ -} - - -#define _ADDOP_NAME(C, LOC, OP, O, TYPE) { \ - if (compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) \ - return 0; \ -} - -#define _ADDOP_I(C, LOC, OP, O) { \ - if (cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC)) < 0) \ - return 0; \ -} - -#define _ADDOP_JUMP(C, LOC, OP, O) { \ - if (cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O)) < 0) \ - return 0; \ -} - -#define _ADDOP_COMPARE(C, LOC, CMP) { \ - if (compiler_addcompare((C), (LOC), (cmpop_ty)(CMP)) < 0) \ - return 0; \ -} - -#define _ADDOP_BINARY(C, LOC, BINOP) { \ - if (addop_binary((C), (LOC), (BINOP), false) < 0) \ - return 0; \ - } - - -#define _ADD_YIELD_FROM(C, LOC, await) { \ - if (compiler_add_yield_from((C), (LOC), (await)) < 0) \ - return 0; \ -} - - -#define _ADDOP_YIELD(C, LOC) { \ - if (addop_yield((C), (LOC)) < 0) \ - return 0; \ - } - -/* _VISIT and _VISIT_SEQ takes an ASDL type as their second argument. They use - the ASDL name to synthesize the name of the C type and the visit function. -*/ - -#define _VISIT(C, TYPE, V) {\ - if (!compiler_visit_ ## TYPE((C), (V))) \ - return 0; \ -} - -#define _VISIT_SEQ(C, TYPE, SEQ) { \ - int _i; \ - asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \ - for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ - TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ - if (!compiler_visit_ ## TYPE((C), elt)) \ - return 0; \ - } \ -} - - static int compiler_enter_scope(struct compiler *c, identifier name, int scope_type, void *key, int lineno) @@ -2453,17 +2365,15 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, goto error; } } - if (!compiler_visit_expr(c, default_)) { - goto error; - } + RETURN_IF_ERROR(compiler_visit_expr(c, default_)); } } if (keys != NULL) { Py_ssize_t default_count = PyList_GET_SIZE(keys); PyObject *keys_tuple = PyList_AsTuple(keys); Py_DECREF(keys); - _ADDOP_LOAD_CONST_NEW(c, loc, keys_tuple); - _ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, default_count); + ADDOP_LOAD_CONST_NEW(c, loc, keys_tuple); + ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, default_count); assert(default_count > 0); return 1; } @@ -2480,8 +2390,8 @@ static int compiler_visit_annexpr(struct compiler *c, expr_ty annotation) { location loc = LOC(annotation); - _ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation)); - return 1; + ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation)); + return SUCCESS; } static int @@ -2597,10 +2507,8 @@ compiler_default_arguments(struct compiler *c, location loc, int res = compiler_visit_kwonlydefaults(c, loc, args->kwonlyargs, args->kw_defaults); - if (res < 0) { - return ERROR; - } - else if (res > 0) { + RETURN_IF_ERROR(res); + if (res > 0) { funcflags |= 0x02; } } @@ -2740,10 +2648,8 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) return ERROR; } annotations = compiler_visit_annotations(c, loc, args, returns); - if (annotations == ERROR) { - return ERROR; - } - else if (annotations > 0) { + RETURN_IF_ERROR(annotations); + if (annotations > 0) { funcflags |= 0x04; } @@ -4119,94 +4025,94 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) switch (s->kind) { case FunctionDef_kind: - return compiler_function(c, s, 0) == SUCCESS ? 1 : 0; + return compiler_function(c, s, 0); case ClassDef_kind: - return compiler_class(c, s) == SUCCESS ? 1 : 0; + return compiler_class(c, s); case Return_kind: - return compiler_return(c, s) == SUCCESS ? 1 : 0; + return compiler_return(c, s); case Delete_kind: - _VISIT_SEQ(c, expr, s->v.Delete.targets) + VISIT_SEQ(c, expr, s->v.Delete.targets) break; case Assign_kind: { Py_ssize_t n = asdl_seq_LEN(s->v.Assign.targets); - _VISIT(c, expr, s->v.Assign.value); + VISIT(c, expr, s->v.Assign.value); for (Py_ssize_t i = 0; i < n; i++) { if (i < n - 1) { - _ADDOP_I(c, LOC(s), COPY, 1); + ADDOP_I(c, LOC(s), COPY, 1); } - _VISIT(c, expr, + VISIT(c, expr, (expr_ty)asdl_seq_GET(s->v.Assign.targets, i)); } break; } case AugAssign_kind: - return compiler_augassign(c, s) == SUCCESS ? 1 : 0; + return compiler_augassign(c, s); case AnnAssign_kind: - return compiler_annassign(c, s) == SUCCESS ? 1 : 0; + return compiler_annassign(c, s); case For_kind: - return compiler_for(c, s) == SUCCESS ? 1 : 0; + return compiler_for(c, s); case While_kind: - return compiler_while(c, s) == SUCCESS ? 1 : 0; + return compiler_while(c, s); case If_kind: - return compiler_if(c, s) == SUCCESS ? 1 : 0; + return compiler_if(c, s); case Match_kind: - return compiler_match(c, s) == SUCCESS ? 1 : 0; + return compiler_match(c, s); case Raise_kind: { Py_ssize_t n = 0; if (s->v.Raise.exc) { - _VISIT(c, expr, s->v.Raise.exc); + VISIT(c, expr, s->v.Raise.exc); n++; if (s->v.Raise.cause) { - _VISIT(c, expr, s->v.Raise.cause); + VISIT(c, expr, s->v.Raise.cause); n++; } } - _ADDOP_I(c, LOC(s), RAISE_VARARGS, (int)n); + ADDOP_I(c, LOC(s), RAISE_VARARGS, (int)n); break; } case Try_kind: - return compiler_try(c, s) == SUCCESS ? 1 : 0; + return compiler_try(c, s); case TryStar_kind: - return compiler_try_star(c, s) == SUCCESS ? 1 : 0; + return compiler_try_star(c, s); case Assert_kind: - return compiler_assert(c, s) == SUCCESS ? 1 : 0; + return compiler_assert(c, s); case Import_kind: - return compiler_import(c, s) == SUCCESS ? 1 : 0; + return compiler_import(c, s); case ImportFrom_kind: - return compiler_from_import(c, s) == SUCCESS ? 1 : 0; + return compiler_from_import(c, s); case Global_kind: case Nonlocal_kind: break; case Expr_kind: { - return compiler_stmt_expr(c, LOC(s), s->v.Expr.value) == SUCCESS ? 1 : 0; + return compiler_stmt_expr(c, LOC(s), s->v.Expr.value); } case Pass_kind: { - _ADDOP(c, LOC(s), NOP); + ADDOP(c, LOC(s), NOP); break; } case Break_kind: { - return compiler_break(c, LOC(s)) == SUCCESS ? 1 : 0; + return compiler_break(c, LOC(s)); } case Continue_kind: { - return compiler_continue(c, LOC(s)) == SUCCESS ? 1 : 0; + return compiler_continue(c, LOC(s)); } case With_kind: - return compiler_with(c, s, 0) == SUCCESS ? 1 : 0; + return compiler_with(c, s, 0); case AsyncFunctionDef_kind: - return compiler_function(c, s, 1) == SUCCESS ? 1 : 0; + return compiler_function(c, s, 1); case AsyncWith_kind: - return compiler_async_with(c, s, 0) == SUCCESS ? 1 : 0; + return compiler_async_with(c, s, 0); case AsyncFor_kind: - return compiler_async_for(c, s) == SUCCESS ? 1 : 0; + return compiler_async_for(c, s); } - return 1; + return SUCCESS; } static int @@ -5647,8 +5553,8 @@ compiler_dictcomp(struct compiler *c, expr_ty e) static int compiler_visit_keyword(struct compiler *c, keyword_ty k) { - _VISIT(c, expr, k->value); - return 1; + VISIT(c, expr, k->value); + return SUCCESS; } @@ -5873,140 +5779,146 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) location loc = LOC(e); switch (e->kind) { case NamedExpr_kind: - _VISIT(c, expr, e->v.NamedExpr.value); - _ADDOP_I(c, loc, COPY, 1); - _VISIT(c, expr, e->v.NamedExpr.target); + VISIT(c, expr, e->v.NamedExpr.value); + ADDOP_I(c, loc, COPY, 1); + VISIT(c, expr, e->v.NamedExpr.target); break; case BoolOp_kind: - return compiler_boolop(c, e) == SUCCESS ? 1 : 0; + return compiler_boolop(c, e); case BinOp_kind: - _VISIT(c, expr, e->v.BinOp.left); - _VISIT(c, expr, e->v.BinOp.right); - _ADDOP_BINARY(c, loc, e->v.BinOp.op); + VISIT(c, expr, e->v.BinOp.left); + VISIT(c, expr, e->v.BinOp.right); + ADDOP_BINARY(c, loc, e->v.BinOp.op); break; case UnaryOp_kind: - _VISIT(c, expr, e->v.UnaryOp.operand); - _ADDOP(c, loc, unaryop(e->v.UnaryOp.op)); + VISIT(c, expr, e->v.UnaryOp.operand); + ADDOP(c, loc, unaryop(e->v.UnaryOp.op)); break; case Lambda_kind: - return compiler_lambda(c, e) == SUCCESS ? 1 : 0; + return compiler_lambda(c, e); case IfExp_kind: - return compiler_ifexp(c, e) == SUCCESS ? 1 : 0; + return compiler_ifexp(c, e); case Dict_kind: - return compiler_dict(c, e) == SUCCESS ? 1 : 0; + return compiler_dict(c, e); case Set_kind: - return compiler_set(c, e) == SUCCESS ? 1 : 0; + return compiler_set(c, e); case GeneratorExp_kind: - return compiler_genexp(c, e) == SUCCESS ? 1 : 0; + return compiler_genexp(c, e); case ListComp_kind: - return compiler_listcomp(c, e) == SUCCESS ? 1 : 0; + return compiler_listcomp(c, e); case SetComp_kind: - return compiler_setcomp(c, e) == SUCCESS ? 1 : 0; + return compiler_setcomp(c, e); case DictComp_kind: - return compiler_dictcomp(c, e) == SUCCESS ? 1 : 0; + return compiler_dictcomp(c, e); case Yield_kind: - if (c->u->u_ste->ste_type != FunctionBlock) - return compiler_error(c, loc, "'yield' outside function"); + if (c->u->u_ste->ste_type != FunctionBlock) { + compiler_error(c, loc, "'yield' outside function"); + return ERROR; + } if (e->v.Yield.value) { - _VISIT(c, expr, e->v.Yield.value); + VISIT(c, expr, e->v.Yield.value); } else { - _ADDOP_LOAD_CONST(c, loc, Py_None); + ADDOP_LOAD_CONST(c, loc, Py_None); } - _ADDOP_YIELD(c, loc); + ADDOP_YIELD(c, loc); break; case YieldFrom_kind: - if (c->u->u_ste->ste_type != FunctionBlock) - return compiler_error(c, loc, "'yield' outside function"); - - if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) - return compiler_error(c, loc, "'yield from' inside async function"); - - _VISIT(c, expr, e->v.YieldFrom.value); - _ADDOP(c, loc, GET_YIELD_FROM_ITER); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 0); + if (c->u->u_ste->ste_type != FunctionBlock) { + compiler_error(c, loc, "'yield' outside function"); + return ERROR; + } + if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) { + compiler_error(c, loc, "'yield from' inside async function"); + return ERROR; + } + VISIT(c, expr, e->v.YieldFrom.value); + ADDOP(c, loc, GET_YIELD_FROM_ITER); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 0); break; case Await_kind: if (!IS_TOP_LEVEL_AWAIT(c)){ if (c->u->u_ste->ste_type != FunctionBlock){ - return compiler_error(c, loc, "'await' outside function"); + compiler_error(c, loc, "'await' outside function"); + return ERROR; } if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION && - c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION){ - return compiler_error(c, loc, "'await' outside async function"); + c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION) { + compiler_error(c, loc, "'await' outside async function"); + return ERROR; } } - _VISIT(c, expr, e->v.Await.value); - _ADDOP_I(c, loc, GET_AWAITABLE, 0); - _ADDOP_LOAD_CONST(c, loc, Py_None); - _ADD_YIELD_FROM(c, loc, 1); + VISIT(c, expr, e->v.Await.value); + ADDOP_I(c, loc, GET_AWAITABLE, 0); + ADDOP_LOAD_CONST(c, loc, Py_None); + ADD_YIELD_FROM(c, loc, 1); break; case Compare_kind: - return compiler_compare(c, e) == SUCCESS ? 1 : 0; + return compiler_compare(c, e); case Call_kind: - return compiler_call(c, e) == SUCCESS ? 1 : 0; + return compiler_call(c, e); case Constant_kind: - _ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); + ADDOP_LOAD_CONST(c, loc, e->v.Constant.value); break; case JoinedStr_kind: - return compiler_joined_str(c, e) == SUCCESS ? 1 : 0; + return compiler_joined_str(c, e); case FormattedValue_kind: - return compiler_formatted_value(c, e) == SUCCESS ? 1 : 0; + return compiler_formatted_value(c, e); /* The following exprs can be assignment targets. */ case Attribute_kind: - _VISIT(c, expr, e->v.Attribute.value); + VISIT(c, expr, e->v.Attribute.value); loc = LOC(e); loc = update_start_location_to_match_attr(c, loc, e); switch (e->v.Attribute.ctx) { case Load: - _ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); + ADDOP_NAME(c, loc, LOAD_ATTR, e->v.Attribute.attr, names); break; case Store: if (forbidden_name(c, loc, e->v.Attribute.attr, e->v.Attribute.ctx)) { - return 0; + return ERROR; } - _ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); + ADDOP_NAME(c, loc, STORE_ATTR, e->v.Attribute.attr, names); break; case Del: - _ADDOP_NAME(c, loc, DELETE_ATTR, e->v.Attribute.attr, names); + ADDOP_NAME(c, loc, DELETE_ATTR, e->v.Attribute.attr, names); break; } break; case Subscript_kind: - return compiler_subscript(c, e) == SUCCESS ? 1 : 0; + return compiler_subscript(c, e); case Starred_kind: switch (e->v.Starred.ctx) { case Store: /* In all legitimate cases, the Starred node was already replaced * by compiler_list/compiler_tuple. XXX: is that okay? */ - return compiler_error(c, loc, + compiler_error(c, loc, "starred assignment target must be in a list or tuple"); + return ERROR; default: - return compiler_error(c, loc, + compiler_error(c, loc, "can't use starred expression here"); + return ERROR; } break; case Slice_kind: { int n = compiler_slice(c, e); - if (n < 0) { - return 0; - } - _ADDOP_I(c, loc, BUILD_SLICE, n); + RETURN_IF_ERROR(n); + ADDOP_I(c, loc, BUILD_SLICE, n); break; } case Name_kind: - return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx) == SUCCESS ? 1 : 0; + return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx); /* child nodes of List and Tuple will have expr_context set */ case List_kind: - return compiler_list(c, e) == SUCCESS ? 1 : 0; + return compiler_list(c, e); case Tuple_kind: - return compiler_tuple(c, e) == SUCCESS ? 1 : 0; + return compiler_tuple(c, e); } - return 1; + return SUCCESS; } static int @@ -6791,9 +6703,7 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, compiler_error(c, LOC(p), e); goto error; } - if (!compiler_visit_expr(c, key)) { - goto error; - } + RETURN_IF_ERROR(compiler_visit_expr(c, key)); } // all keys have been checked; there are no duplicates @@ -8865,6 +8775,19 @@ prepare_localsplus(struct compiler* c, int code_flags) return nlocalsplus; } +static int +add_return_at_end_of_block(struct compiler *c, int addNone) +{ + /* Make sure every block that falls off the end returns None. */ + if (!basicblock_returns(CFG_BUILDER(c)->g_curblock)) { + if (addNone) { + ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); + } + ADDOP(c, NO_LOCATION, RETURN_VALUE); + } + return SUCCESS; +} + static PyCodeObject * assemble(struct compiler *c, int addNone) { @@ -8878,12 +8801,8 @@ assemble(struct compiler *c, int addNone) return NULL; } - /* Make sure every block that falls off the end returns None. */ - if (!basicblock_returns(CFG_BUILDER(c)->g_curblock)) { - if (addNone) { - _ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None); - } - _ADDOP(c, NO_LOCATION, RETURN_VALUE); + if (add_return_at_end_of_block(c, addNone) < 0) { + return NULL; } int nblocks = 0; From d5b624b035d597d48a7cee4b9b4dd94d35b4e30c Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 11:46:14 +0000 Subject: [PATCH 85/93] compiler_error returns ERROR --- Python/compile.c | 108 ++++++++++++++++------------------------------- 1 file changed, 37 insertions(+), 71 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index e44cef17b184b1..8cfac779472b72 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1913,8 +1913,7 @@ compiler_push_fblock(struct compiler *c, location loc, { struct fblockinfo *f; if (c->u->u_nfblocks >= CO_MAXBLOCKS) { - compiler_error(c, loc, "too many statically nested blocks"); - return ERROR; + return compiler_error(c, loc, "too many statically nested blocks"); } f = &c->u->u_fblock[c->u->u_nfblocks++]; f->fb_type = t; @@ -2102,9 +2101,8 @@ compiler_unwind_fblock_stack(struct compiler *c, location *ploc, } struct fblockinfo *top = &c->u->u_fblock[c->u->u_nfblocks-1]; if (top->fb_type == EXCEPTION_GROUP_HANDLER) { - compiler_error(c, *ploc, + return compiler_error(c, *ploc, "'break', 'continue' and 'return' cannot appear in an except* block"); - return ERROR; } if (loop != NULL && (top->fb_type == WHILE_LOOP || top->fb_type == FOR_LOOP)) { *loop = top; @@ -3133,8 +3131,7 @@ compiler_async_for(struct compiler *c, stmt_ty s) if (IS_TOP_LEVEL_AWAIT(c)){ c->u->u_ste->ste_coroutine = 1; } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION) { - compiler_error(c, loc, "'async for' outside async function"); - return ERROR; + return compiler_error(c, loc, "'async for' outside async function"); } NEW_JUMP_TARGET_LABEL(c, start); @@ -3212,14 +3209,12 @@ compiler_return(struct compiler *c, stmt_ty s) int preserve_tos = ((s->v.Return.value != NULL) && (s->v.Return.value->kind != Constant_kind)); if (c->u->u_ste->ste_type != FunctionBlock) { - compiler_error(c, loc, "'return' outside function"); - return ERROR; + return compiler_error(c, loc, "'return' outside function"); } if (s->v.Return.value != NULL && c->u->u_ste->ste_coroutine && c->u->u_ste->ste_generator) { - compiler_error(c, loc, "'return' with value in async generator"); - return ERROR; + return compiler_error(c, loc, "'return' with value in async generator"); } if (preserve_tos) { @@ -3256,8 +3251,7 @@ compiler_break(struct compiler *c, location loc) ADDOP(c, loc, NOP); RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, 0, &loop)); if (loop == NULL) { - compiler_error(c, loc, "'break' outside loop"); - return ERROR; + return compiler_error(c, loc, "'break' outside loop"); } RETURN_IF_ERROR(compiler_unwind_fblock(c, &loc, loop, 0)); ADDOP_JUMP(c, loc, JUMP, loop->fb_exit); @@ -3272,8 +3266,7 @@ compiler_continue(struct compiler *c, location loc) ADDOP(c, loc, NOP); RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, 0, &loop)); if (loop == NULL) { - compiler_error(c, loc, "'continue' not properly in loop"); - return ERROR; + return compiler_error(c, loc, "'continue' not properly in loop"); } ADDOP_JUMP(c, loc, JUMP, loop->fb_block); return SUCCESS; @@ -3491,8 +3484,7 @@ compiler_try_except(struct compiler *c, stmt_ty s) s->v.Try.handlers, i); location loc = LOC(handler); if (!handler->v.ExceptHandler.type && i < n-1) { - compiler_error(c, loc, "default 'except:' must be last"); - return ERROR; + return compiler_error(c, loc, "default 'except:' must be last"); } NEW_JUMP_TARGET_LABEL(c, next_except); except = next_except; @@ -3931,9 +3923,8 @@ compiler_from_import(struct compiler *c, stmt_ty s) _PyUnicode_EqualToASCIIString(s->v.ImportFrom.module, "__future__")) { Py_DECREF(names); - compiler_error(c, LOC(s), "from __future__ imports must occur " - "at the beginning of the file"); - return ERROR; + return compiler_error(c, LOC(s), "from __future__ imports must occur " + "at the beginning of the file"); } ADDOP_LOAD_CONST_NEW(c, LOC(s), names); @@ -4425,18 +4416,16 @@ unpack_helper(struct compiler *c, location loc, asdl_expr_seq *elts) if (elt->kind == Starred_kind && !seen_star) { if ((i >= (1 << 8)) || (n-i-1 >= (INT_MAX >> 8))) { - compiler_error(c, loc, + return compiler_error(c, loc, "too many expressions in " "star-unpacking assignment"); - return ERROR; } ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == Starred_kind) { - compiler_error(c, loc, + return compiler_error(c, loc, "multiple starred expressions in assignment"); - return ERROR; } } if (!seen_star) { @@ -4884,8 +4873,7 @@ validate_keywords(struct compiler *c, asdl_keyword_seq *keywords) for (Py_ssize_t j = i + 1; j < nkeywords; j++) { keyword_ty other = ((keyword_ty)asdl_seq_GET(keywords, j)); if (other->arg && !PyUnicode_Compare(key->arg, other->arg)) { - compiler_error(c, LOC(other), "keyword argument repeated: %U", key->arg); - return ERROR; + return compiler_error(c, LOC(other), "keyword argument repeated: %U", key->arg); } } } @@ -5614,8 +5602,7 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) if (IS_TOP_LEVEL_AWAIT(c)){ c->u->u_ste->ste_coroutine = 1; } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION){ - compiler_error(c, loc, "'async with' outside async function"); - return ERROR; + return compiler_error(c, loc, "'async with' outside async function"); } NEW_JUMP_TARGET_LABEL(c, block); @@ -5812,8 +5799,7 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) return compiler_dictcomp(c, e); case Yield_kind: if (c->u->u_ste->ste_type != FunctionBlock) { - compiler_error(c, loc, "'yield' outside function"); - return ERROR; + return compiler_error(c, loc, "'yield' outside function"); } if (e->v.Yield.value) { VISIT(c, expr, e->v.Yield.value); @@ -5825,12 +5811,10 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) break; case YieldFrom_kind: if (c->u->u_ste->ste_type != FunctionBlock) { - compiler_error(c, loc, "'yield' outside function"); - return ERROR; + return compiler_error(c, loc, "'yield' outside function"); } if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) { - compiler_error(c, loc, "'yield from' inside async function"); - return ERROR; + return compiler_error(c, loc, "'yield from' inside async function"); } VISIT(c, expr, e->v.YieldFrom.value); ADDOP(c, loc, GET_YIELD_FROM_ITER); @@ -5840,14 +5824,12 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Await_kind: if (!IS_TOP_LEVEL_AWAIT(c)){ if (c->u->u_ste->ste_type != FunctionBlock){ - compiler_error(c, loc, "'await' outside function"); - return ERROR; + return compiler_error(c, loc, "'await' outside function"); } if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION && c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION) { - compiler_error(c, loc, "'await' outside async function"); - return ERROR; + return compiler_error(c, loc, "'await' outside async function"); } } @@ -5894,13 +5876,11 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) case Store: /* In all legitimate cases, the Starred node was already replaced * by compiler_list/compiler_tuple. XXX: is that okay? */ - compiler_error(c, loc, + return compiler_error(c, loc, "starred assignment target must be in a list or tuple"); - return ERROR; default: - compiler_error(c, loc, + return compiler_error(c, loc, "can't use starred expression here"); - return ERROR; } break; case Slice_kind: @@ -6142,7 +6122,7 @@ compiler_error(struct compiler *c, location loc, PyObject *msg = PyUnicode_FromFormatV(format, vargs); va_end(vargs); if (msg == NULL) { - return 0; + return ERROR; } PyObject *loc_obj = PyErr_ProgramTextObject(c->c_filename, loc.lineno); if (loc_obj == NULL) { @@ -6159,7 +6139,7 @@ compiler_error(struct compiler *c, location loc, exit: Py_DECREF(loc_obj); Py_XDECREF(args); - return 0; + return ERROR; } /* Emits a SyntaxWarning and returns 1 on success. @@ -6345,9 +6325,8 @@ emit_and_reset_fail_pop(struct compiler *c, location loc, static int compiler_error_duplicate_store(struct compiler *c, location loc, identifier n) { - compiler_error(c, loc, + return compiler_error(c, loc, "multiple assignments to name %R in pattern", n); - return ERROR; } // Duplicate the effect of 3.10's ROT_* instructions using SWAPs. @@ -6377,8 +6356,7 @@ pattern_helper_store_name(struct compiler *c, location loc, return ERROR; } if (duplicate) { - compiler_error_duplicate_store(c, loc, n); - return ERROR; + return compiler_error_duplicate_store(c, loc, n); } // Rotate this object underneath any items we need to preserve: Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1; @@ -6403,18 +6381,16 @@ pattern_unpack_helper(struct compiler *c, location loc, if (elt->kind == MatchStar_kind && !seen_star) { if ((i >= (1 << 8)) || (n-i-1 >= (INT_MAX >> 8))) { - compiler_error(c, loc, + return compiler_error(c, loc, "too many expressions in " "star-unpacking sequence pattern"); - return ERROR; } ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8))); seen_star = 1; } else if (elt->kind == MatchStar_kind) { - compiler_error(c, loc, + return compiler_error(c, loc, "multiple starred expressions in sequence pattern"); - return ERROR; } } if (!seen_star) { @@ -6505,12 +6481,10 @@ compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc) if (!pc->allow_irrefutable) { if (p->v.MatchAs.name) { const char *e = "name capture %R makes remaining patterns unreachable"; - compiler_error(c, LOC(p), e, p->v.MatchAs.name); - return ERROR; + return compiler_error(c, LOC(p), e, p->v.MatchAs.name); } const char *e = "wildcard makes remaining patterns unreachable"; - compiler_error(c, LOC(p), e); - return ERROR; + return compiler_error(c, LOC(p), e); } return pattern_helper_store_name(c, LOC(p), p->v.MatchAs.name, pc); } @@ -6549,8 +6523,7 @@ validate_kwd_attrs(struct compiler *c, asdl_identifier_seq *attrs, asdl_pattern_ identifier other = ((identifier)asdl_seq_GET(attrs, j)); if (!PyUnicode_Compare(attr, other)) { location loc = LOC((pattern_ty) asdl_seq_GET(patterns, j)); - compiler_error(c, loc, "attribute name repeated in class pattern: %U", attr); - return ERROR; + return compiler_error(c, loc, "attribute name repeated in class pattern: %U", attr); } } } @@ -6571,13 +6544,11 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char * e = "kwd_attrs (%d) / kwd_patterns (%d) length mismatch in class pattern"; - compiler_error(c, LOC(p), e, nattrs, nkwd_patterns); - return ERROR; + return compiler_error(c, LOC(p), e, nattrs, nkwd_patterns); } if (INT_MAX < nargs || INT_MAX < nargs + nattrs - 1) { const char *e = "too many sub-patterns in class pattern %R"; - compiler_error(c, LOC(p), e, p->v.MatchClass.cls); - return ERROR; + return compiler_error(c, LOC(p), e, p->v.MatchClass.cls); } if (nattrs) { RETURN_IF_ERROR(validate_kwd_attrs(c, kwd_attrs, kwd_patterns)); @@ -6636,8 +6607,7 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char * e = "keys (%d) / patterns (%d) length mismatch in mapping pattern"; - compiler_error(c, LOC(p), e, size, npatterns); - return ERROR; + return compiler_error(c, LOC(p), e, size, npatterns); } // We have a double-star target if "rest" is set PyObject *star_target = p->v.MatchMapping.rest; @@ -6659,8 +6629,7 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE)); } if (INT_MAX < size - 1) { - compiler_error(c, LOC(p), "too many sub-patterns in mapping pattern"); - return ERROR; + return compiler_error(c, LOC(p), "too many sub-patterns in mapping pattern"); } // Collect all of the keys into a tuple for MATCH_KEYS and // **rest. They can either be dotted names or literals: @@ -6926,8 +6895,7 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, if (pattern->kind == MatchStar_kind) { if (star >= 0) { const char *e = "multiple starred names in sequence pattern"; - compiler_error(c, LOC(p), e); - return ERROR; + return compiler_error(c, LOC(p), e); } star_wildcard = WILDCARD_STAR_CHECK(pattern); only_wildcard &= star_wildcard; @@ -6978,8 +6946,7 @@ compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc) expr_ty value = p->v.MatchValue.value; if (!MATCH_VALUE_EXPR(value)) { const char *e = "patterns may only match literals and attribute lookups"; - compiler_error(c, LOC(p), e); - return ERROR; + return compiler_error(c, LOC(p), e); } VISIT(c, expr, value); ADDOP_COMPARE(c, LOC(p), Eq); @@ -7021,8 +6988,7 @@ compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc) // AST validator shouldn't let this happen, but if it does, // just fail, don't crash out of the interpreter const char *e = "invalid match pattern node in AST (kind=%d)"; - compiler_error(c, LOC(p), e, p->kind); - return ERROR; + return compiler_error(c, LOC(p), e, p->kind); } static int From ef1001c14921f5a60cf2702ebd35805e61fe5239 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 11:49:27 +0000 Subject: [PATCH 86/93] compiler_warn returns SUCCESS/ERROR --- Python/compile.c | 42 ++++++++++++++++++------------------------ 1 file changed, 18 insertions(+), 24 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 8cfac779472b72..f327ab134e6db1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2841,8 +2841,7 @@ check_compare(struct compiler *c, expr_ty e) const char *msg = (op == Is) ? "\"is\" with a literal. Did you mean \"==\"?" : "\"is not\" with a literal. Did you mean \"!=\"?"; - int ret = compiler_warn(c, LOC(e), msg); - return ret == 0 ? ERROR : SUCCESS; + return compiler_warn(c, LOC(e), msg); } } left = right; @@ -3968,11 +3967,9 @@ compiler_assert(struct compiler *c, stmt_ty s) PyTuple_Check(s->v.Assert.test->v.Constant.value) && PyTuple_Size(s->v.Assert.test->v.Constant.value) > 0)) { - if (!compiler_warn(c, LOC(s), "assertion is always true, " - "perhaps remove parentheses?")) - { - return ERROR; - } + RETURN_IF_ERROR( + compiler_warn(c, LOC(s), "assertion is always true, " + "perhaps remove parentheses?")); } if (c->c_optimize) { return SUCCESS; @@ -4679,10 +4676,9 @@ check_caller(struct compiler *c, expr_ty e) case JoinedStr_kind: case FormattedValue_kind: { location loc = LOC(e); - int ret = compiler_warn(c, loc, "'%.200s' object is not callable; " - "perhaps you missed a comma?", - infer_type(e)->tp_name); - return ret == 0 ? ERROR : SUCCESS; + return compiler_warn(c, loc, "'%.200s' object is not callable; " + "perhaps you missed a comma?", + infer_type(e)->tp_name); } default: return SUCCESS; @@ -4709,10 +4705,9 @@ check_subscripter(struct compiler *c, expr_ty e) case GeneratorExp_kind: case Lambda_kind: { location loc = LOC(e); - int ret = compiler_warn(c, loc, "'%.200s' object is not subscriptable; " - "perhaps you missed a comma?", - infer_type(e)->tp_name); - return ret == 0 ? ERROR : SUCCESS; + return compiler_warn(c, loc, "'%.200s' object is not subscriptable; " + "perhaps you missed a comma?", + infer_type(e)->tp_name); } default: return SUCCESS; @@ -4744,12 +4739,11 @@ check_index(struct compiler *c, expr_ty e, expr_ty s) case JoinedStr_kind: case FormattedValue_kind: { location loc = LOC(e); - int ret = compiler_warn(c, loc, "%.200s indices must be integers " - "or slices, not %.200s; " - "perhaps you missed a comma?", - infer_type(e)->tp_name, - index_type->tp_name); - return ret == 0 ? ERROR : SUCCESS; + return compiler_warn(c, loc, "%.200s indices must be integers " + "or slices, not %.200s; " + "perhaps you missed a comma?", + infer_type(e)->tp_name, + index_type->tp_name); } default: return SUCCESS; @@ -6155,7 +6149,7 @@ compiler_warn(struct compiler *c, location loc, PyObject *msg = PyUnicode_FromFormatV(format, vargs); va_end(vargs); if (msg == NULL) { - return 0; + return ERROR; } if (PyErr_WarnExplicitObject(PyExc_SyntaxWarning, msg, c->c_filename, loc.lineno, NULL, NULL) < 0) @@ -6168,10 +6162,10 @@ compiler_warn(struct compiler *c, location loc, compiler_error(c, loc, PyUnicode_AsUTF8(msg)); } Py_DECREF(msg); - return 0; + return ERROR; } Py_DECREF(msg); - return 1; + return SUCCESS; } static int From e1a54146866041ca8d9686a6ddacbff0d127964a Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 13:28:12 +0000 Subject: [PATCH 87/93] use RETURN_IF_ERROR in a few places --- Python/compile.c | 31 +++++++++++-------------------- 1 file changed, 11 insertions(+), 20 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index f327ab134e6db1..9e3c639be5c76b 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -5308,10 +5308,9 @@ compiler_async_comprehension_generator(struct compiler *c, location loc, USE_LABEL(c, start); /* Runtime will push a block here, so we need to account for that */ - if (compiler_push_fblock(c, loc, ASYNC_COMPREHENSION_GENERATOR, - start, NO_LABEL, NULL) < 0) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, loc, ASYNC_COMPREHENSION_GENERATOR, + start, NO_LABEL, NULL)); ADDOP_JUMP(c, loc, SETUP_FINALLY, except); ADDOP(c, loc, GET_ANEXT); @@ -5631,8 +5630,8 @@ compiler_async_with(struct compiler *c, stmt_ty s, int pos) /* BLOCK code */ VISIT_SEQ(c, stmt, s->v.AsyncWith.body) } - else if (compiler_async_with(c, s, pos) == ERROR) { - return ERROR; + else { + RETURN_IF_ERROR(compiler_async_with(c, s, pos)); } compiler_pop_fblock(c, ASYNC_WITH, block); @@ -5725,8 +5724,8 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) /* BLOCK code */ VISIT_SEQ(c, stmt, s->v.With.body) } - else if (compiler_with(c, s, pos) == ERROR) { - return ERROR; + else { + RETURN_IF_ERROR(compiler_with(c, s, pos)); } ADDOP(c, NO_LOCATION, POP_BLOCK); @@ -6346,20 +6345,14 @@ pattern_helper_store_name(struct compiler *c, location loc, } // Can't assign to the same name twice: int duplicate = PySequence_Contains(pc->stores, n); - if (duplicate < 0) { - return ERROR; - } + RETURN_IF_ERROR(duplicate); if (duplicate) { return compiler_error_duplicate_store(c, loc, n); } // Rotate this object underneath any items we need to preserve: Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1; - if (pattern_helper_rotate(c, loc, rotations) < 0) { - return ERROR; - } - if (PyList_Append(pc->stores, n) < 0) { - return ERROR; - } + RETURN_IF_ERROR(pattern_helper_rotate(c, loc, rotations)); + RETURN_IF_ERROR(PyList_Append(pc->stores, n)); return SUCCESS; } @@ -6398,9 +6391,7 @@ pattern_helper_sequence_unpack(struct compiler *c, location loc, asdl_pattern_seq *patterns, Py_ssize_t star, pattern_context *pc) { - if (pattern_unpack_helper(c, loc, patterns) < 0) { - return ERROR; - } + RETURN_IF_ERROR(pattern_unpack_helper(c, loc, patterns)); Py_ssize_t size = asdl_seq_LEN(patterns); // We've now got a bunch of new subjects on the stack. They need to remain // there after each subpattern match: From e2b63688d0f1190b825e8ddb282624488a7024ff Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 13:50:51 +0000 Subject: [PATCH 88/93] minor tweaks --- Python/compile.c | 44 +++++++++++++++++--------------------------- 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 9e3c639be5c76b..146c3d52cf4a63 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1318,10 +1318,6 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) return stack_effect(opcode, oparg, -1); } -/* Add an opcode with no argument. - Returns 0 on failure, 1 on success. -*/ - static int basicblock_addop(basicblock *b, int opcode, int oparg, location loc) { @@ -1605,7 +1601,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP(C, LOC, OP) \ - RETURN_IF_ERROR(cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))); + RETURN_IF_ERROR(cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))) #define ADDOP_IN_SCOPE(C, LOC, OP) { \ if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \ @@ -1615,7 +1611,7 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_LOAD_CONST(C, LOC, O) \ - RETURN_IF_ERROR(compiler_addop_load_const((C), (LOC), (O))); + RETURN_IF_ERROR(compiler_addop_load_const((C), (LOC), (O))) /* Same as ADDOP_LOAD_CONST, but steals a reference. */ #define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \ @@ -1640,31 +1636,31 @@ cfg_builder_addop_j(cfg_builder *g, location loc, } #define ADDOP_NAME(C, LOC, OP, O, TYPE) \ - RETURN_IF_ERROR(compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))); + RETURN_IF_ERROR(compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))) #define ADDOP_I(C, LOC, OP, O) \ - RETURN_IF_ERROR(cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC))); + RETURN_IF_ERROR(cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC))) #define ADDOP_JUMP(C, LOC, OP, O) \ - RETURN_IF_ERROR(cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))); + RETURN_IF_ERROR(cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))) #define ADDOP_COMPARE(C, LOC, CMP) \ - RETURN_IF_ERROR(compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))); + RETURN_IF_ERROR(compiler_addcompare((C), (LOC), (cmpop_ty)(CMP))) #define ADDOP_BINARY(C, LOC, BINOP) \ - RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false)); + RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false)) #define ADDOP_INPLACE(C, LOC, BINOP) \ - RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true)); + RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true)) -#define ADD_YIELD_FROM(C, LOC, await) \ - RETURN_IF_ERROR(compiler_add_yield_from((C), (LOC), (await))); +#define ADD_YIELD_FROM(C, LOC, await) \ + RETURN_IF_ERROR(compiler_add_yield_from((C), (LOC), (await))) -#define POP_EXCEPT_AND_RERAISE(C, LOC) \ - RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))); +#define POP_EXCEPT_AND_RERAISE(C, LOC) \ + RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC))) #define ADDOP_YIELD(C, LOC) \ - RETURN_IF_ERROR(addop_yield((C), (LOC))); + RETURN_IF_ERROR(addop_yield((C), (LOC))) /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use the ASDL name to synthesize the name of the C type and the visit function. @@ -1784,17 +1780,13 @@ compiler_enter_scope(struct compiler *c, identifier name, c->c_nestlevel++; cfg_builder *g = CFG_BUILDER(c); - if (cfg_builder_init(g) < 0) { - return ERROR; - } + RETURN_IF_ERROR(cfg_builder_init(g)); if (u->u_scope_type == COMPILER_SCOPE_MODULE) { loc.lineno = 0; } else { - if (compiler_set_qualname(c) < 0){ - return ERROR; - } + RETURN_IF_ERROR(compiler_set_qualname(c)); } ADDOP_I(c, loc, RESUME, 0); @@ -2110,9 +2102,7 @@ compiler_unwind_fblock_stack(struct compiler *c, location *ploc, } struct fblockinfo copy = *top; c->u->u_nfblocks--; - if (compiler_unwind_fblock(c, ploc, ©, preserve_tos) < 0) { - return ERROR; - } + RETURN_IF_ERROR(compiler_unwind_fblock(c, ploc, ©, preserve_tos)); RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, ploc, preserve_tos, loop)); c->u->u_fblock[c->u->u_nfblocks] = copy; c->u->u_nfblocks++; @@ -6204,7 +6194,7 @@ compiler_subscript(struct compiler *c, expr_ty e) } /* Returns the number of the values emitted, - * thus are needed to build the slice, or 0 if there is an error. */ + * thus are needed to build the slice, or -1 if there is an error. */ static int compiler_slice(struct compiler *c, expr_ty s) { From dad47998a1836382a2acfdf1835222bf939a3798 Mon Sep 17 00:00:00 2001 From: Irit Katriel Date: Mon, 5 Dec 2022 14:04:46 +0000 Subject: [PATCH 89/93] reduce diff, revert error --- Python/compile.c | 89 ++++++++++++++++++++++++------------------------ 1 file changed, 45 insertions(+), 44 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index 146c3d52cf4a63..64d62794b9d9f1 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2007,9 +2007,8 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, /* This POP_BLOCK gets the line number of the unwinding statement */ ADDOP(c, *ploc, POP_BLOCK); if (preserve_tos) { - if (compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL) < 0) { - return ERROR; - } + RETURN_IF_ERROR( + compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL)); } /* Emit the finally block */ VISIT_SEQ(c, stmt, info->fb_datum); @@ -2041,9 +2040,7 @@ compiler_unwind_fblock(struct compiler *c, location *ploc, if (preserve_tos) { ADDOP_I(c, *ploc, SWAP, 2); } - if (compiler_call_exit_with_nones(c, *ploc) < 0) { - return ERROR; - } + RETURN_IF_ERROR(compiler_call_exit_with_nones(c, *ploc)); if (info->fb_type == ASYNC_WITH) { ADDOP_I(c, *ploc, GET_AWAITABLE, 2); ADDOP_LOAD_CONST(c, *ploc, Py_None); @@ -2093,8 +2090,8 @@ compiler_unwind_fblock_stack(struct compiler *c, location *ploc, } struct fblockinfo *top = &c->u->u_fblock[c->u->u_nfblocks-1]; if (top->fb_type == EXCEPTION_GROUP_HANDLER) { - return compiler_error(c, *ploc, - "'break', 'continue' and 'return' cannot appear in an except* block"); + return compiler_error( + c, *ploc, "'break', 'continue' and 'return' cannot appear in an except* block"); } if (loop != NULL && (top->fb_type == WHILE_LOOP || top->fb_type == FOR_LOOP)) { *loop = top; @@ -2353,7 +2350,9 @@ compiler_visit_kwonlydefaults(struct compiler *c, location loc, goto error; } } - RETURN_IF_ERROR(compiler_visit_expr(c, default_)); + if (compiler_visit_expr(c, default_) < 0) { + goto error; + } } } if (keys != NULL) { @@ -2445,26 +2444,30 @@ compiler_visit_annotations(struct compiler *c, location loc, */ Py_ssize_t annotations_len = 0; - if (compiler_visit_argannotations(c, args->args, &annotations_len, loc) < 0) - return ERROR; - if (compiler_visit_argannotations(c, args->posonlyargs, &annotations_len, loc) < 0) - return ERROR; - if (args->vararg && args->vararg->annotation && - compiler_visit_argannotation(c, args->vararg->arg, - args->vararg->annotation, &annotations_len, loc) < 0) - return ERROR; - if (compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len, loc) < 0) - return ERROR; - if (args->kwarg && args->kwarg->annotation && - compiler_visit_argannotation(c, args->kwarg->arg, - args->kwarg->annotation, &annotations_len, loc) < 0) - return ERROR; + RETURN_IF_ERROR( + compiler_visit_argannotations(c, args->args, &annotations_len, loc)); - if (compiler_visit_argannotation(c, &_Py_ID(return), returns, - &annotations_len, loc) < 0) { - return ERROR; + RETURN_IF_ERROR( + compiler_visit_argannotations(c, args->posonlyargs, &annotations_len, loc)); + + if (args->vararg && args->vararg->annotation) { + RETURN_IF_ERROR( + compiler_visit_argannotation(c, args->vararg->arg, + args->vararg->annotation, &annotations_len, loc)); + } + + RETURN_IF_ERROR( + compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len, loc)); + + if (args->kwarg && args->kwarg->annotation) { + RETURN_IF_ERROR( + compiler_visit_argannotation(c, args->kwarg->arg, + args->kwarg->annotation, &annotations_len, loc)); } + RETURN_IF_ERROR( + compiler_visit_argannotation(c, &_Py_ID(return), returns, &annotations_len, loc)); + if (annotations_len) { ADDOP_I(c, loc, BUILD_TUPLE, annotations_len); return 1; @@ -2796,7 +2799,8 @@ compiler_class(struct compiler *c, stmt_ty s) RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); /* 7. store into */ - return compiler_nameop(c, loc, s->v.ClassDef.name, Store); + RETURN_IF_ERROR(compiler_nameop(c, loc, s->v.ClassDef.name, Store)); + return SUCCESS; } /* Return false if the expression is a constant value except named singletons. @@ -3865,9 +3869,7 @@ compiler_import(struct compiler *c, stmt_ty s) if (alias->asname) { r = compiler_import_as(c, loc, alias->name, alias->asname); - if (r == ERROR) { - return r; - } + RETURN_IF_ERROR(r); } else { identifier tmp = alias->name; @@ -4857,7 +4859,8 @@ validate_keywords(struct compiler *c, asdl_keyword_seq *keywords) for (Py_ssize_t j = i + 1; j < nkeywords; j++) { keyword_ty other = ((keyword_ty)asdl_seq_GET(keywords, j)); if (other->arg && !PyUnicode_Compare(key->arg, other->arg)) { - return compiler_error(c, LOC(other), "keyword argument repeated: %U", key->arg); + compiler_error(c, LOC(other), "keyword argument repeated: %U", key->arg); + return ERROR; } } } @@ -6498,7 +6501,8 @@ validate_kwd_attrs(struct compiler *c, asdl_identifier_seq *attrs, asdl_pattern_ identifier other = ((identifier)asdl_seq_GET(attrs, j)); if (!PyUnicode_Compare(attr, other)) { location loc = LOC((pattern_ty) asdl_seq_GET(patterns, j)); - return compiler_error(c, loc, "attribute name repeated in class pattern: %U", attr); + compiler_error(c, loc, "attribute name repeated in class pattern: %U", attr); + return ERROR; } } } @@ -6530,7 +6534,7 @@ compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc) } VISIT(c, expr, p->v.MatchClass.cls); PyObject *attr_names = PyTuple_New(nattrs); - if (!attr_names) { + if (attr_names == NULL) { return ERROR; } Py_ssize_t i; @@ -6647,7 +6651,9 @@ compiler_pattern_mapping(struct compiler *c, pattern_ty p, compiler_error(c, LOC(p), e); goto error; } - RETURN_IF_ERROR(compiler_visit_expr(c, key)); + if (compiler_visit_expr(c, key) < 0) { + goto error; + } } // all keys have been checked; there are no duplicates @@ -6904,12 +6910,10 @@ compiler_pattern_sequence(struct compiler *c, pattern_ty p, ADDOP(c, LOC(p), POP_TOP); } else if (star_wildcard) { - RETURN_IF_ERROR( - pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); + RETURN_IF_ERROR(pattern_helper_sequence_subscr(c, LOC(p), patterns, star, pc)); } else { - RETURN_IF_ERROR( - pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc)); + RETURN_IF_ERROR(pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc)); } return SUCCESS; } @@ -6982,7 +6986,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) ADDOP_I(c, LOC(m->pattern), COPY, 1); } pc->stores = PyList_New(0); - if (!pc->stores) { + if (pc->stores == NULL) { return ERROR; } // Irrefutable cases must be either guarded, last, or both: @@ -7009,9 +7013,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) // NOTE: Returning macros are safe again. if (m->guard) { RETURN_IF_ERROR(ensure_fail_pop(c, pc, 0)); - RETURN_IF_ERROR( - compiler_jump_if(c, LOC(m->pattern), m->guard, - pc->fail_pop[0], 0)); + RETURN_IF_ERROR(compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0)); } // Success! Pop the subject off, we're done with it: if (i != cases - has_default - 1) { @@ -7037,8 +7039,7 @@ compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc) ADDOP(c, LOC(m->pattern), NOP); } if (m->guard) { - RETURN_IF_ERROR( - compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)); + RETURN_IF_ERROR(compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0)); } VISIT_SEQ(c, stmt, m->body); } From 9c7d675ed2347dcc18730460bed4d7f4ddbd6e42 Mon Sep 17 00:00:00 2001 From: "blurb-it[bot]" <43283697+blurb-it[bot]@users.noreply.github.com> Date: Mon, 12 Dec 2022 11:27:57 +0000 Subject: [PATCH 90/93] =?UTF-8?q?=F0=9F=93=9C=F0=9F=A4=96=20Added=20by=20b?= =?UTF-8?q?lurb=5Fit.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../2022-12-12-11-27-54.gh-issue-99955.Ix5Rrg.rst | 1 + 1 file changed, 1 insertion(+) create mode 100644 Misc/NEWS.d/next/Core and Builtins/2022-12-12-11-27-54.gh-issue-99955.Ix5Rrg.rst diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-12-12-11-27-54.gh-issue-99955.Ix5Rrg.rst b/Misc/NEWS.d/next/Core and Builtins/2022-12-12-11-27-54.gh-issue-99955.Ix5Rrg.rst new file mode 100644 index 00000000000000..e9867b39ad7d1c --- /dev/null +++ b/Misc/NEWS.d/next/Core and Builtins/2022-12-12-11-27-54.gh-issue-99955.Ix5Rrg.rst @@ -0,0 +1 @@ +Internal compiler functions (in compile.c) now consistently return -1 on error and 0 on success. From 4271c4389e3653927a88fbdf46ca832f094eb8c0 Mon Sep 17 00:00:00 2001 From: Irit Katriel <1055913+iritkatriel@users.noreply.github.com> Date: Mon, 12 Dec 2022 11:31:01 +0000 Subject: [PATCH 91/93] Remove unnecessary () --- Python/compile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Python/compile.c b/Python/compile.c index 64d62794b9d9f1..86857744749a8b 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -6810,7 +6810,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc) // Need to NULL this for the PyObject_Free call in the error block. old_pc.fail_pop = NULL; // No match. Pop the remaining copy of the subject and fail: - if ((cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, LOC(p)) < 0) || + if (cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, LOC(p)) < 0 || jump_to_fail_pop(c, LOC(p), pc, JUMP) < 0) { goto error; } From 48802dc2b88b9594e4b53a6652eb4bcd44567cfe Mon Sep 17 00:00:00 2001 From: Irit Katriel <1055913+iritkatriel@users.noreply.github.com> Date: Mon, 12 Dec 2022 11:32:07 +0000 Subject: [PATCH 92/93] -1 --> ERROR Co-authored-by: Mark Shannon --- Python/compile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Python/compile.c b/Python/compile.c index 86857744749a8b..fbe7441999ab10 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -60,7 +60,7 @@ #define RETURN_IF_ERROR(X) \ if ((X) == -1) { \ - return -1; \ + return ERROR; \ } /* If we exceed this limit, it should From a47b4821f58c130c7555112cba57b387e9534e01 Mon Sep 17 00:00:00 2001 From: Irit Katriel <1055913+iritkatriel@users.noreply.github.com> Date: Mon, 12 Dec 2022 13:06:33 +0000 Subject: [PATCH 93/93] whitespace --- Python/compile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Python/compile.c b/Python/compile.c index fbe7441999ab10..17b164a4d06ef5 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -60,7 +60,7 @@ #define RETURN_IF_ERROR(X) \ if ((X) == -1) { \ - return ERROR; \ + return ERROR; \ } /* If we exceed this limit, it should pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy