static int compiler_visit_stmt(struct compiler *, stmt_ty);
static int compiler_visit_keyword(struct compiler *, keyword_ty);
static int compiler_visit_expr(struct compiler *, expr_ty);
-static int compiler_augassign(struct compiler *, stmt_ty);
+static int codegen_augassign(struct compiler *, stmt_ty);
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 codegen_subscript(struct compiler *, expr_ty);
+static int codegen_slice(struct compiler *, expr_ty);
static bool are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t);
-static int compiler_with(struct compiler *, stmt_ty, int);
-static int compiler_async_with(struct compiler *, stmt_ty, int);
-static int compiler_async_for(struct compiler *, stmt_ty);
-static int compiler_call_simple_kw_helper(struct compiler *c,
- location loc,
- asdl_keyword_seq *keywords,
- Py_ssize_t nkwelts);
-static int compiler_call_helper(struct compiler *c, location loc,
- int n, asdl_expr_seq *args,
- asdl_keyword_seq *keywords);
-static int compiler_try_except(struct compiler *, stmt_ty);
-static int compiler_try_star_except(struct compiler *, stmt_ty);
+static int codegen_with(struct compiler *, stmt_ty, int);
+static int codegen_async_with(struct compiler *, stmt_ty, int);
+static int codegen_async_for(struct compiler *, stmt_ty);
+static int codegen_call_simple_kw_helper(struct compiler *c,
+ location loc,
+ asdl_keyword_seq *keywords,
+ Py_ssize_t nkwelts);
+static int codegen_call_helper(struct compiler *c, location loc,
+ int n, asdl_expr_seq *args,
+ asdl_keyword_seq *keywords);
+static int codegen_try_except(struct compiler *, stmt_ty);
+static int codegen_try_star_except(struct compiler *, stmt_ty);
static int compiler_sync_comprehension_generator(
struct compiler *c, location loc,
expr_ty elt, expr_ty val, int type,
int iter_on_stack);
-static int compiler_pattern(struct compiler *, pattern_ty, pattern_context *);
-static int compiler_match(struct compiler *, stmt_ty);
-static int compiler_pattern_subpattern(struct compiler *,
- pattern_ty, pattern_context *);
-static int compiler_make_closure(struct compiler *c, location loc,
- PyCodeObject *co, Py_ssize_t flags);
+static int codegen_pattern(struct compiler *, pattern_ty, pattern_context *);
+static int codegen_match(struct compiler *, stmt_ty);
+static int codegen_pattern_subpattern(struct compiler *,
+ pattern_ty, pattern_context *);
+static int codegen_make_closure(struct compiler *c, location loc,
+ PyCodeObject *co, Py_ssize_t flags);
static PyCodeObject *optimize_and_assemble(struct compiler *, int addNone);
RETURN_IF_ERROR(codegen_addop_j(INSTR_SEQUENCE(C), (LOC), (OP), (O)))
#define ADDOP_COMPARE(C, LOC, CMP) \
- RETURN_IF_ERROR(compiler_addcompare((C), (LOC), (cmpop_ty)(CMP)))
+ RETURN_IF_ERROR(codegen_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), true))
#define ADD_YIELD_FROM(C, LOC, await) \
- RETURN_IF_ERROR(compiler_add_yield_from((C), (LOC), (await)))
+ RETURN_IF_ERROR(codegen_add_yield_from((C), (LOC), (await)))
#define POP_EXCEPT_AND_RERAISE(C, LOC) \
- RETURN_IF_ERROR(compiler_pop_except_and_reraise((C), (LOC)))
+ RETURN_IF_ERROR(codegen_pop_except_and_reraise((C), (LOC)))
#define ADDOP_YIELD(C, LOC) \
- RETURN_IF_ERROR(addop_yield((C), (LOC)))
+ RETURN_IF_ERROR(codegen_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.
}
static int
-compiler_call_exit_with_nones(struct compiler *c, location loc)
+codegen_call_exit_with_nones(struct compiler *c, location loc)
{
ADDOP_LOAD_CONST(c, loc, Py_None);
ADDOP_LOAD_CONST(c, loc, Py_None);
}
static int
-compiler_add_yield_from(struct compiler *c, location loc, int await)
+codegen_add_yield_from(struct compiler *c, location loc, int await)
{
NEW_JUMP_TARGET_LABEL(c, send);
NEW_JUMP_TARGET_LABEL(c, fail);
}
static int
-compiler_pop_except_and_reraise(struct compiler *c, location loc)
+codegen_pop_except_and_reraise(struct compiler *c, location loc)
{
/* Stack contents
* [exc_info, lasti, exc] COPY 3
ADDOP_I(c, *ploc, SWAP, 3);
ADDOP_I(c, *ploc, SWAP, 2);
}
- RETURN_IF_ERROR(compiler_call_exit_with_nones(c, *ploc));
+ RETURN_IF_ERROR(codegen_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);
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
Py_DECREF(co);
return ERROR;
}
}
static int
-compiler_enter_anonymous_scope(struct compiler* c, mod_ty mod)
+codegen_enter_anonymous_scope(struct compiler* c, mod_ty mod)
{
_Py_DECLARE_STR(anon_module, "<module>");
RETURN_IF_ERROR(
{
PyCodeObject *co = NULL;
int addNone = mod->kind != Expression_kind;
- if (compiler_enter_anonymous_scope(c, mod) < 0) {
+ if (codegen_enter_anonymous_scope(c, mod) < 0) {
return NULL;
}
if (compiler_codegen(c, mod) < 0) {
}
static int
-compiler_make_closure(struct compiler *c, location loc,
- PyCodeObject *co, Py_ssize_t flags)
+codegen_make_closure(struct compiler *c, location loc,
+ PyCodeObject *co, Py_ssize_t flags)
{
if (co->co_nfreevars) {
int i = PyUnstable_Code_GetFirstFree(co);
}
static int
-compiler_decorators(struct compiler *c, asdl_expr_seq* decos)
+codegen_decorators(struct compiler *c, asdl_expr_seq* decos)
{
if (!decos) {
return SUCCESS;
}
static int
-compiler_apply_decorators(struct compiler *c, asdl_expr_seq* decos)
+codegen_apply_decorators(struct compiler *c, asdl_expr_seq* decos)
{
if (!decos) {
return SUCCESS;
}
static int
-compiler_kwonlydefaults(struct compiler *c, location loc,
- asdl_arg_seq *kwonlyargs, asdl_expr_seq *kw_defaults)
+codegen_kwonlydefaults(struct compiler *c, location loc,
+ asdl_arg_seq *kwonlyargs, asdl_expr_seq *kw_defaults)
{
/* Push a dict of keyword-only default values.
}
static int
-compiler_defaults(struct compiler *c, arguments_ty args,
+codegen_defaults(struct compiler *c, arguments_ty args,
location loc)
{
VISIT_SEQ(c, expr, args->defaults);
}
static Py_ssize_t
-compiler_default_arguments(struct compiler *c, location loc,
- arguments_ty args)
+codegen_default_arguments(struct compiler *c, location loc,
+ arguments_ty args)
{
Py_ssize_t funcflags = 0;
if (args->defaults && asdl_seq_LEN(args->defaults) > 0) {
- RETURN_IF_ERROR(compiler_defaults(c, args, loc));
+ RETURN_IF_ERROR(codegen_defaults(c, args, loc));
funcflags |= MAKE_FUNCTION_DEFAULTS;
}
if (args->kwonlyargs) {
- int res = compiler_kwonlydefaults(c, loc,
- args->kwonlyargs,
- args->kw_defaults);
+ int res = codegen_kwonlydefaults(c, loc,
+ args->kwonlyargs,
+ args->kw_defaults);
RETURN_IF_ERROR(res);
if (res > 0) {
funcflags |= MAKE_FUNCTION_KWDEFAULTS;
}
static int
-wrap_in_stopiteration_handler(struct compiler *c)
+codegen_wrap_in_stopiteration_handler(struct compiler *c)
{
NEW_JUMP_TARGET_LABEL(c, handler);
}
static int
-compiler_type_param_bound_or_default(struct compiler *c, expr_ty e,
- identifier name, void *key,
- bool allow_starred)
+codegen_type_param_bound_or_default(struct compiler *c, expr_ty e,
+ identifier name, void *key,
+ bool allow_starred)
{
PyObject *defaults = PyTuple_Pack(1, _PyLong_GetOne());
ADDOP_LOAD_CONST_NEW(c, LOC(e), defaults);
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, LOC(e), co, MAKE_FUNCTION_DEFAULTS) < 0) {
+ if (codegen_make_closure(c, LOC(e), co, MAKE_FUNCTION_DEFAULTS) < 0) {
Py_DECREF(co);
return ERROR;
}
}
static int
-compiler_type_params(struct compiler *c, asdl_type_param_seq *type_params)
+codegen_type_params(struct compiler *c, asdl_type_param_seq *type_params)
{
if (!type_params) {
return SUCCESS;
ADDOP_LOAD_CONST(c, loc, typeparam->v.TypeVar.name);
if (typeparam->v.TypeVar.bound) {
expr_ty bound = typeparam->v.TypeVar.bound;
- if (compiler_type_param_bound_or_default(c, bound, typeparam->v.TypeVar.name,
- (void *)typeparam, false) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(
+ codegen_type_param_bound_or_default(c, bound, typeparam->v.TypeVar.name,
+ (void *)typeparam, false));
int intrinsic = bound->kind == Tuple_kind
? INTRINSIC_TYPEVAR_WITH_CONSTRAINTS
if (typeparam->v.TypeVar.default_value) {
seen_default = true;
expr_ty default_ = typeparam->v.TypeVar.default_value;
- if (compiler_type_param_bound_or_default(c, default_, typeparam->v.TypeVar.name,
- (void *)((uintptr_t)typeparam + 1), false) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(
+ codegen_type_param_bound_or_default(c, default_, typeparam->v.TypeVar.name,
+ (void *)((uintptr_t)typeparam + 1), false));
ADDOP_I(c, loc, CALL_INTRINSIC_2, INTRINSIC_SET_TYPEPARAM_DEFAULT);
}
else if (seen_default) {
ADDOP_I(c, loc, CALL_INTRINSIC_1, INTRINSIC_TYPEVARTUPLE);
if (typeparam->v.TypeVarTuple.default_value) {
expr_ty default_ = typeparam->v.TypeVarTuple.default_value;
- if (compiler_type_param_bound_or_default(c, default_, typeparam->v.TypeVarTuple.name,
- (void *)typeparam, true) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(
+ codegen_type_param_bound_or_default(c, default_, typeparam->v.TypeVarTuple.name,
+ (void *)typeparam, true));
ADDOP_I(c, loc, CALL_INTRINSIC_2, INTRINSIC_SET_TYPEPARAM_DEFAULT);
seen_default = true;
}
ADDOP_I(c, loc, CALL_INTRINSIC_1, INTRINSIC_PARAMSPEC);
if (typeparam->v.ParamSpec.default_value) {
expr_ty default_ = typeparam->v.ParamSpec.default_value;
- if (compiler_type_param_bound_or_default(c, default_, typeparam->v.ParamSpec.name,
- (void *)typeparam, false) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(
+ codegen_type_param_bound_or_default(c, default_, typeparam->v.ParamSpec.name,
+ (void *)typeparam, false));
ADDOP_I(c, loc, CALL_INTRINSIC_2, INTRINSIC_SET_TYPEPARAM_DEFAULT);
seen_default = true;
}
docstring = NULL;
}
}
- if (compiler_add_const(c, docstring ? docstring : Py_None) < 0) {
- Py_XDECREF(docstring);
- compiler_exit_scope(c);
- return ERROR;
- }
- Py_CLEAR(docstring);
+ Py_ssize_t idx = compiler_add_const(c, docstring ? docstring : Py_None);
+ Py_XDECREF(docstring);
+ RETURN_IF_ERROR_IN_SCOPE(c, idx < 0 ? ERROR : SUCCESS);
assert(c->u->u_metadata.u_argcount == asdl_seq_LEN(args->args));
assert(c->u->u_metadata.u_posonlyargcount == asdl_seq_LEN(args->posonlyargs));
PySTEntryObject *ste = SYMTABLE_ENTRY(c);
bool add_stopiteration_handler = ste->ste_coroutine || ste->ste_generator;
if (add_stopiteration_handler) {
- /* wrap_in_stopiteration_handler will push a block, so we need to account for that */
+ /* codegen_wrap_in_stopiteration_handler will push a block, so we need to account for that */
RETURN_IF_ERROR(
compiler_push_fblock(c, NO_LOCATION, STOP_ITERATION,
start, NO_LABEL, NULL));
VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i));
}
if (add_stopiteration_handler) {
- if (wrap_in_stopiteration_handler(c) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_wrap_in_stopiteration_handler(c));
compiler_pop_fblock(c, STOP_ITERATION, start);
}
PyCodeObject *co = optimize_and_assemble(c, 1);
Py_XDECREF(co);
return ERROR;
}
- location loc = LOC(s);
- if (compiler_make_closure(c, loc, co, funcflags) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, LOC(s), co, funcflags);
Py_DECREF(co);
- return SUCCESS;
+ return ret;
}
static int
type_params = s->v.FunctionDef.type_params;
}
- RETURN_IF_ERROR(compiler_decorators(c, decos));
+ RETURN_IF_ERROR(codegen_decorators(c, decos));
firstlineno = s->lineno;
if (asdl_seq_LEN(decos)) {
int is_generic = asdl_seq_LEN(type_params) > 0;
- funcflags = compiler_default_arguments(c, loc, args);
+ funcflags = codegen_default_arguments(c, loc, args);
if (funcflags == -1) {
return ERROR;
}
return ERROR;
}
Py_DECREF(type_params_name);
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_type_params(c, type_params));
for (int i = 0; i < num_typeparam_args; i++) {
ADDOP_I_IN_SCOPE(c, loc, LOAD_FAST, i);
}
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
Py_DECREF(co);
return ERROR;
}
}
}
- RETURN_IF_ERROR(compiler_apply_decorators(c, decos));
+ RETURN_IF_ERROR(codegen_apply_decorators(c, decos));
return compiler_nameop(c, loc, name, Store);
}
static int
-compiler_set_type_params_in_class(struct compiler *c, location loc)
+codegen_set_type_params_in_class(struct compiler *c, location loc)
{
_Py_DECLARE_STR(type_params, ".type_params");
RETURN_IF_ERROR(compiler_nameop(c, loc, &_Py_STR(type_params), Load));
RETURN_IF_ERROR(compiler_nameop(c, loc, &_Py_ID(__type_params__), Store));
- return 1;
+ return SUCCESS;
}
static int
<name> is the class name
<bases> is the positional arguments and *varargs argument
<keywords> is the keyword arguments and **kwds argument
- This borrows from compiler_call.
+ This borrows from codegen_call.
*/
/* 1. compile the class body into a code object */
location loc = LOCATION(firstlineno, firstlineno, 0, 0);
/* load (global) __name__ ... */
- if (compiler_nameop(c, loc, &_Py_ID(__name__), Load) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__name__), Load));
/* ... and store it as __module__ */
- if (compiler_nameop(c, loc, &_Py_ID(__module__), Store) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__module__), Store));
assert(c->u->u_metadata.u_qualname);
ADDOP_LOAD_CONST(c, loc, c->u->u_metadata.u_qualname);
- if (compiler_nameop(c, loc, &_Py_ID(__qualname__), Store) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__qualname__), Store));
ADDOP_LOAD_CONST_NEW(c, loc, PyLong_FromLong(c->u->u_metadata.u_firstlineno));
- if (compiler_nameop(c, loc, &_Py_ID(__firstlineno__), Store) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__firstlineno__), Store));
asdl_type_param_seq *type_params = s->v.ClassDef.type_params;
if (asdl_seq_LEN(type_params) > 0) {
- if (!compiler_set_type_params_in_class(c, loc)) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_set_type_params_in_class(c, loc));
}
if (SYMTABLE_ENTRY(c)->ste_needs_classdict) {
ADDOP(c, loc, LOAD_LOCALS);
ADDOP_N_IN_SCOPE(c, loc, STORE_DEREF, &_Py_ID(__classdict__), cellvars);
}
/* compile the body proper */
- if (compiler_body(c, loc, s->v.ClassDef.body) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, compiler_body(c, loc, s->v.ClassDef.body));
assert(c->u->u_static_attributes);
PyObject *static_attributes = PySequence_Tuple(c->u->u_static_attributes);
if (static_attributes == NULL) {
}
ADDOP_LOAD_CONST(c, NO_LOCATION, static_attributes);
Py_CLEAR(static_attributes);
- if (compiler_nameop(c, NO_LOCATION, &_Py_ID(__static_attributes__), Store) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(
+ c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__static_attributes__), Store));
/* The following code is artificial */
/* Set __classdictcell__ if necessary */
if (SYMTABLE_ENTRY(c)->ste_needs_classdict) {
/* Store __classdictcell__ into class namespace */
int i = dict_lookup_arg(c->u->u_metadata.u_cellvars, &_Py_ID(__classdict__));
- if (i < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, i);
ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i);
- if (compiler_nameop(c, NO_LOCATION, &_Py_ID(__classdictcell__), Store) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(
+ c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__classdictcell__), Store));
}
/* Return __classcell__ if it is referenced, otherwise return None */
if (SYMTABLE_ENTRY(c)->ste_needs_class_closure) {
/* Store __classcell__ into class namespace & return it */
int i = dict_lookup_arg(c->u->u_metadata.u_cellvars, &_Py_ID(__class__));
- if (i < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(c, i);
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) < 0) {
- compiler_exit_scope(c);
- return ERROR;
- }
+ RETURN_IF_ERROR_IN_SCOPE(
+ c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store));
}
else {
/* No methods referenced __class__, so just return None */
ADDOP(c, loc, PUSH_NULL);
/* 3. load a function (or closure) made from the code object */
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
Py_DECREF(co);
return ERROR;
}
}
static int
-compiler_class(struct compiler *c, stmt_ty s)
+codegen_class(struct compiler *c, stmt_ty s)
{
asdl_expr_seq *decos = s->v.ClassDef.decorator_list;
- RETURN_IF_ERROR(compiler_decorators(c, decos));
+ RETURN_IF_ERROR(codegen_decorators(c, decos));
int firstlineno = s->lineno;
if (asdl_seq_LEN(decos)) {
return ERROR;
}
Py_DECREF(type_params_name);
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_type_params(c, type_params));
_Py_DECLARE_STR(type_params, ".type_params");
RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_STR(type_params), Store));
}
return ERROR;
}
asdl_seq_SET(bases, original_len, name_node);
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_call_helper(c, loc, 2,
- bases,
- s->v.ClassDef.keywords));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_call_helper(c, loc, 2,
+ bases,
+ s->v.ClassDef.keywords));
PyCodeObject *co = optimize_and_assemble(c, 0);
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
Py_DECREF(co);
return ERROR;
}
ADDOP(c, loc, PUSH_NULL);
ADDOP_I(c, loc, CALL, 0);
} else {
- RETURN_IF_ERROR(compiler_call_helper(c, loc, 2,
+ RETURN_IF_ERROR(codegen_call_helper(c, loc, 2,
s->v.ClassDef.bases,
s->v.ClassDef.keywords));
}
/* 6. apply decorators */
- RETURN_IF_ERROR(compiler_apply_decorators(c, decos));
+ RETURN_IF_ERROR(codegen_apply_decorators(c, decos));
/* 7. store into <name> */
RETURN_IF_ERROR(compiler_nameop(c, loc, s->v.ClassDef.name, Store));
}
static int
-compiler_typealias_body(struct compiler *c, stmt_ty s)
+codegen_typealias_body(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
PyObject *name = s->v.TypeAlias.name->v.Name.id;
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, loc, co, MAKE_FUNCTION_DEFAULTS) < 0) {
+ if (codegen_make_closure(c, loc, co, MAKE_FUNCTION_DEFAULTS) < 0) {
Py_DECREF(co);
return ERROR;
}
}
static int
-compiler_typealias(struct compiler *c, stmt_ty s)
+codegen_typealias(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
asdl_type_param_seq *type_params = s->v.TypeAlias.type_params;
}
Py_DECREF(type_params_name);
ADDOP_LOAD_CONST_IN_SCOPE(c, loc, name);
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_type_params(c, type_params));
}
else {
ADDOP_LOAD_CONST(c, loc, name);
ADDOP_LOAD_CONST(c, loc, Py_None);
}
- if (compiler_typealias_body(c, s) < 0) {
+ if (codegen_typealias_body(c, s) < 0) {
if (is_generic) {
compiler_exit_scope(c);
}
if (co == NULL) {
return ERROR;
}
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
Py_DECREF(co);
return ERROR;
}
Emit a warning if any operand is a constant except named singletons.
*/
static int
-check_compare(struct compiler *c, expr_ty e)
+codegen_check_compare(struct compiler *c, expr_ty e)
{
Py_ssize_t i, n;
bool left = check_is_arg(e->v.Compare.left);
}
static int
-compiler_addcompare(struct compiler *c, location loc, cmpop_ty op)
+codegen_addcompare(struct compiler *c, location loc, cmpop_ty op)
{
int cmp;
switch (op) {
return SUCCESS;
}
-
-
static int
-compiler_jump_if(struct compiler *c, location loc,
- expr_ty e, jump_target_label next, int cond)
+codegen_jump_if(struct compiler *c, location loc,
+ expr_ty e, jump_target_label next, int cond)
{
switch (e->kind) {
case UnaryOp_kind:
if (e->v.UnaryOp.op == Not) {
- return compiler_jump_if(c, loc, e->v.UnaryOp.operand, next, !cond);
+ return codegen_jump_if(c, loc, e->v.UnaryOp.operand, next, !cond);
}
/* fallback to general implementation */
break;
}
for (i = 0; i < n; ++i) {
RETURN_IF_ERROR(
- compiler_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, i), next2, cond2));
+ codegen_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));
+ codegen_jump_if(c, loc, (expr_ty)asdl_seq_GET(s, n), next, cond));
if (!SAME_LABEL(next2, next)) {
USE_LABEL(c, next2);
}
NEW_JUMP_TARGET_LABEL(c, end);
NEW_JUMP_TARGET_LABEL(c, next2);
RETURN_IF_ERROR(
- compiler_jump_if(c, loc, e->v.IfExp.test, next2, 0));
+ codegen_jump_if(c, loc, e->v.IfExp.test, next2, 0));
RETURN_IF_ERROR(
- compiler_jump_if(c, loc, e->v.IfExp.body, next, cond));
+ codegen_jump_if(c, loc, e->v.IfExp.body, next, cond));
ADDOP_JUMP(c, NO_LOCATION, JUMP_NO_INTERRUPT, end);
USE_LABEL(c, next2);
RETURN_IF_ERROR(
- compiler_jump_if(c, loc, e->v.IfExp.orelse, next, cond));
+ codegen_jump_if(c, loc, e->v.IfExp.orelse, next, cond));
USE_LABEL(c, end);
return SUCCESS;
case Compare_kind: {
Py_ssize_t n = asdl_seq_LEN(e->v.Compare.ops) - 1;
if (n > 0) {
- RETURN_IF_ERROR(check_compare(c, e));
+ RETURN_IF_ERROR(codegen_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++) {
}
static int
-compiler_ifexp(struct compiler *c, expr_ty e)
+codegen_ifexp(struct compiler *c, expr_ty e)
{
assert(e->kind == IfExp_kind);
NEW_JUMP_TARGET_LABEL(c, end);
NEW_JUMP_TARGET_LABEL(c, next);
RETURN_IF_ERROR(
- compiler_jump_if(c, LOC(e), e->v.IfExp.test, next, 0));
+ codegen_jump_if(c, LOC(e), e->v.IfExp.test, next, 0));
VISIT(c, expr, e->v.IfExp.body);
ADDOP_JUMP(c, NO_LOCATION, JUMP_NO_INTERRUPT, end);
}
static int
-compiler_lambda(struct compiler *c, expr_ty e)
+codegen_lambda(struct compiler *c, expr_ty e)
{
PyCodeObject *co;
Py_ssize_t funcflags;
assert(e->kind == Lambda_kind);
location loc = LOC(e);
- funcflags = compiler_default_arguments(c, loc, args);
+ funcflags = codegen_default_arguments(c, loc, args);
if (funcflags == -1) {
return ERROR;
}
return ERROR;
}
- if (compiler_make_closure(c, loc, co, funcflags) < 0) {
+ if (codegen_make_closure(c, loc, co, funcflags) < 0) {
Py_DECREF(co);
return ERROR;
}
}
static int
-compiler_if(struct compiler *c, stmt_ty s)
+codegen_if(struct compiler *c, stmt_ty s)
{
jump_target_label next;
assert(s->kind == If_kind);
next = end;
}
RETURN_IF_ERROR(
- compiler_jump_if(c, LOC(s), s->v.If.test, next, 0));
+ codegen_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)) {
}
static int
-compiler_for(struct compiler *c, stmt_ty s)
+codegen_for(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
NEW_JUMP_TARGET_LABEL(c, start);
static int
-compiler_async_for(struct compiler *c, stmt_ty s)
+codegen_async_for(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
}
static int
-compiler_while(struct compiler *c, stmt_ty s)
+codegen_while(struct compiler *c, stmt_ty s)
{
NEW_JUMP_TARGET_LABEL(c, loop);
NEW_JUMP_TARGET_LABEL(c, end);
USE_LABEL(c, loop);
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));
+ RETURN_IF_ERROR(codegen_jump_if(c, LOC(s), s->v.While.test, anchor, 0));
VISIT_SEQ(c, stmt, s->v.While.body);
ADDOP_JUMP(c, NO_LOCATION, JUMP, loop);
}
static int
-compiler_return(struct compiler *c, stmt_ty s)
+codegen_return(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
int preserve_tos = ((s->v.Return.value != NULL) &&
}
static int
-compiler_break(struct compiler *c, location loc)
+codegen_break(struct compiler *c, location loc)
{
struct fblockinfo *loop = NULL;
location origin_loc = loc;
}
static int
-compiler_continue(struct compiler *c, location loc)
+codegen_continue(struct compiler *c, location loc)
{
struct fblockinfo *loop = NULL;
location origin_loc = loc;
*/
static int
-compiler_try_finally(struct compiler *c, stmt_ty s)
+codegen_try_finally(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
s->v.Try.finalbody));
if (s->v.Try.handlers && asdl_seq_LEN(s->v.Try.handlers)) {
- RETURN_IF_ERROR(compiler_try_except(c, s));
+ RETURN_IF_ERROR(codegen_try_except(c, s));
}
else {
VISIT_SEQ(c, stmt, s->v.Try.body);
}
static int
-compiler_try_star_finally(struct compiler *c, stmt_ty s)
+codegen_try_star_finally(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
s->v.TryStar.finalbody));
if (s->v.TryStar.handlers && asdl_seq_LEN(s->v.TryStar.handlers)) {
- RETURN_IF_ERROR(compiler_try_star_except(c, s));
+ RETURN_IF_ERROR(codegen_try_star_except(c, s));
}
else {
VISIT_SEQ(c, stmt, s->v.TryStar.body);
Of course, parts are not generated if Vi or Ei is not present.
*/
static int
-compiler_try_except(struct compiler *c, stmt_ty s)
+codegen_try_except(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
Py_ssize_t i, n;
[] L0: <next statement>
*/
static int
-compiler_try_star_except(struct compiler *c, stmt_ty s)
+codegen_try_star_except(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
}
static int
-compiler_try(struct compiler *c, stmt_ty s) {
+codegen_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 codegen_try_finally(c, s);
else
- return compiler_try_except(c, s);
+ return codegen_try_except(c, s);
}
static int
-compiler_try_star(struct compiler *c, stmt_ty s)
+codegen_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 codegen_try_star_finally(c, s);
}
else {
- return compiler_try_star_except(c, s);
+ return codegen_try_star_except(c, s);
}
}
static int
-compiler_import_as(struct compiler *c, location loc,
- identifier name, identifier asname)
+codegen_import_as(struct compiler *c, location loc,
+ identifier name, identifier asname)
{
/* The IMPORT_NAME opcode was already generated. This function
merely needs to bind the result to a name.
}
static int
-compiler_import(struct compiler *c, stmt_ty s)
+codegen_import(struct compiler *c, stmt_ty s)
{
location loc = LOC(s);
/* The Import node stores a module name like a.b.c as a single
ADDOP_NAME(c, loc, IMPORT_NAME, alias->name, names);
if (alias->asname) {
- r = compiler_import_as(c, loc, alias->name, alias->asname);
+ r = codegen_import_as(c, loc, alias->name, alias->asname);
RETURN_IF_ERROR(r);
}
else {
}
static int
-compiler_from_import(struct compiler *c, stmt_ty s)
+codegen_from_import(struct compiler *c, stmt_ty s)
{
Py_ssize_t n = asdl_seq_LEN(s->v.ImportFrom.names);
return SUCCESS;
}
NEW_JUMP_TARGET_LABEL(c, end);
- RETURN_IF_ERROR(compiler_jump_if(c, LOC(s), s->v.Assert.test, end, 1));
+ RETURN_IF_ERROR(codegen_jump_if(c, LOC(s), s->v.Assert.test, end, 1));
ADDOP_I(c, LOC(s), LOAD_COMMON_CONSTANT, CONSTANT_ASSERTIONERROR);
if (s->v.Assert.msg) {
VISIT(c, expr, s->v.Assert.msg);
case FunctionDef_kind:
return codegen_function(c, s, 0);
case ClassDef_kind:
- return compiler_class(c, s);
+ return codegen_class(c, s);
case TypeAlias_kind:
- return compiler_typealias(c, s);
+ return codegen_typealias(c, s);
case Return_kind:
- return compiler_return(c, s);
+ return codegen_return(c, s);
case Delete_kind:
VISIT_SEQ(c, expr, s->v.Delete.targets)
break;
break;
}
case AugAssign_kind:
- return compiler_augassign(c, s);
+ return codegen_augassign(c, s);
case AnnAssign_kind:
return compiler_annassign(c, s);
case For_kind:
- return compiler_for(c, s);
+ return codegen_for(c, s);
case While_kind:
- return compiler_while(c, s);
+ return codegen_while(c, s);
case If_kind:
- return compiler_if(c, s);
+ return codegen_if(c, s);
case Match_kind:
- return compiler_match(c, s);
+ return codegen_match(c, s);
case Raise_kind:
{
Py_ssize_t n = 0;
break;
}
case Try_kind:
- return compiler_try(c, s);
+ return codegen_try(c, s);
case TryStar_kind:
- return compiler_try_star(c, s);
+ return codegen_try_star(c, s);
case Assert_kind:
return compiler_assert(c, s);
case Import_kind:
- return compiler_import(c, s);
+ return codegen_import(c, s);
case ImportFrom_kind:
- return compiler_from_import(c, s);
+ return codegen_from_import(c, s);
case Global_kind:
case Nonlocal_kind:
break;
}
case Break_kind:
{
- return compiler_break(c, LOC(s));
+ return codegen_break(c, LOC(s));
}
case Continue_kind:
{
- return compiler_continue(c, LOC(s));
+ return codegen_continue(c, LOC(s));
}
case With_kind:
- return compiler_with(c, s, 0);
+ return codegen_with(c, s, 0);
case AsyncFunctionDef_kind:
return codegen_function(c, s, 1);
case AsyncWith_kind:
- return compiler_async_with(c, s, 0);
+ return codegen_async_with(c, s, 0);
case AsyncFor_kind:
- return compiler_async_for(c, s);
+ return codegen_async_for(c, s);
}
return SUCCESS;
static int
-addop_yield(struct compiler *c, location loc) {
+codegen_addop_yield(struct compiler *c, location loc) {
PySTEntryObject *ste = SYMTABLE_ENTRY(c);
if (ste->ste_generator && ste->ste_coroutine) {
ADDOP_I(c, loc, CALL_INTRINSIC_1, INTRINSIC_ASYNC_GEN_WRAP);
}
static int
-compiler_load_classdict_freevar(struct compiler *c, location loc)
+codegen_load_classdict_freevar(struct compiler *c, location loc)
{
ADDOP_N(c, loc, LOAD_DEREF, &_Py_ID(__classdict__), freevars);
return SUCCESS;
else if (SYMTABLE_ENTRY(c)->ste_can_see_class_scope) {
op = LOAD_FROM_DICT_OR_DEREF;
// First load the classdict
- if (compiler_load_classdict_freevar(c, loc) < 0) {
+ if (codegen_load_classdict_freevar(c, loc) < 0) {
goto error;
}
}
if (SYMTABLE_ENTRY(c)->ste_can_see_class_scope && scope == GLOBAL_IMPLICIT) {
op = LOAD_FROM_DICT_OR_GLOBALS;
// First load the classdict
- if (compiler_load_classdict_freevar(c, loc) < 0) {
+ if (codegen_load_classdict_freevar(c, loc) < 0) {
goto error;
}
} else {
}
static int
-compiler_boolop(struct compiler *c, expr_ty e)
+codegen_boolop(struct compiler *c, expr_ty e)
{
int jumpi;
Py_ssize_t i, n;
}
static int
-compiler_list(struct compiler *c, expr_ty e)
+codegen_list(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
asdl_expr_seq *elts = e->v.List.elts;
}
static int
-compiler_tuple(struct compiler *c, expr_ty e)
+codegen_tuple(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
asdl_expr_seq *elts = e->v.Tuple.elts;
}
static int
-compiler_set(struct compiler *c, expr_ty e)
+codegen_set(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
return starunpack_helper(c, loc, e->v.Set.elts, 0,
}
static int
-compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end)
+codegen_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end)
{
Py_ssize_t i, n = end - begin;
int big = n*2 > STACK_USE_GUIDELINE;
}
static int
-compiler_dict(struct compiler *c, expr_ty e)
+codegen_dict(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
Py_ssize_t i, n, elements;
is_unpacking = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i) == NULL;
if (is_unpacking) {
if (elements) {
- RETURN_IF_ERROR(compiler_subdict(c, e, i - elements, i));
+ RETURN_IF_ERROR(codegen_subdict(c, e, i - elements, i));
if (have_dict) {
ADDOP_I(c, loc, DICT_UPDATE, 1);
}
}
else {
if (elements*2 > STACK_USE_GUIDELINE) {
- RETURN_IF_ERROR(compiler_subdict(c, e, i - elements, i + 1));
+ RETURN_IF_ERROR(codegen_subdict(c, e, i - elements, i + 1));
if (have_dict) {
ADDOP_I(c, loc, DICT_UPDATE, 1);
}
}
}
if (elements) {
- RETURN_IF_ERROR(compiler_subdict(c, e, n - elements, n));
+ RETURN_IF_ERROR(codegen_subdict(c, e, n - elements, n));
if (have_dict) {
ADDOP_I(c, loc, DICT_UPDATE, 1);
}
}
static int
-compiler_compare(struct compiler *c, expr_ty e)
+codegen_compare(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
Py_ssize_t i, n;
- RETURN_IF_ERROR(check_compare(c, e));
+ RETURN_IF_ERROR(codegen_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;
if (kwdsl) {
VISIT_SEQ(c, keyword, kwds);
RETURN_IF_ERROR(
- compiler_call_simple_kw_helper(c, loc, kwds, kwdsl));
+ codegen_call_simple_kw_helper(c, loc, kwds, kwdsl));
loc = update_start_location_to_match_attr(c, LOC(e), meth);
ADDOP_I(c, loc, CALL_KW, argsl + kwdsl);
}
}
static int
-validate_keywords(struct compiler *c, asdl_keyword_seq *keywords)
+codegen_validate_keywords(struct compiler *c, asdl_keyword_seq *keywords)
{
Py_ssize_t nkeywords = asdl_seq_LEN(keywords);
for (Py_ssize_t i = 0; i < nkeywords; i++) {
}
static int
-compiler_call(struct compiler *c, expr_ty e)
+codegen_call(struct compiler *c, expr_ty e)
{
- RETURN_IF_ERROR(validate_keywords(c, e->v.Call.keywords));
+ RETURN_IF_ERROR(codegen_validate_keywords(c, e->v.Call.keywords));
int ret = maybe_optimize_method_call(c, e);
if (ret < 0) {
return ERROR;
location loc = LOC(e->v.Call.func);
ADDOP(c, loc, PUSH_NULL);
loc = LOC(e);
- return compiler_call_helper(c, loc, 0,
- e->v.Call.args,
- e->v.Call.keywords);
+ return codegen_call_helper(c, loc, 0,
+ e->v.Call.args,
+ e->v.Call.keywords);
}
static int
-compiler_joined_str(struct compiler *c, expr_ty e)
+codegen_joined_str(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
Py_ssize_t value_count = asdl_seq_LEN(e->v.JoinedStr.values);
/* Used to implement f-strings. Format a single value. */
static int
-compiler_formatted_value(struct compiler *c, expr_ty e)
+codegen_formatted_value(struct compiler *c, expr_ty e)
{
/* Our oparg encodes 2 pieces of information: the conversion
character, and whether or not a format_spec was provided.
}
static int
-compiler_subkwargs(struct compiler *c, location loc,
- asdl_keyword_seq *keywords,
- Py_ssize_t begin, Py_ssize_t end)
+codegen_subkwargs(struct compiler *c, location loc,
+ asdl_keyword_seq *keywords,
+ Py_ssize_t begin, Py_ssize_t end)
{
Py_ssize_t i, n = end - begin;
keyword_ty kw;
return SUCCESS;
}
-/* Used by compiler_call_helper and maybe_optimize_method_call to emit
+/* Used by codegen_call_helper and maybe_optimize_method_call to emit
* a tuple of keyword names before CALL.
*/
static int
-compiler_call_simple_kw_helper(struct compiler *c, location loc,
- asdl_keyword_seq *keywords, Py_ssize_t nkwelts)
+codegen_call_simple_kw_helper(struct compiler *c, location loc,
+ asdl_keyword_seq *keywords, Py_ssize_t nkwelts)
{
PyObject *names;
names = PyTuple_New(nkwelts);
}
-/* shared code between compiler_call and compiler_class */
+/* shared code between codegen_call and codegen_class */
static int
-compiler_call_helper(struct compiler *c, location loc,
- int n, /* Args already pushed */
- asdl_expr_seq *args,
- asdl_keyword_seq *keywords)
+codegen_call_helper(struct compiler *c, location loc,
+ int n, /* Args already pushed */
+ asdl_expr_seq *args,
+ asdl_keyword_seq *keywords)
{
Py_ssize_t i, nseen, nelts, nkwelts;
- RETURN_IF_ERROR(validate_keywords(c, keywords));
+ RETURN_IF_ERROR(codegen_validate_keywords(c, keywords));
nelts = asdl_seq_LEN(args);
nkwelts = asdl_seq_LEN(keywords);
if (nkwelts) {
VISIT_SEQ(c, keyword, keywords);
RETURN_IF_ERROR(
- compiler_call_simple_kw_helper(c, loc, keywords, nkwelts));
+ codegen_call_simple_kw_helper(c, loc, keywords, nkwelts));
ADDOP_I(c, loc, CALL_KW, n + nelts + nkwelts);
}
else {
if (kw->arg == NULL) {
/* A keyword argument unpacking. */
if (nseen) {
- RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, i - nseen, i));
+ RETURN_IF_ERROR(codegen_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. */
- RETURN_IF_ERROR(compiler_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts));
+ RETURN_IF_ERROR(codegen_subkwargs(c, loc, keywords, nkwelts - nseen, nkwelts));
if (have_dict) {
ADDOP_I(c, loc, DICT_MERGE, 1);
}
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);
- RETURN_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0));
+ RETURN_IF_ERROR(codegen_jump_if(c, loc, e, if_cleanup, 0));
}
if (++gen_index < asdl_seq_LEN(generators)) {
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);
- RETURN_IF_ERROR(compiler_jump_if(c, loc, e, if_cleanup, 0));
+ RETURN_IF_ERROR(codegen_jump_if(c, loc, e, if_cleanup, 0));
}
depth++;
ADDOP(c, LOC(e), RETURN_VALUE);
}
if (type == COMP_GENEXP) {
- if (wrap_in_stopiteration_handler(c) < 0) {
+ if (codegen_wrap_in_stopiteration_handler(c) < 0) {
goto error_in_scope;
}
}
}
loc = LOC(e);
- if (compiler_make_closure(c, loc, co, 0) < 0) {
+ if (codegen_make_closure(c, loc, co, 0) < 0) {
goto error;
}
Py_CLEAR(co);
static int
-compiler_with_except_finish(struct compiler *c, jump_target_label cleanup) {
+codegen_with_except_finish(struct compiler *c, jump_target_label cleanup) {
NEW_JUMP_TARGET_LABEL(c, suppress);
ADDOP(c, NO_LOCATION, TO_BOOL);
ADDOP_JUMP(c, NO_LOCATION, POP_JUMP_IF_TRUE, suppress);
raise
*/
static int
-compiler_async_with(struct compiler *c, stmt_ty s, int pos)
+codegen_async_with(struct compiler *c, stmt_ty s, int pos)
{
location loc = LOC(s);
withitem_ty item = asdl_seq_GET(s->v.AsyncWith.items, pos);
VISIT_SEQ(c, stmt, s->v.AsyncWith.body)
}
else {
- RETURN_IF_ERROR(compiler_async_with(c, s, pos));
+ RETURN_IF_ERROR(codegen_async_with(c, s, pos));
}
compiler_pop_fblock(c, ASYNC_WITH, block);
/* For successful outcome:
* call __exit__(None, None, None)
*/
- RETURN_IF_ERROR(compiler_call_exit_with_nones(c, loc));
+ RETURN_IF_ERROR(codegen_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);
- RETURN_IF_ERROR(compiler_with_except_finish(c, cleanup));
+ RETURN_IF_ERROR(codegen_with_except_finish(c, cleanup));
USE_LABEL(c, exit);
return SUCCESS;
*/
static int
-compiler_with(struct compiler *c, stmt_ty s, int pos)
+codegen_with(struct compiler *c, stmt_ty s, int pos)
{
withitem_ty item = asdl_seq_GET(s->v.With.items, pos);
VISIT_SEQ(c, stmt, s->v.With.body)
}
else {
- RETURN_IF_ERROR(compiler_with(c, s, pos));
+ RETURN_IF_ERROR(codegen_with(c, s, pos));
}
ADDOP(c, NO_LOCATION, POP_BLOCK);
/* For successful outcome:
* call __exit__(None, None, None)
*/
- RETURN_IF_ERROR(compiler_call_exit_with_nones(c, loc));
+ RETURN_IF_ERROR(codegen_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);
- RETURN_IF_ERROR(compiler_with_except_finish(c, cleanup));
+ RETURN_IF_ERROR(codegen_with_except_finish(c, cleanup));
USE_LABEL(c, exit);
return SUCCESS;
VISIT(c, expr, e->v.NamedExpr.target);
break;
case BoolOp_kind:
- return compiler_boolop(c, e);
+ return codegen_boolop(c, e);
case BinOp_kind:
VISIT(c, expr, e->v.BinOp.left);
VISIT(c, expr, e->v.BinOp.right);
}
break;
case Lambda_kind:
- return compiler_lambda(c, e);
+ return codegen_lambda(c, e);
case IfExp_kind:
- return compiler_ifexp(c, e);
+ return codegen_ifexp(c, e);
case Dict_kind:
- return compiler_dict(c, e);
+ return codegen_dict(c, e);
case Set_kind:
- return compiler_set(c, e);
+ return codegen_set(c, e);
case GeneratorExp_kind:
return compiler_genexp(c, e);
case ListComp_kind:
ADD_YIELD_FROM(c, loc, 1);
break;
case Compare_kind:
- return compiler_compare(c, e);
+ return codegen_compare(c, e);
case Call_kind:
- return compiler_call(c, e);
+ return codegen_call(c, e);
case Constant_kind:
ADDOP_LOAD_CONST(c, loc, e->v.Constant.value);
break;
case JoinedStr_kind:
- return compiler_joined_str(c, e);
+ return codegen_joined_str(c, e);
case FormattedValue_kind:
- return compiler_formatted_value(c, e);
+ return codegen_formatted_value(c, e);
/* The following exprs can be assignment targets. */
case Attribute_kind:
if (e->v.Attribute.ctx == Load) {
}
break;
case Subscript_kind:
- return compiler_subscript(c, e);
+ return codegen_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? */
+ * by codegen_list/codegen_tuple. XXX: is that okay? */
return compiler_error(c, loc,
"starred assignment target must be in a list or tuple");
default:
break;
case Slice_kind:
{
- int n = compiler_slice(c, e);
+ int n = codegen_slice(c, e);
RETURN_IF_ERROR(n);
ADDOP_I(c, loc, BUILD_SLICE, n);
break;
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 codegen_list(c, e);
case Tuple_kind:
- return compiler_tuple(c, e);
+ return codegen_tuple(c, e);
}
return SUCCESS;
}
}
static int
-compiler_augassign(struct compiler *c, stmt_ty s)
+codegen_augassign(struct compiler *c, stmt_ty s)
{
assert(s->kind == AugAssign_kind);
expr_ty e = s->v.AugAssign.target;
case Subscript_kind:
VISIT(c, expr, e->v.Subscript.value);
if (is_two_element_slice(e->v.Subscript.slice)) {
- RETURN_IF_ERROR(compiler_slice(c, e->v.Subscript.slice));
+ RETURN_IF_ERROR(codegen_slice(c, e->v.Subscript.slice));
ADDOP_I(c, loc, COPY, 3);
ADDOP_I(c, loc, COPY, 3);
ADDOP_I(c, loc, COPY, 3);
}
static int
-check_ann_expr(struct compiler *c, expr_ty e)
+codegen_check_ann_expr(struct compiler *c, expr_ty e)
{
VISIT(c, expr, e);
ADDOP(c, LOC(e), POP_TOP);
}
static int
-check_annotation(struct compiler *c, stmt_ty s)
+compiler_check_annotation(struct compiler *c, stmt_ty s)
{
/* Annotations of complex targets does not produce anything
under annotations future */
/* Annotations are only evaluated in a module or class. */
if (c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
c->u->u_scope_type == COMPILER_SCOPE_CLASS) {
- return check_ann_expr(c, s->v.AnnAssign.annotation);
+ return codegen_check_ann_expr(c, s->v.AnnAssign.annotation);
}
return SUCCESS;
}
static int
-check_ann_subscr(struct compiler *c, expr_ty e)
+codegen_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) < 0) {
+ if (e->v.Slice.lower && codegen_check_ann_expr(c, e->v.Slice.lower) < 0) {
return ERROR;
}
- if (e->v.Slice.upper && check_ann_expr(c, e->v.Slice.upper) < 0) {
+ if (e->v.Slice.upper && codegen_check_ann_expr(c, e->v.Slice.upper) < 0) {
return ERROR;
}
- if (e->v.Slice.step && check_ann_expr(c, e->v.Slice.step) < 0) {
+ if (e->v.Slice.step && codegen_check_ann_expr(c, e->v.Slice.step) < 0) {
return ERROR;
}
return SUCCESS;
asdl_expr_seq *elts = e->v.Tuple.elts;
Py_ssize_t i, n = asdl_seq_LEN(elts);
for (i = 0; i < n; i++) {
- RETURN_IF_ERROR(check_ann_subscr(c, asdl_seq_GET(elts, i)));
+ RETURN_IF_ERROR(codegen_check_ann_subscr(c, asdl_seq_GET(elts, i)));
}
return SUCCESS;
}
default:
- return check_ann_expr(c, e);
+ return codegen_check_ann_expr(c, e);
}
}
break;
case Attribute_kind:
if (!s->v.AnnAssign.value &&
- check_ann_expr(c, targ->v.Attribute.value) < 0) {
+ codegen_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) < 0 ||
- check_ann_subscr(c, targ->v.Subscript.slice) < 0)) {
+ (codegen_check_ann_expr(c, targ->v.Subscript.value) < 0 ||
+ codegen_check_ann_subscr(c, targ->v.Subscript.slice) < 0)) {
return ERROR;
}
break;
return ERROR;
}
/* Annotation is evaluated last. */
- if (future_annotations && !s->v.AnnAssign.simple && check_annotation(c, s) < 0) {
+ if (future_annotations && !s->v.AnnAssign.simple && compiler_check_annotation(c, s) < 0) {
return ERROR;
}
return SUCCESS;
}
static int
-compiler_subscript(struct compiler *c, expr_ty e)
+codegen_subscript(struct compiler *c, expr_ty e)
{
location loc = LOC(e);
expr_context_ty ctx = e->v.Subscript.ctx;
VISIT(c, expr, e->v.Subscript.value);
if (is_two_element_slice(e->v.Subscript.slice) && ctx != Del) {
- RETURN_IF_ERROR(compiler_slice(c, e->v.Subscript.slice));
+ RETURN_IF_ERROR(codegen_slice(c, e->v.Subscript.slice));
if (ctx == Load) {
ADDOP(c, loc, BINARY_SLICE);
}
/* Returns the number of the values emitted,
* thus are needed to build the slice, or -1 if there is an error. */
static int
-compiler_slice(struct compiler *c, expr_ty s)
+codegen_slice(struct compiler *c, expr_ty s)
{
int n = 2;
assert(s->kind == Slice_kind);
// PEP 634: Structural Pattern Matching
-// To keep things simple, all compiler_pattern_* and pattern_helper_* routines
-// follow the convention of consuming TOS (the subject for the given pattern)
-// and calling jump_to_fail_pop on failure (no match).
+// To keep things simple, all codegen_pattern_* routines follow the convention
+// of consuming TOS (the subject for the given pattern) and calling
+// jump_to_fail_pop on failure (no match).
// When calling into these routines, it's important that pc->on_top be kept
// updated to reflect the current number of items that we are using on the top
// Duplicate the effect of 3.10's ROT_* instructions using SWAPs.
static int
-pattern_helper_rotate(struct compiler *c, location loc, Py_ssize_t count)
+codegen_pattern_helper_rotate(struct compiler *c, location loc, Py_ssize_t count)
{
while (1 < count) {
ADDOP_I(c, loc, SWAP, count--);
}
static int
-pattern_helper_store_name(struct compiler *c, location loc,
- identifier n, pattern_context *pc)
+codegen_pattern_helper_store_name(struct compiler *c, location loc,
+ identifier n, pattern_context *pc)
{
if (n == NULL) {
ADDOP(c, loc, POP_TOP);
}
// 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_ERROR(pattern_helper_rotate(c, loc, rotations));
+ RETURN_IF_ERROR(codegen_pattern_helper_rotate(c, loc, rotations));
RETURN_IF_ERROR(PyList_Append(pc->stores, n));
return SUCCESS;
}
static int
-pattern_unpack_helper(struct compiler *c, location loc,
- asdl_pattern_seq *elts)
+codegen_pattern_unpack_helper(struct compiler *c, location loc,
+ asdl_pattern_seq *elts)
{
Py_ssize_t n = asdl_seq_LEN(elts);
int seen_star = 0;
asdl_pattern_seq *patterns, Py_ssize_t star,
pattern_context *pc)
{
- RETURN_IF_ERROR(pattern_unpack_helper(c, loc, patterns));
+ RETURN_IF_ERROR(codegen_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_ERROR(compiler_pattern_subpattern(c, pattern, pc));
+ RETURN_IF_ERROR(codegen_pattern_subpattern(c, pattern, pc));
}
return SUCCESS;
}
ADDOP_BINARY(c, loc, Sub);
}
ADDOP(c, loc, BINARY_SUBSCR);
- RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc));
+ RETURN_IF_ERROR(codegen_pattern_subpattern(c, pattern, pc));
}
// Pop the subject, we're done with it:
pc->on_top--;
return SUCCESS;
}
-// Like compiler_pattern, but turn off checks for irrefutability.
+// Like codegen_pattern, but turn off checks for irrefutability.
static int
-compiler_pattern_subpattern(struct compiler *c,
+codegen_pattern_subpattern(struct compiler *c,
pattern_ty p, pattern_context *pc)
{
int allow_irrefutable = pc->allow_irrefutable;
pc->allow_irrefutable = 1;
- RETURN_IF_ERROR(compiler_pattern(c, p, pc));
+ RETURN_IF_ERROR(codegen_pattern(c, p, pc));
pc->allow_irrefutable = allow_irrefutable;
return SUCCESS;
}
static int
-compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc)
{
assert(p->kind == MatchAs_kind);
if (p->v.MatchAs.pattern == NULL) {
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 codegen_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_ERROR(compiler_pattern(c, p->v.MatchAs.pattern, pc));
+ RETURN_IF_ERROR(codegen_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));
+ RETURN_IF_ERROR(codegen_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)
+codegen_pattern_star(struct compiler *c, pattern_ty p, pattern_context *pc)
{
assert(p->kind == MatchStar_kind);
RETURN_IF_ERROR(
- pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc));
+ codegen_pattern_helper_store_name(c, LOC(p), p->v.MatchStar.name, pc));
return SUCCESS;
}
}
static int
-compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc)
{
assert(p->kind == MatchClass_kind);
asdl_pattern_seq *patterns = p->v.MatchClass.patterns;
ADDOP(c, LOC(p), POP_TOP);
continue;
}
- RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc));
+ RETURN_IF_ERROR(codegen_pattern_subpattern(c, pattern, pc));
}
// Success! Pop the tuple of attributes:
return SUCCESS;
}
static int
-compiler_pattern_mapping(struct compiler *c, pattern_ty p,
- pattern_context *pc)
+codegen_pattern_mapping(struct compiler *c, pattern_ty p,
+ pattern_context *pc)
{
assert(p->kind == MatchMapping_kind);
asdl_expr_seq *keys = p->v.MatchMapping.keys;
for (Py_ssize_t i = 0; i < size; i++) {
pc->on_top--;
pattern_ty pattern = asdl_seq_GET(patterns, i);
- RETURN_IF_ERROR(compiler_pattern_subpattern(c, pattern, pc));
+ RETURN_IF_ERROR(codegen_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_ERROR(pattern_helper_store_name(c, LOC(p), star_target, pc));
+ RETURN_IF_ERROR(codegen_pattern_helper_store_name(c, LOC(p), star_target, pc));
}
else {
ADDOP(c, LOC(p), POP_TOP); // Tuple of keys.
}
static int
-compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
{
assert(p->kind == MatchOr_kind);
NEW_JUMP_TARGET_LABEL(c, end);
pc->fail_pop_size = 0;
pc->on_top = 0;
if (codegen_addop_i(INSTR_SEQUENCE(c), COPY, 1, LOC(alt)) < 0 ||
- compiler_pattern(c, alt, pc) < 0) {
+ codegen_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) < 0) {
+ if (codegen_pattern_helper_rotate(c, LOC(alt), icontrol + 1) < 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) < 0) {
+ if (codegen_pattern_helper_rotate(c, LOC(p), nrots) < 0) {
goto error;
}
// Update the list of previous stores with this new name, checking for
static int
-compiler_pattern_sequence(struct compiler *c, pattern_ty p,
- pattern_context *pc)
+codegen_pattern_sequence(struct compiler *c, pattern_ty p,
+ pattern_context *pc)
{
assert(p->kind == MatchSequence_kind);
asdl_pattern_seq *patterns = p->v.MatchSequence.patterns;
}
static int
-compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc)
{
assert(p->kind == MatchValue_kind);
expr_ty value = p->v.MatchValue.value;
}
static int
-compiler_pattern_singleton(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_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);
}
static int
-compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc)
+codegen_pattern(struct compiler *c, pattern_ty p, pattern_context *pc)
{
switch (p->kind) {
case MatchValue_kind:
- return compiler_pattern_value(c, p, pc);
+ return codegen_pattern_value(c, p, pc);
case MatchSingleton_kind:
- return compiler_pattern_singleton(c, p, pc);
+ return codegen_pattern_singleton(c, p, pc);
case MatchSequence_kind:
- return compiler_pattern_sequence(c, p, pc);
+ return codegen_pattern_sequence(c, p, pc);
case MatchMapping_kind:
- return compiler_pattern_mapping(c, p, pc);
+ return codegen_pattern_mapping(c, p, pc);
case MatchClass_kind:
- return compiler_pattern_class(c, p, pc);
+ return codegen_pattern_class(c, p, pc);
case MatchStar_kind:
- return compiler_pattern_star(c, p, pc);
+ return codegen_pattern_star(c, p, pc);
case MatchAs_kind:
- return compiler_pattern_as(c, p, pc);
+ return codegen_pattern_as(c, p, pc);
case MatchOr_kind:
- return compiler_pattern_or(c, p, pc);
+ return codegen_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
}
static int
-compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc)
+codegen_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc)
{
VISIT(c, expr, s->v.Match.subject);
NEW_JUMP_TARGET_LABEL(c, end);
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) < 0) {
+ if (codegen_pattern(c, m->pattern, pc) < 0) {
Py_DECREF(pc->stores);
return ERROR;
}
// 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(codegen_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), NOP);
}
if (m->guard) {
- RETURN_IF_ERROR(compiler_jump_if(c, LOC(m->pattern), m->guard, end, 0));
+ RETURN_IF_ERROR(codegen_jump_if(c, LOC(m->pattern), m->guard, end, 0));
}
VISIT_SEQ(c, stmt, m->body);
}
}
static int
-compiler_match(struct compiler *c, stmt_ty s)
+codegen_match(struct compiler *c, stmt_ty s)
{
pattern_context pc;
pc.fail_pop = NULL;
- int result = compiler_match_inner(c, s, &pc);
+ int result = codegen_match_inner(c, s, &pc);
PyMem_Free(pc.fail_pop);
return result;
}
return NULL;
}
- if (compiler_enter_anonymous_scope(c, mod) < 0) {
+ if (codegen_enter_anonymous_scope(c, mod) < 0) {
return NULL;
}
if (compiler_codegen(c, mod) < 0) {
projects / thirdparty / Python / cpython.git / commitdiff
