*/
#define STACK_USE_GUIDELINE 30
+#define SUCCESS 0
+#define ERROR -1
+
+#define RETURN_IF_ERROR(X) \
+ if ((X) == -1) { \
+ return ERROR; \
+ }
+
/* If we exceed this limit, it should
* be considered a compiler bug.
* Currently it should be impossible
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);
{
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;
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*
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;
}
{
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
|| 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);
_Py_DECLARE_STR(dot_locals, ".<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);
_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
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)
{
int off = basicblock_next_instr(b);
if (off < 0) {
- return 0;
+ return ERROR;
}
struct instr *i = &b->b_instr[off];
i->i_opcode = opcode;
i->i_target = NULL;
i->i_loc = loc;
- return 1;
+ return SUCCESS;
}
static bool
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;
+ if (arg < 0) {
+ return ERROR;
+ }
return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, loc);
}
int opcode, PyObject *dict, PyObject *o)
{
Py_ssize_t arg = dict_add_o(dict, o);
- if (arg < 0)
- return 0;
+ if (arg < 0) {
+ return ERROR;
+ }
return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, 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;
}
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)
{
return cfg_builder_addop(g, opcode, target.id, loc);
}
-
-#define ADDOP(C, LOC, OP) { \
- if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC))) \
- return 0; \
-}
+#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))) { \
+ if (cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), (LOC)) < 0) { \
compiler_exit_scope(c); \
- return 0; \
+ return -1; \
} \
}
-#define ADDOP_LOAD_CONST(C, LOC, O) { \
- if (!compiler_addop_load_const((C), (LOC), (O))) \
- return 0; \
-}
+#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 0; \
+ return ERROR; \
} \
- 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; \
+ 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))) { \
+ if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O)) < 0) { \
Py_DECREF((O)); \
- return 0; \
+ return ERROR; \
} \
Py_DECREF((O)); \
}
-#define ADDOP_NAME(C, LOC, OP, O, TYPE) { \
- if (!compiler_addop_name((C), (LOC), (OP), (C)->u->u_ ## TYPE, (O))) \
- return 0; \
-}
+#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) { \
- if (!cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), (LOC))) \
- return 0; \
-}
+#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) { \
- if (!cfg_builder_addop_j(CFG_BUILDER(C), (LOC), (OP), (O))) \
- return 0; \
-}
+#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 0; \
-}
+#define ADDOP_COMPARE(C, LOC, CMP) \
+ RETURN_IF_ERROR(compiler_addcompare((C), (LOC), (cmpop_ty)(CMP)))
#define ADDOP_BINARY(C, LOC, BINOP) \
- RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), false))
+ RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false))
#define ADDOP_INPLACE(C, LOC, BINOP) \
- RETURN_IF_FALSE(addop_binary((C), (LOC), (BINOP), true))
+ RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true))
#define ADD_YIELD_FROM(C, LOC, await) \
- RETURN_IF_FALSE(compiler_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_FALSE(compiler_pop_except_and_reraise((C), (LOC)))
+ RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC)))
#define ADDOP_YIELD(C, LOC) \
- RETURN_IF_FALSE(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.
*/
-#define VISIT(C, TYPE, V) {\
- if (!compiler_visit_ ## TYPE((C), (V))) \
- return 0; \
-}
+#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 0; \
+ return ERROR; \
} \
}
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; \
+ if (compiler_visit_ ## TYPE((C), elt) < 0) \
+ return ERROR; \
} \
}
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 0; \
+ return ERROR; \
} \
} \
}
-#define RETURN_IF_FALSE(X) \
- if (!(X)) { \
- return 0; \
- }
static int
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;
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. */
_PyLong_GetZero());
if (res < 0) {
compiler_unit_free(u);
- return 0;
+ return ERROR;
}
}
PyDict_GET_SIZE(u->u_cellvars));
if (!u->u_freevars) {
compiler_unit_free(u);
- return 0;
+ return ERROR;
}
u->u_nfblocks = 0;
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;
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);
c->c_nestlevel++;
cfg_builder *g = CFG_BUILDER(c);
- if (!cfg_builder_init(g)) {
- return 0;
- }
+ RETURN_IF_ERROR(cfg_builder_init(g));
if (u->u_scope_type == COMPILER_SCOPE_MODULE) {
loc.lineno = 0;
}
else {
- if (!compiler_set_qualname(c))
- return 0;
+ RETURN_IF_ERROR(compiler_set_qualname(c));
}
ADDOP_I(c, loc, RESUME, 0);
if (u->u_scope_type == COMPILER_SCOPE_MODULE) {
loc.lineno = -1;
}
- return 1;
+ return SUCCESS;
}
static void
/* 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;
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);
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) ||
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) ||
find_ann(st->v.TryStar.orelse);
break;
default:
- res = 0;
+ res = false;
}
if (res) {
break;
f->fb_block = block_label;
f->fb_exit = exit;
f->fb_datum = datum;
- return 1;
+ return SUCCESS;
}
static void
ADDOP_LOAD_CONST(c, loc, Py_None);
ADDOP_LOAD_CONST(c, loc, Py_None);
ADDOP_I(c, loc, CALL, 2);
- return 1;
+ return SUCCESS;
}
static int
ADDOP(c, loc, CLEANUP_THROW);
USE_LABEL(c, exit);
- return 1;
+ return SUCCESS;
}
static int
ADDOP_I(c, loc, COPY, 3);
ADDOP(c, loc, POP_EXCEPT);
ADDOP_I(c, loc, RERAISE, 1);
- return 1;
+ return SUCCESS;
}
/* Unwind a frame block. If preserve_tos is true, the TOS before
case EXCEPTION_HANDLER:
case EXCEPTION_GROUP_HANDLER:
case ASYNC_COMPREHENSION_GENERATOR:
- return 1;
+ return SUCCESS;
case FOR_LOOP:
/* Pop the iterator */
ADDOP_I(c, *ploc, SWAP, 2);
}
ADDOP(c, *ploc, POP_TOP);
- return 1;
+ return SUCCESS;
case TRY_EXCEPT:
ADDOP(c, *ploc, POP_BLOCK);
- return 1;
+ return SUCCESS;
case FINALLY_TRY:
/* 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)) {
- return 0;
- }
+ 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);
* statement causing the unwinding, so make the unwinding
* instruction artificial */
*ploc = NO_LOCATION;
- return 1;
+ return SUCCESS;
case FINALLY_END:
if (preserve_tos) {
}
ADDOP(c, *ploc, POP_BLOCK);
ADDOP(c, *ploc, POP_EXCEPT);
- return 1;
+ return SUCCESS;
case WITH:
case ASYNC_WITH:
if (preserve_tos) {
ADDOP_I(c, *ploc, SWAP, 2);
}
- if(!compiler_call_exit_with_nones(c, *ploc)) {
- return 0;
- }
+ 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);
* 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_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 1;
+ return SUCCESS;
}
case POP_VALUE: {
if (preserve_tos) {
ADDOP_I(c, *ploc, SWAP, 2);
}
ADDOP(c, *ploc, POP_TOP);
- return 1;
+ return SUCCESS;
}
}
Py_UNREACHABLE();
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) {
}
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)) {
- return 0;
- }
- if (!compiler_unwind_fblock_stack(c, ploc, preserve_tos, loop)) {
- return 0;
- }
+ 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++;
- return 1;
+ return SUCCESS;
}
/* Compile a sequence of statements, checking for a docstring
if (find_ann(stmts)) {
ADDOP(c, loc, SETUP_ANNOTATIONS);
}
- if (!asdl_seq_LEN(stmts))
- return 1;
+ if (!asdl_seq_LEN(stmts)) {
+ return SUCCESS;
+ }
/* if not -OO mode, set docstring */
if (c->c_optimize < 2) {
docstring = _PyAST_GetDocString(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 0;
+ RETURN_IF_ERROR(compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store));
}
}
- for (; i < asdl_seq_LEN(stmts); i++)
+ for (; i < asdl_seq_LEN(stmts); i++) {
VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
- return 1;
+ }
+ return SUCCESS;
}
static int
compiler_codegen(struct compiler *c, mod_ty mod)
{
_Py_DECLARE_STR(anon_module, "<module>");
- if (!compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE,
- mod, 1)) {
- 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)) {
+ if (compiler_body(c, loc, mod->v.Module.body) < 0) {
compiler_exit_scope(c);
- return 0;
+ return ERROR;
}
break;
case Interactive_kind:
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);
*/
int reftype = get_ref_type(c, name);
if (reftype == -1) {
- return 0;
+ return ERROR;
}
int arg;
if (reftype == CELL) {
co->co_name,
freevars);
Py_DECREF(freevars);
- return 0;
+ return ERROR;
}
ADDOP_I(c, loc, LOAD_CLOSURE, arg);
}
}
ADDOP_LOAD_CONST(c, loc, (PyObject*)co);
ADDOP_I(c, loc, MAKE_FUNCTION, flags);
- return 1;
+ return SUCCESS;
}
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++) {
+ 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);
}
- return 1;
+ return SUCCESS;
}
static int
{
/* 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;
keys = PyList_New(1);
if (keys == NULL) {
Py_DECREF(mangled);
- return 0;
+ return ERROR;
}
PyList_SET_ITEM(keys, 0, mangled);
}
goto error;
}
}
- if (!compiler_visit_expr(c, default_)) {
+ if (compiler_visit_expr(c, default_) < 0) {
goto error;
}
}
return 1;
}
else {
- return -1;
+ return 0;
}
error:
Py_XDECREF(keys);
- return 0;
+ return ERROR;
}
static int
{
location loc = LOC(annotation);
ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation));
- return 1;
+ return SUCCESS;
}
static int
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);
Py_DECREF(mangled);
}
}
*annotations_len += 2;
- return 1;
+ return SUCCESS;
}
static int
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
/* 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 (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;
- if (args->kwarg && args->kwarg->annotation &&
- !compiler_visit_argannotation(c, args->kwarg->arg,
- args->kwarg->annotation, &annotations_len, loc))
- return 0;
+ RETURN_IF_ERROR(
+ compiler_visit_argannotations(c, args->args, &annotations_len, loc));
- if (!compiler_visit_argannotation(c, &_Py_ID(return), returns,
- &annotations_len, loc)) {
- return 0;
+ 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;
}
- return -1;
+ return 0;
}
static int
{
VISIT_SEQ(c, expr, args->defaults);
ADDOP_I(c, loc, BUILD_TUPLE, asdl_seq_LEN(args->defaults));
- return 1;
+ return SUCCESS;
}
static Py_ssize_t
{
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) {
int res = compiler_visit_kwonlydefaults(c, loc,
args->kwonlyargs,
args->kw_defaults);
- if (res == 0) {
- return -1;
- }
- else if (res > 0) {
+ RETURN_IF_ERROR(res);
+ if (res > 0) {
funcflags |= 0x02;
}
}
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))
- return 0;
+ if (forbidden_name(c, LOC(arg), arg->arg, Store)) {
+ return ERROR;
+ }
}
- return 1;
+ return SUCCESS;
}
static int
{
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
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
.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);
USE_LABEL(c, handler);
ADDOP(c, NO_LOCATION, STOPITERATION_ERROR);
ADDOP_I(c, NO_LOCATION, RERAISE, 1);
- return 1;
+ return SUCCESS;
}
static int
scope_type = COMPILER_SCOPE_FUNCTION;
}
- if (!compiler_check_debug_args(c, args))
- return 0;
-
- if (!compiler_decorators(c, decos))
- return 0;
+ RETURN_IF_ERROR(compiler_check_debug_args(c, args));
+ RETURN_IF_ERROR(compiler_decorators(c, decos));
firstlineno = s->lineno;
if (asdl_seq_LEN(decos)) {
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;
- }
- else if (annotations > 0) {
+ RETURN_IF_ERROR(annotations);
+ if (annotations > 0) {
funcflags |= 0x04;
}
- if (!compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno)) {
- 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) {
}
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);
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;
+ return ERROR;
}
}
co = assemble(c, 1);
if (co == NULL) {
Py_XDECREF(qualname);
Py_XDECREF(co);
- return 0;
+ return ERROR;
}
- 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;
+ return ERROR;
}
Py_DECREF(qualname);
Py_DECREF(co);
- if (!compiler_apply_decorators(c, decos))
- return 0;
+ RETURN_IF_ERROR(compiler_apply_decorators(c, decos));
return compiler_nameop(c, loc, name, Store);
}
int i, firstlineno;
asdl_expr_seq *decos = s->v.ClassDef.decorator_list;
- if (!compiler_decorators(c, decos))
- return 0;
+ RETURN_IF_ERROR(compiler_decorators(c, decos));
firstlineno = s->lineno;
if (asdl_seq_LEN(decos)) {
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)) {
- 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);
/* 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 0;
+ 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 0;
+ 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 0;
+ return ERROR;
}
/* 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;
+ return ERROR;
}
/* The following code is artificial */
/* Return __classcell__ if it is referenced, otherwise return None */
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);
- 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 0;
+ return ERROR;
}
}
else {
}
/* 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, 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;
+ return ERROR;
}
Py_DECREF(co);
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;
+ RETURN_IF_ERROR(compiler_call_helper(c, loc, 2,
+ s->v.ClassDef.bases,
+ s->v.ClassDef.keywords));
+
/* 6. apply decorators */
- if (!compiler_apply_decorators(c, decos))
- return 0;
+ RETURN_IF_ERROR(compiler_apply_decorators(c, decos));
/* 7. store into <name> */
- if (!compiler_nameop(c, loc, s->v.ClassDef.name, Store))
- return 0;
- return 1;
+ RETURN_IF_ERROR(compiler_nameop(c, loc, s->v.ClassDef.name, Store));
+ return SUCCESS;
}
-/* 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
|| 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)
{
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)
}
left = right;
}
- return 1;
+ return SUCCESS;
}
static int compiler_addcompare(struct compiler *c, location loc,
break;
case Is:
ADDOP_I(c, loc, IS_OP, 0);
- return 1;
+ return SUCCESS;
case IsNot:
ADDOP_I(c, loc, IS_OP, 1);
- return 1;
+ return SUCCESS;
case In:
ADDOP_I(c, loc, CONTAINS_OP, 0);
- return 1;
+ return SUCCESS;
case NotIn:
ADDOP_I(c, loc, CONTAINS_OP, 1);
- return 1;
+ return SUCCESS;
default:
Py_UNREACHABLE();
}
ADDOP_I(c, loc, COMPARE_OP, cmp);
- return 1;
+ return SUCCESS;
}
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;
- }
+ 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)) {
- return 0;
- }
+ RETURN_IF_ERROR(check_compare(c, e));
NEW_JUMP_TARGET_LABEL(c, cleanup);
VISIT(c, expr, e->v.Compare.left);
for (Py_ssize_t i = 0; i < n; i++) {
}
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
/* fallback to general implementation */
break;
/* general implementation */
VISIT(c, expr, e);
ADDOP_JUMP(c, LOC(e), cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next);
- return 1;
+ return SUCCESS;
}
static int
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 0;
- }
+ 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);
VISIT(c, expr, e->v.IfExp.orelse);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
arguments_ty args = e->v.Lambda.args;
assert(e->kind == Lambda_kind);
- if (!compiler_check_debug_args(c, args))
- return 0;
+ RETURN_IF_ERROR(compiler_check_debug_args(c, args));
location loc = LOC(e);
funcflags = compiler_default_arguments(c, loc, args);
}
_Py_DECLARE_STR(anon_lambda, "<lambda>");
- if (!compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA,
- (void *)e, e->lineno)) {
- 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);
compiler_exit_scope(c);
if (co == NULL) {
Py_DECREF(qualname);
- return 0;
+ return ERROR;
}
- 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;
+ return ERROR;
}
Py_DECREF(qualname);
Py_DECREF(co);
- return 1;
+ return SUCCESS;
}
static int
else {
next = end;
}
- if (!compiler_jump_if(c, LOC(s), s->v.If.test, next, 0)) {
- return 0;
- }
+ 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);
}
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
NEW_JUMP_TARGET_LABEL(c, cleanup);
NEW_JUMP_TARGET_LABEL(c, end);
- if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) {
- return 0;
- }
+ 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);
VISIT_SEQ(c, stmt, s->v.For.orelse);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
ADDOP(c, loc, GET_AITER);
USE_LABEL(c, start);
- if (!compiler_push_fblock(c, loc, FOR_LOOP, start, end, NULL)) {
- 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);
VISIT_SEQ(c, stmt, s->v.For.orelse);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
NEW_JUMP_TARGET_LABEL(c, anchor);
USE_LABEL(c, loop);
- if (!compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL)) {
- return 0;
- }
- if (!compiler_jump_if(c, LOC(s), s->v.While.test, anchor, 0)) {
- return 0;
- }
+
+ RETURN_IF_ERROR(compiler_push_fblock(c, LOC(s), WHILE_LOOP, loop, end, NULL));
+ 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 0;
- }
+ RETURN_IF_ERROR(compiler_jump_if(c, LOC(s), s->v.While.test, body, 1));
compiler_pop_fblock(c, WHILE_LOOP, loop);
}
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
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)
+ if (c->u->u_ste->ste_type != FunctionBlock) {
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)
{
- return compiler_error(
- c, loc, "'return' with value in async generator");
+ return compiler_error(c, loc, "'return' with value in async generator");
}
if (preserve_tos) {
ADDOP(c, loc, NOP);
}
- if (!compiler_unwind_fblock_stack(c, &loc, preserve_tos, NULL))
- 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(c, loc, RETURN_VALUE);
- return 1;
+ return SUCCESS;
}
static int
struct fblockinfo *loop = NULL;
/* Emit instruction with line number */
ADDOP(c, loc, NOP);
- if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) {
- return 0;
- }
+ 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)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_unwind_fblock(c, &loc, loop, 0));
ADDOP_JUMP(c, loc, JUMP, loop->fb_exit);
- return 1;
+ return SUCCESS;
}
static int
struct fblockinfo *loop = NULL;
/* Emit instruction with line number */
ADDOP(c, loc, NOP);
- if (!compiler_unwind_fblock_stack(c, &loc, 0, &loop)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_unwind_fblock_stack(c, &loc, 0, &loop));
if (loop == NULL) {
return compiler_error(c, loc, "'continue' not properly in loop");
}
ADDOP_JUMP(c, loc, JUMP, loop->fb_block);
- return 1;
+ return SUCCESS;
}
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))
- 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;
+ RETURN_IF_ERROR(compiler_try_except(c, s));
}
else {
VISIT_SEQ(c, stmt, s->v.Try.body);
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))
- return 0;
+ 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);
POP_EXCEPT_AND_RERAISE(c, loc);
USE_LABEL(c, exit);
- return 1;
+ return SUCCESS;
}
static int
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)) {
- 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);
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)) {
- return 0;
- }
+ 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);
POP_EXCEPT_AND_RERAISE(c, loc);
USE_LABEL(c, exit);
- return 1;
+ return SUCCESS;
}
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;
+ 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_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;
+ 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);
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:
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)) {
- 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);
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: */
/* 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);
}
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;
+ 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);
POP_EXCEPT_AND_RERAISE(c, NO_LOCATION);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
/*
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;
- }
+ 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, 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")) {
- 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);
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
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)) {
- 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);
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);
/* 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 */
VISIT_SEQ(c, stmt, s->v.TryStar.orelse);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
*/
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;
+ 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);
}
- if (!compiler_nameop(c, loc, asname, Store)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_nameop(c, loc, asname, Store));
ADDOP(c, loc, POP_TOP);
- return 1;
+ return SUCCESS;
}
return compiler_nameop(c, loc, asname, Store);
}
if (alias->asname) {
r = compiler_import_as(c, loc, alias->name, alias->asname);
- if (!r)
- return r;
+ RETURN_IF_ERROR(r);
}
else {
identifier tmp = alias->name;
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;
+ RETURN_IF_ERROR(r);
}
}
- return 1;
+ return SUCCESS;
}
static int
PyObject *names = PyTuple_New(n);
if (!names) {
- return 0;
+ return ERROR;
}
/* build up the names */
if (i == 0 && PyUnicode_READ_CHAR(alias->name, 0) == '*') {
assert(n == 1);
ADDOP(c, LOC(s), IMPORT_STAR);
- return 1;
+ return SUCCESS;
}
ADDOP_NAME(c, LOC(s), IMPORT_FROM, alias->name, names);
store_name = alias->asname;
}
- if (!compiler_nameop(c, LOC(s), store_name, Store)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_nameop(c, LOC(s), store_name, Store));
}
/* remove imported module */
ADDOP(c, LOC(s), POP_TOP);
- return 1;
+ return SUCCESS;
}
static int
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 0;
- }
+ RETURN_IF_ERROR(
+ compiler_warn(c, LOC(s), "assertion is always true, "
+ "perhaps remove parentheses?"));
}
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_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);
ADDOP_I(c, LOC(s), RAISE_VARARGS, 1);
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
if (c->c_interactive && c->c_nestlevel <= 1) {
VISIT(c, expr, value);
ADDOP(c, loc, PRINT_EXPR);
- return 1;
+ return SUCCESS;
}
if (value->kind == Constant_kind) {
/* ignore constant statement */
ADDOP(c, loc, NOP);
- return 1;
+ return SUCCESS;
}
VISIT(c, expr, value);
ADDOP(c, NO_LOCATION, POP_TOP); /* artificial */
- return 1;
+ return SUCCESS;
}
static int
return compiler_async_for(c, s);
}
- return 1;
+ return SUCCESS;
}
static int
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;
+ return SUCCESS;
}
}
ADDOP_I(c, loc, YIELD_VALUE, 0);
ADDOP_I(c, loc, RESUME, 1);
- return 1;
+ return SUCCESS;
}
static int
!_PyUnicode_EqualToASCIIString(name, "True") &&
!_PyUnicode_EqualToASCIIString(name, "False"));
- if (forbidden_name(c, loc, name, ctx))
- return 0;
+ if (forbidden_name(c, loc, name, ctx)) {
+ return ERROR;
+ }
mangled = _Py_Mangle(c->u->u_private, name);
- if (!mangled)
- return 0;
+ if (!mangled) {
+ return ERROR;
+ }
op = 0;
optype = OP_NAME;
case Del: op = DELETE_FAST; break;
}
ADDOP_N(c, loc, op, mangled, varnames);
- return 1;
+ return SUCCESS;
case OP_GLOBAL:
switch (ctx) {
case Load: op = LOAD_GLOBAL; break;
arg = dict_add_o(dict, mangled);
Py_DECREF(mangled);
if (arg < 0) {
- return 0;
+ return ERROR;
}
if (op == LOAD_GLOBAL) {
arg <<= 1;
VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n));
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
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++) {
if (add == SET_ADD) {
Py_SETREF(folded, PyFrozenSet_New(folded));
if (folded == NULL) {
- return 0;
+ return ERROR;
}
}
ADDOP_I(c, loc, build, pushed);
ADDOP(c, loc, LIST_TO_TUPLE);
}
}
- return 1;
+ return SUCCESS;
}
int big = n+pushed > STACK_USE_GUIDELINE;
} else {
ADDOP_I(c, loc, build, n+pushed);
}
- return 1;
+ return SUCCESS;
}
int sequence_built = 0;
if (big) {
if (tuple) {
ADDOP(c, loc, LIST_TO_TUPLE);
}
- return 1;
+ return SUCCESS;
}
static int
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)))
+ (n-i-1 >= (INT_MAX >> 8))) {
return compiler_error(c, loc,
"too many expressions in "
"star-unpacking assignment");
+ }
ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8)));
seen_star = 1;
}
if (!seen_star) {
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);
}
- return 1;
+ return SUCCESS;
}
static int
return starunpack_helper(c, loc, elts, 0,
BUILD_LIST, LIST_APPEND, LIST_EXTEND, 0);
}
- else
+ else {
VISIT_SEQ(c, expr, elts);
- return 1;
+ }
+ return SUCCESS;
}
static int
return starunpack_helper(c, loc, elts, 0,
BUILD_LIST, LIST_APPEND, LIST_EXTEND, 1);
}
- else
+ else {
VISIT_SEQ(c, expr, elts);
- return 1;
+ }
+ return SUCCESS;
}
static int
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
}
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;
}
ADDOP_LOAD_CONST_NEW(c, loc, keys);
ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
- return 1;
+ return SUCCESS;
}
if (big) {
ADDOP_I(c, loc, BUILD_MAP, 0);
if (!big) {
ADDOP_I(c, loc, BUILD_MAP, n);
}
- return 1;
+ return SUCCESS;
}
static int
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);
}
}
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);
}
}
}
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);
}
if (!have_dict) {
ADDOP_I(c, loc, BUILD_MAP, 0);
}
- return 1;
+ return SUCCESS;
}
static int
location loc = LOC(e);
Py_ssize_t i, n;
- if (!check_compare(c, e)) {
- 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;
USE_LABEL(c, end);
}
- return 1;
+ return SUCCESS;
}
static PyTypeObject *
infer_type(e)->tp_name);
}
default:
- return 1;
+ return SUCCESS;
}
}
PyLong_Check(v) || PyFloat_Check(v) || PyComplex_Check(v) ||
PyAnySet_Check(v)))
{
- return 1;
+ return SUCCESS;
}
/* fall through */
case Set_kind:
infer_type(e)->tp_name);
}
default:
- return 1;
+ return SUCCESS;
}
}
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:
index_type->tp_name);
}
default:
- return 1;
+ return SUCCESS;
}
}
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)
{
/* 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. */
if (kwdsl) {
VISIT_SEQ(c, keyword, kwds);
- if (!compiler_call_simple_kw_helper(c, loc, kwds, kwdsl)) {
- return 0;
- };
+ 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);
}
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) {
- 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 < 0) {
+ return ERROR;
}
- if (!check_caller(c, e->v.Call.func)) {
- return 0;
+ if (ret == 1) {
+ return SUCCESS;
}
+ 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_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. */
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. */
location loc = LOC(e);
ADDOP_I(c, loc, FORMAT_VALUE, oparg);
- return 1;
+ return SUCCESS;
}
static int
}
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;
}
ADDOP_LOAD_CONST_NEW(c, loc, keys);
ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
- return 1;
+ return SUCCESS;
}
if (big) {
ADDOP_I(c, NO_LOCATION, BUILD_MAP, 0);
if (!big) {
ADDOP_I(c, loc, BUILD_MAP, n);
}
- return 1;
+ return SUCCESS;
}
/* 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,
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);
}
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;
+ return SUCCESS;
}
{
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);
}
if (nkwelts) {
VISIT_SEQ(c, keyword, keywords);
- if (!compiler_call_simple_kw_helper(c, loc, keywords, nkwelts)) {
- return 0;
- };
+ RETURN_IF_ERROR(
+ compiler_call_simple_kw_helper(c, loc, keywords, nkwelts));
}
ADDOP_I(c, loc, CALL, n + nelts + nkwelts);
- return 1;
+ return SUCCESS;
ex_call:
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;
+ LIST_APPEND, LIST_EXTEND, 1) < 0) {
+ return ERROR;
}
/* Then keyword arguments */
if (nkwelts) {
if (kw->arg == NULL) {
/* A keyword argument unpacking. */
if (nseen) {
- if (!compiler_subkwargs(c, loc, keywords, i - nseen, i)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, i - nseen, i));
if (have_dict) {
ADDOP_I(c, loc, DICT_MERGE, 1);
}
}
if (nseen) {
/* Pack up any trailing keyword arguments. */
- if (!compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts));
if (have_dict) {
ADDOP_I(c, loc, DICT_MERGE, 1);
}
assert(have_dict);
}
ADDOP_I(c, loc, CALL_FUNCTION_EX, nkwelts > 0);
- return 1;
+ return SUCCESS;
}
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_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0));
}
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);
ADDOP_I(c, elt_loc, MAP_ADD, depth + 1);
break;
default:
- return 0;
+ return ERROR;
}
}
ADDOP(c, NO_LOCATION, END_FOR);
}
- return 1;
+ return SUCCESS;
}
static int
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)) {
- return 0;
- }
+ 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);
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_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0));
}
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);
ADDOP_I(c, elt_loc, MAP_ADD, depth + 1);
break;
default:
- return 0;
+ return ERROR;
}
}
ADDOP(c, loc, END_ASYNC_FOR);
- return 1;
+ return SUCCESS;
}
static int
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;
}
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;
}
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;
}
}
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)) {
+ if (compiler_make_closure(c, loc, co, 0, qualname) < 0) {
goto error;
}
Py_DECREF(qualname);
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
compiler_visit_keyword(struct compiler *c, keyword_ty k)
{
VISIT(c, expr, k->value);
- return 1;
+ return SUCCESS;
}
POP_EXCEPT_AND_RERAISE(c, NO_LOCATION);
USE_LABEL(c, exit);
- return 1;
+ return SUCCESS;
}
/*
/* SETUP_WITH pushes a finally block. */
USE_LABEL(c, block);
- if (!compiler_push_fblock(c, loc, ASYNC_WITH, block, final, s)) {
- 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);
}
else {
- /* Discard result from context.__aenter__() */
+ /* Discard result from context.__aenter__() */
ADDOP(c, loc, POP_TOP);
}
/* BLOCK code */
VISIT_SEQ(c, stmt, s->v.AsyncWith.body)
}
- else if (!compiler_async_with(c, s, pos)) {
- return 0;
+ else {
+ RETURN_IF_ERROR(compiler_async_with(c, s, pos));
}
compiler_pop_fblock(c, ASYNC_WITH, block);
/* For successful outcome:
* call __exit__(None, None, None)
*/
- if(!compiler_call_exit_with_nones(c, loc))
- return 0;
+ 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_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 1;
+ return SUCCESS;
}
/* SETUP_WITH pushes a finally block. */
USE_LABEL(c, block);
- if (!compiler_push_fblock(c, loc, WITH, block, final, s)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_push_fblock(c, loc, WITH, block, final, s));
if (item->optional_vars) {
VISIT(c, expr, item->optional_vars);
}
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;
+ }
+ else {
+ RETURN_IF_ERROR(compiler_with(c, s, pos));
+ }
ADDOP(c, NO_LOCATION, POP_BLOCK);
compiler_pop_fblock(c, WITH, block);
* call __exit__(None, None, None)
*/
loc = LOC(s);
- if (!compiler_call_exit_with_nones(c, loc))
- return 0;
+ RETURN_IF_ERROR(compiler_call_exit_with_nones(c, loc));
ADDOP(c, loc, POP_TOP);
ADDOP_JUMP(c, loc, JUMP, exit);
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 1;
+ return SUCCESS;
}
static int
case DictComp_kind:
return compiler_dictcomp(c, e);
case Yield_kind:
- if (c->u->u_ste->ste_type != FunctionBlock)
+ 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);
}
ADDOP_YIELD(c, loc);
break;
case YieldFrom_kind:
- if (c->u->u_ste->ste_type != FunctionBlock)
+ 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)
+ }
+ 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);
}
if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION &&
- c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION){
+ c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION) {
return compiler_error(c, loc, "'await' outside async function");
}
}
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);
break;
case Slice_kind:
{
int n = compiler_slice(c, e);
- if (n == 0) {
- return 0;
- }
+ RETURN_IF_ERROR(n);
ADDOP_I(c, loc, BUILD_SLICE, n);
break;
}
case Tuple_kind:
return compiler_tuple(c, e);
}
- return 1;
+ return SUCCESS;
}
static int
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 0;
- }
+ 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);
}
break;
case Name_kind:
- if (!compiler_nameop(c, loc, e->v.Name.id, Load))
- return 0;
+ RETURN_IF_ERROR(compiler_nameop(c, loc, e->v.Name.id, Load));
break;
default:
PyErr_Format(PyExc_SystemError,
"invalid node type (%d) for augmented assignment",
e->kind);
- return 0;
+ return ERROR;
}
loc = LOC(s);
default:
Py_UNREACHABLE();
}
- return 1;
+ return SUCCESS;
}
static int
{
VISIT(c, expr, e);
ADDOP(c, LOC(e), POP_TOP);
- return 1;
+ return SUCCESS;
}
static int
/* 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. */
c->u->u_scope_type == COMPILER_SCOPE_CLASS) {
return check_ann_expr(c, s->v.AnnAssign.annotation);
}
- return 1;
+ return SUCCESS;
}
static int
/* 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);
}
switch (targ->kind) {
case Name_kind:
- if (forbidden_name(c, loc, targ->v.Name.id, Store))
- return 0;
+ if (forbidden_name(c, loc, targ->v.Name.id, Store)) {
+ 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 ||
}
break;
case Attribute_kind:
- if (forbidden_name(c, loc, targ->v.Attribute.attr, Store))
- return 0;
+ if (forbidden_name(c, loc, targ->v.Attribute.attr, Store)) {
+ return ERROR;
+ }
if (!s->v.AnnAssign.value &&
- !check_ann_expr(c, targ->v.Attribute.value)) {
- return 0;
+ 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))) {
- return 0;
+ (check_ann_expr(c, targ->v.Subscript.value) < 0 ||
+ check_ann_subscr(c, targ->v.Subscript.slice) < 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;
+ if (!s->v.AnnAssign.simple && check_annotation(c, s) < 0) {
+ return ERROR;
}
- return 1;
+ return SUCCESS;
}
/* Raises a SyntaxError and returns 0.
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) {
exit:
Py_DECREF(loc_obj);
Py_XDECREF(args);
- return 0;
+ return ERROR;
}
/* Emits a SyntaxWarning and returns 1 on success.
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)
compiler_error(c, loc, PyUnicode_AsUTF8(msg));
}
Py_DECREF(msg);
- return 0;
+ return ERROR;
}
Py_DECREF(msg);
- return 1;
+ return SUCCESS;
}
static int
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);
if (is_two_element_slice(e->v.Subscript.slice) && ctx != Del) {
- if (!compiler_slice(c, e->v.Subscript.slice)) {
- return 0;
- }
+ RETURN_IF_ERROR(compiler_slice(c, e->v.Subscript.slice));
if (ctx == Load) {
ADDOP(c, loc, BINARY_SLICE);
}
assert(op);
ADDOP(c, loc, op);
}
- return 1;
+ return SUCCESS;
}
/* 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)
{
{
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.
// 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));
+ RETURN_IF_ERROR(ensure_fail_pop(c, pc, pops));
ADDOP_JUMP(c, loc, op, pc->fail_pop[pops]);
- return 1;
+ return SUCCESS;
}
// Build all of the fail_pop blocks and reset fail_pop.
{
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]);
- 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;
- 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
while (1 < count) {
ADDOP_I(c, loc, SWAP, count--);
}
- return 1;
+ return SUCCESS;
}
static int
{
if (n == NULL) {
ADDOP(c, loc, POP_TOP);
- return 1;
+ 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_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;
- RETURN_IF_FALSE(pattern_helper_rotate(c, loc, rotations));
- return !PyList_Append(pc->stores, n);
+ RETURN_IF_ERROR(pattern_helper_rotate(c, loc, rotations));
+ RETURN_IF_ERROR(PyList_Append(pc->stores, n));
+ return SUCCESS;
}
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)))
+ (n-i-1 >= (INT_MAX >> 8))) {
return compiler_error(c, loc,
"too many expressions in "
"star-unpacking sequence pattern");
+ }
ADDOP_I(c, loc, UNPACK_EX, (i + ((n-i-1) << 8)));
seen_star = 1;
}
if (!seen_star) {
ADDOP_I(c, loc, UNPACK_SEQUENCE, n);
}
- return 1;
+ return SUCCESS;
}
static int
asdl_pattern_seq *patterns, Py_ssize_t star,
pattern_context *pc)
{
- RETURN_IF_FALSE(pattern_unpack_helper(c, loc, patterns));
+ 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:
// 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));
+ RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc));
}
- return 1;
+ return SUCCESS;
}
// Like pattern_helper_sequence_unpack, but uses BINARY_SUBSCR instead of
ADDOP_BINARY(c, loc, Sub);
}
ADDOP(c, loc, BINARY_SUBSCR);
- RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
+ 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;
+ return SUCCESS;
}
// Like compiler_pattern, but turn off checks for irrefutability.
{
int allow_irrefutable = pc->allow_irrefutable;
pc->allow_irrefutable = 1;
- RETURN_IF_FALSE(compiler_pattern(c, p, pc));
+ RETURN_IF_ERROR(compiler_pattern(c, p, pc));
pc->allow_irrefutable = allow_irrefutable;
- return 1;
+ return SUCCESS;
}
static int
// 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));
+ RETURN_IF_ERROR(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));
- 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);
- RETURN_IF_FALSE(pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc));
- return 1;
+ RETURN_IF_ERROR(
+ pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc));
+ return SUCCESS;
}
static int
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
return compiler_error(c, LOC(p), e, p->v.MatchClass.cls);
}
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;
- RETURN_IF_FALSE(attr_names = PyTuple_New(nattrs));
+ PyObject *attr_names = PyTuple_New(nattrs);
+ if (attr_names == NULL) {
+ return ERROR;
+ }
Py_ssize_t i;
for (i = 0; i < nattrs; i++) {
PyObject *name = asdl_seq_GET(kwd_attrs, i);
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));
+ 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++) {
ADDOP(c, LOC(p), POP_TOP);
continue;
}
- RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
+ RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc));
}
// Success! Pop the tuple of attributes:
- return 1;
+ return SUCCESS;
}
static int
// 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));
+ 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;
+ 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);
- RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE));
+ 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");
// 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`
compiler_error(c, LOC(p), e);
goto error;
}
- if (!compiler_visit_expr(c, key)) {
+ if (compiler_visit_expr(c, key) < 0) {
goto error;
}
}
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));
+ 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);
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));
+ 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:
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));
+ 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.
}
- return 1;
+ return SUCCESS;
error:
Py_DECREF(seen);
- return 0;
+ return ERROR;
}
static int
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)) ||
- !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!
// 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;
}
}
}
}
assert(control);
- if (!cfg_builder_addop_j(CFG_BUILDER(c), LOC(alt), JUMP, end) ||
- !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;
}
// 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)) ||
- !jump_to_fail_pop(c, LOC(p), pc, JUMP)) {
+ 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;
}
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
// NOTE: Returning macros are safe again.
// Pop the copy of the subject:
ADDOP(c, LOC(p), POP_TOP);
- return 1;
+ 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;
}
// 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));
+ 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);
- RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE));
+ 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);
- RETURN_IF_FALSE(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE));
+ 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--;
ADDOP(c, LOC(p), POP_TOP);
}
else if (star_wildcard) {
- RETURN_IF_FALSE(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_FALSE(pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc));
+ RETURN_IF_ERROR(pattern_helper_sequence_unpack(c, LOC(p), patterns, star, pc));
}
- return 1;
+ return SUCCESS;
}
static int
}
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;
+ RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE));
+ return SUCCESS;
}
static int
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));
- return 1;
+ RETURN_IF_ERROR(jump_to_fail_pop(c, LOC(p), pc, POP_JUMP_IF_FALSE));
+ return SUCCESS;
}
static int
if (i != cases - has_default - 1) {
ADDOP_I(c, LOC(m->pattern), COPY, 1);
}
- RETURN_IF_FALSE(pc->stores = PyList_New(0));
+ pc->stores = PyList_New(0);
+ if (pc->stores == NULL) {
+ return ERROR;
+ }
// Irrefutable cases must be either guarded, last, or both:
pc->allow_irrefutable = m->guard != NULL || i == cases - 1;
pc->fail_pop = NULL;
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;
+ return ERROR;
}
assert(!pc->on_top);
// It's a match! Store all of the captured names (they're on the stack).
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 0;
+ return ERROR;
}
}
Py_DECREF(pc->stores);
// NOTE: Returning macros are safe again.
if (m->guard) {
- RETURN_IF_FALSE(ensure_fail_pop(c, pc, 0));
- RETURN_IF_FALSE(compiler_jump_if(c, LOC(m->pattern), m->guard, pc->fail_pop[0], 0));
+ 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));
}
// Success! Pop the subject off, we're done with it:
if (i != cases - has_default - 1) {
// 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));
+ 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
ADDOP(c, LOC(m->pattern), NOP);
}
if (m->guard) {
- RETURN_IF_FALSE(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);
}
USE_LABEL(c, end);
- return 1;
+ return SUCCESS;
}
static int
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)
{
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;
if (PyErr_Occurred()) {
return -1;
}
- if (!cfg_builder_addop(g, opcode, oparg, loc)) {
+ if (cfg_builder_addop(g, opcode, oparg, loc) < 0) {
return -1;
}
}
return NULL;
}
- if (!compiler_codegen(c, mod)) {
+ if (compiler_codegen(c, mod) < 0) {
goto finally;
}
projects / thirdparty / Python / cpython.git / commitdiff
