#define FUTURE_FEATURES(C) compiler_future_features(C)
#define SYMTABLE(C) compiler_symtable(C)
#define SYMTABLE_ENTRY(C) compiler_symtable_entry(C)
+#define OPTIMIZATION_LEVEL(C) compiler_optimization_level(C)
+#define IS_INTERACTIVE(C) compiler_is_interactive(C)
+#define IS_NESTED_SCOPE(C) compiler_is_nested_scope(C)
typedef _Py_SourceLocation location;
typedef struct _PyCfgBuilder cfg_builder;
+static PyObject *compiler_mangle(struct compiler *c, PyObject *name);
static PyObject *compiler_maybe_mangle(struct compiler *c, PyObject *name);
+static int compiler_optimization_level(struct compiler *c);
+static int compiler_is_interactive(struct compiler *c);
+static int compiler_is_nested_scope(struct compiler *c);
#define LOCATION(LNO, END_LNO, COL, END_COL) \
((const _Py_SourceLocation){(LNO), (END_LNO), (COL), (END_COL)})
int c_optimize; /* optimization level */
int c_interactive; /* true if in interactive mode */
- int c_nestlevel;
PyObject *c_const_cache; /* Python dict holding all constants,
including names tuple */
struct compiler_unit *u; /* compiler state for current block */
flags->cf_flags = merged;
c->c_flags = *flags;
c->c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;
- c->c_nestlevel = 0;
c->c_save_nested_seqs = false;
if (!_PyAST_Optimize(mod, arena, c->c_optimize, merged)) {
c->u = u;
- c->c_nestlevel++;
-
if (u->u_scope_type == COMPILER_SCOPE_MODULE) {
loc.lineno = 0;
}
nested_seq = c->u->u_instr_sequence;
Py_INCREF(nested_seq);
}
- c->c_nestlevel--;
compiler_unit_free(c->u);
/* Restore c->u to the parent unit. */
Py_ssize_t n = PyList_GET_SIZE(c->c_stack) - 1;
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, loc, co, 0) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, 0);
Py_DECREF(co);
- return 0;
+ RETURN_IF_ERROR(ret);
+ return SUCCESS;
}
/* Compile a sequence of statements, checking for a docstring
return SUCCESS;
}
Py_ssize_t first_instr = 0;
- if (!c->c_interactive) {
+ if (!IS_INTERACTIVE(c)) {
PyObject *docstring = _PyAST_GetDocString(stmts);
if (docstring) {
first_instr = 1;
/* if not -OO mode, set docstring */
- if (c->c_optimize < 2) {
+ if (OPTIMIZATION_LEVEL(c) < 2) {
PyObject *cleandoc = _PyCompile_CleanDoc(docstring);
if (cleandoc == NULL) {
return ERROR;
Py_DECREF(deferred_anno);
return ERROR;
}
- PyObject *mangled = _Py_Mangle(c->u->u_private, st->v.AnnAssign.target->v.Name.id);
+ PyObject *mangled = compiler_mangle(c, st->v.AnnAssign.target->v.Name.id);
ADDOP_LOAD_CONST_NEW(c, LOC(st), mangled);
VISIT(c, expr, st->v.AnnAssign.annotation);
}
switch (mod->kind) {
case Module_kind: {
asdl_stmt_seq *stmts = mod->v.Module.body;
- if (compiler_body(c, start_location(stmts), stmts) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(compiler_body(c, start_location(stmts), stmts));
break;
}
case Interactive_kind: {
c->c_interactive = 1;
asdl_stmt_seq *stmts = mod->v.Interactive.body;
- if (compiler_body(c, start_location(stmts), stmts) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(compiler_body(c, start_location(stmts), stmts));
break;
}
case Expression_kind: {
Py_ssize_t annotations_len = 0;
PySTEntryObject *ste;
- if (_PySymtable_LookupOptional(SYMTABLE(c), args, &ste) < 0) {
- return ERROR;
- }
+ RETURN_IF_ERROR(_PySymtable_LookupOptional(SYMTABLE(c), args, &ste));
assert(ste != NULL);
bool annotations_used = ste->ste_annotations_used;
- if (annotations_used) {
- if (codegen_setup_annotations_scope(c, loc, (void *)args,
- ste->ste_name) < 0) {
- Py_DECREF(ste);
- return ERROR;
- }
- }
+ int err = annotations_used ?
+ codegen_setup_annotations_scope(c, loc, (void *)args, ste->ste_name) : SUCCESS;
Py_DECREF(ste);
+ RETURN_IF_ERROR(err);
if (codegen_annotations_in_scope(c, loc, args, returns, &annotations_len) < 0) {
if (annotations_used) {
{
PyObject *defaults = PyTuple_Pack(1, _PyLong_GetOne());
ADDOP_LOAD_CONST_NEW(c, LOC(e), defaults);
- if (codegen_setup_annotations_scope(c, LOC(e), key, name) == -1) {
- return ERROR;
- }
+ RETURN_IF_ERROR(codegen_setup_annotations_scope(c, LOC(e), key, name));
if (allow_starred && e->kind == Starred_kind) {
VISIT(c, expr, e->v.Starred.value);
ADDOP_I(c, LOC(e), UNPACK_SEQUENCE, (Py_ssize_t)1);
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, LOC(e), co, MAKE_FUNCTION_DEFAULTS) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, LOC(e), co, MAKE_FUNCTION_DEFAULTS);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
return SUCCESS;
}
}
static int
-compiler_function_body(struct compiler *c, stmt_ty s, int is_async, Py_ssize_t funcflags,
- int firstlineno)
+codegen_function_body(struct compiler *c, stmt_ty s, int is_async, Py_ssize_t funcflags,
+ int firstlineno)
{
arguments_ty args;
identifier name;
if (docstring) {
first_instr = 1;
/* if not -OO mode, add docstring */
- if (c->c_optimize < 2) {
+ if (OPTIMIZATION_LEVEL(c) < 2) {
docstring = _PyCompile_CleanDoc(docstring);
if (docstring == NULL) {
compiler_exit_scope(c);
int is_generic = asdl_seq_LEN(type_params) > 0;
funcflags = codegen_default_arguments(c, loc, args);
- if (funcflags == -1) {
- return ERROR;
- }
+ RETURN_IF_ERROR(funcflags);
int num_typeparam_args = 0;
_PyCompile_CodeUnitMetadata umd = {
.u_argcount = num_typeparam_args,
};
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
- (void *)type_params, firstlineno, NULL, &umd) == -1) {
- Py_DECREF(type_params_name);
- return ERROR;
- }
+ int ret = compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
+ (void *)type_params, firstlineno, NULL, &umd);
Py_DECREF(type_params_name);
+ RETURN_IF_ERROR(ret);
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);
}
funcflags |= annotations_flag;
- if (compiler_function_body(c, s, is_async, funcflags, firstlineno) < 0) {
- if (is_generic) {
- compiler_exit_scope(c);
- }
- return ERROR;
+ int ret = codegen_function_body(c, s, is_async, funcflags, firstlineno);
+ if (is_generic) {
+ RETURN_IF_ERROR_IN_SCOPE(c, ret);
+ }
+ else {
+ RETURN_IF_ERROR(ret);
}
if (is_generic) {
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, loc, co, 0) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, 0);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
if (num_typeparam_args > 0) {
ADDOP_I(c, loc, SWAP, num_typeparam_args + 1);
ADDOP_I(c, loc, CALL, num_typeparam_args - 1);
ADDOP(c, loc, PUSH_NULL);
/* 3. load a function (or closure) made from the code object */
- if (codegen_make_closure(c, loc, co, 0) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, 0);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
/* 4. load class name */
ADDOP_LOAD_CONST(c, loc, s->v.ClassDef.name);
if (!type_params_name) {
return ERROR;
}
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
- (void *)type_params, firstlineno, s->v.ClassDef.name, NULL) == -1) {
- Py_DECREF(type_params_name);
- return ERROR;
- }
+ int ret = compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
+ (void *)type_params, firstlineno, s->v.ClassDef.name, NULL);
Py_DECREF(type_params_name);
+ RETURN_IF_ERROR(ret);
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));
}
- if (compiler_class_body(c, s, firstlineno) < 0) {
- if (is_generic) {
- compiler_exit_scope(c);
- }
- return ERROR;
+ int ret = compiler_class_body(c, s, firstlineno);
+ if (is_generic) {
+ RETURN_IF_ERROR_IN_SCOPE(c, ret);
+ }
+ else {
+ RETURN_IF_ERROR(ret);
}
/* generate the rest of the code for the call */
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, loc, co, 0) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, 0);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
ADDOP(c, loc, PUSH_NULL);
ADDOP_I(c, loc, CALL, 0);
} else {
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, loc, co, MAKE_FUNCTION_DEFAULTS) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, MAKE_FUNCTION_DEFAULTS);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
+
ADDOP_I(c, loc, BUILD_TUPLE, 3);
ADDOP_I(c, loc, CALL_INTRINSIC_1, INTRINSIC_TYPEALIAS);
return SUCCESS;
if (!type_params_name) {
return ERROR;
}
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
- (void *)type_params, loc.lineno, NULL, NULL) == -1) {
- Py_DECREF(type_params_name);
- return ERROR;
- }
+ int ret = compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
+ (void *)type_params, loc.lineno, NULL, NULL);
Py_DECREF(type_params_name);
+ RETURN_IF_ERROR(ret);
ADDOP_LOAD_CONST_IN_SCOPE(c, loc, name);
RETURN_IF_ERROR_IN_SCOPE(c, codegen_type_params(c, type_params));
}
ADDOP_LOAD_CONST(c, loc, Py_None);
}
- if (codegen_typealias_body(c, s) < 0) {
- if (is_generic) {
- compiler_exit_scope(c);
- }
- return ERROR;
+ int ret = codegen_typealias_body(c, s);
+ if (is_generic) {
+ RETURN_IF_ERROR_IN_SCOPE(c, ret);
+ }
+ else {
+ RETURN_IF_ERROR(ret);
}
if (is_generic) {
if (co == NULL) {
return ERROR;
}
- if (codegen_make_closure(c, loc, co, 0) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, 0);
Py_DECREF(co);
+ RETURN_IF_ERROR(ret);
ADDOP(c, loc, PUSH_NULL);
ADDOP_I(c, loc, CALL, 0);
}
location loc = LOC(e);
funcflags = codegen_default_arguments(c, loc, args);
- if (funcflags == -1) {
- return ERROR;
- }
+ RETURN_IF_ERROR(funcflags);
_PyCompile_CodeUnitMetadata umd = {
.u_argcount = asdl_seq_LEN(args->args),
return ERROR;
}
- if (codegen_make_closure(c, loc, co, funcflags) < 0) {
- Py_DECREF(co);
- return ERROR;
- }
+ int ret = codegen_make_closure(c, loc, co, funcflags);
Py_DECREF(co);
-
+ RETURN_IF_ERROR(ret);
return SUCCESS;
}
}
static int
-compiler_assert(struct compiler *c, stmt_ty s)
+codegen_assert(struct compiler *c, stmt_ty s)
{
/* Always emit a warning if the test is a non-zero length tuple */
if ((s->v.Assert.test->kind == Tuple_kind &&
compiler_warn(c, LOC(s), "assertion is always true, "
"perhaps remove parentheses?"));
}
- if (c->c_optimize) {
+ if (OPTIMIZATION_LEVEL(c)) {
return SUCCESS;
}
NEW_JUMP_TARGET_LABEL(c, end);
}
static int
-compiler_stmt_expr(struct compiler *c, location loc, expr_ty value)
+codegen_stmt_expr(struct compiler *c, location loc, expr_ty value)
{
- if (c->c_interactive && c->c_nestlevel <= 1) {
+ if (IS_INTERACTIVE(c) && !IS_NESTED_SCOPE(c)) {
VISIT(c, expr, value);
ADDOP_I(c, loc, CALL_INTRINSIC_1, INTRINSIC_PRINT);
ADDOP(c, NO_LOCATION, POP_TOP);
case TryStar_kind:
return codegen_try_star(c, s);
case Assert_kind:
- return compiler_assert(c, s);
+ return codegen_assert(c, s);
case Import_kind:
return codegen_import(c, s);
case ImportFrom_kind:
break;
case Expr_kind:
{
- return compiler_stmt_expr(c, LOC(s), s->v.Expr.value);
+ return codegen_stmt_expr(c, LOC(s), s->v.Expr.value);
}
case Pass_kind:
{
}
static inline int
-compiler_comprehension_iter(struct compiler *c, location loc,
- comprehension_ty comp)
+codegen_comprehension_iter(struct compiler *c, location loc,
+ comprehension_ty comp)
{
VISIT(c, expr, comp->iter);
if (comp->is_async) {
outermost = (comprehension_ty) asdl_seq_GET(generators, 0);
if (is_inlined) {
- if (compiler_comprehension_iter(c, loc, outermost)) {
+ if (codegen_comprehension_iter(c, loc, outermost)) {
goto error;
}
if (push_inlined_comprehension_state(c, loc, entry, &inline_state)) {
}
Py_CLEAR(co);
- if (compiler_comprehension_iter(c, loc, outermost)) {
+ if (codegen_comprehension_iter(c, loc, outermost)) {
goto error;
}
}
static int
-compiler_genexp(struct compiler *c, expr_ty e)
+codegen_genexp(struct compiler *c, expr_ty e)
{
assert(e->kind == GeneratorExp_kind);
_Py_DECLARE_STR(anon_genexpr, "<genexpr>");
}
static int
-compiler_listcomp(struct compiler *c, expr_ty e)
+codegen_listcomp(struct compiler *c, expr_ty e)
{
assert(e->kind == ListComp_kind);
_Py_DECLARE_STR(anon_listcomp, "<listcomp>");
}
static int
-compiler_setcomp(struct compiler *c, expr_ty e)
+codegen_setcomp(struct compiler *c, expr_ty e)
{
assert(e->kind == SetComp_kind);
_Py_DECLARE_STR(anon_setcomp, "<setcomp>");
static int
-compiler_dictcomp(struct compiler *c, expr_ty e)
+codegen_dictcomp(struct compiler *c, expr_ty e)
{
assert(e->kind == DictComp_kind);
_Py_DECLARE_STR(anon_dictcomp, "<dictcomp>");
case Set_kind:
return codegen_set(c, e);
case GeneratorExp_kind:
- return compiler_genexp(c, e);
+ return codegen_genexp(c, e);
case ListComp_kind:
- return compiler_listcomp(c, e);
+ return codegen_listcomp(c, e);
case SetComp_kind:
- return compiler_setcomp(c, e);
+ return codegen_setcomp(c, e);
case DictComp_kind:
- return compiler_dictcomp(c, e);
+ return codegen_dictcomp(c, e);
case Yield_kind:
if (!_PyST_IsFunctionLike(SYMTABLE_ENTRY(c))) {
return compiler_error(c, loc, "'yield' outside function");
return consts;
}
+static PyObject *
+compiler_mangle(struct compiler *c, PyObject *name)
+{
+ return _Py_Mangle(c->u->u_private, name);
+}
+
static PyObject *
compiler_maybe_mangle(struct compiler *c, PyObject *name)
{
return c->u->u_ste;
}
+static int
+compiler_optimization_level(struct compiler *c)
+{
+ return c->c_optimize;
+}
+
+static int
+compiler_is_interactive(struct compiler *c)
+{
+ return c->c_interactive;
+}
+
+static int
+compiler_is_nested_scope(struct compiler *c)
+{
+ assert(c->c_stack != NULL);
+ assert(PyList_CheckExact(c->c_stack));
+ return PyList_GET_SIZE(c->c_stack) > 0;
+}
+
static int
compute_code_flags(struct compiler *c)
{
projects / thirdparty / Python / cpython.git / commitdiff
