[Python-checkins] bpo-41194: Convert _ast extension to PEP 489 (GH-21293)
Victor Stinner
webhook-mailer at python.org
Fri Jul 3 14:01:54 EDT 2020
https://github.com/python/cpython/commit/b1cc6ba73a51d5cc3aeb113b5e7378fb50a0e20a
commit: b1cc6ba73a51d5cc3aeb113b5e7378fb50a0e20a
branch: master
author: Victor Stinner <vstinner at python.org>
committer: GitHub <noreply at github.com>
date: 2020-07-03T20:01:46+02:00
summary:
bpo-41194: Convert _ast extension to PEP 489 (GH-21293)
Convert the _ast extension module to PEP 489 "Multiphase
initialization". Replace the global _ast state with a module state.
files:
M Parser/asdl_c.py
M Python/Python-ast.c
diff --git a/Parser/asdl_c.py b/Parser/asdl_c.py
index f029ca6618f93..b93906ba8d45d 100755
--- a/Parser/asdl_c.py
+++ b/Parser/asdl_c.py
@@ -692,6 +692,9 @@ def visitModule(self, mod):
int res = -1;
PyObject *key, *value, *fields;
astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
+ goto cleanup;
+ }
if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) {
goto cleanup;
}
@@ -761,6 +764,10 @@ def visitModule(self, mod):
ast_type_reduce(PyObject *self, PyObject *unused)
{
astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
+ return NULL;
+ }
+
PyObject *dict;
if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) {
return NULL;
@@ -969,9 +976,8 @@ def visitModule(self, mod):
""", 0, reflow=False)
- self.emit("static int init_types(void)",0)
+ self.emit("static int init_types(astmodulestate *state)",0)
self.emit("{", 0)
- self.emit("astmodulestate *state = get_global_ast_state();", 1)
self.emit("if (state->initialized) return 1;", 1)
self.emit("if (init_identifiers(state) < 0) return 0;", 1)
self.emit("state->AST_type = PyType_FromSpec(&AST_type_spec);", 1)
@@ -1046,40 +1052,55 @@ def emit_defaults(self, name, fields, depth):
class ASTModuleVisitor(PickleVisitor):
def visitModule(self, mod):
- self.emit("PyMODINIT_FUNC", 0)
- self.emit("PyInit__ast(void)", 0)
+ self.emit("static int", 0)
+ self.emit("astmodule_exec(PyObject *m)", 0)
self.emit("{", 0)
- self.emit("PyObject *m = PyModule_Create(&_astmodule);", 1)
- self.emit("if (!m) {", 1)
- self.emit("return NULL;", 2)
- self.emit("}", 1)
self.emit('astmodulestate *state = get_ast_state(m);', 1)
- self.emit('', 1)
+ self.emit("", 0)
- self.emit("if (!init_types()) {", 1)
- self.emit("goto error;", 2)
+ self.emit("if (!init_types(state)) {", 1)
+ self.emit("return -1;", 2)
self.emit("}", 1)
self.emit('if (PyModule_AddObject(m, "AST", state->AST_type) < 0) {', 1)
- self.emit('goto error;', 2)
+ self.emit('return -1;', 2)
self.emit('}', 1)
self.emit('Py_INCREF(state->AST_type);', 1)
self.emit('if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {', 1)
- self.emit("goto error;", 2)
+ self.emit("return -1;", 2)
self.emit('}', 1)
self.emit('if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {', 1)
- self.emit("goto error;", 2)
+ self.emit("return -1;", 2)
self.emit('}', 1)
self.emit('if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {', 1)
- self.emit("goto error;", 2)
+ self.emit("return -1;", 2)
self.emit('}', 1)
for dfn in mod.dfns:
self.visit(dfn)
- self.emit("return m;", 1)
- self.emit("", 0)
- self.emit("error:", 0)
- self.emit("Py_DECREF(m);", 1)
- self.emit("return NULL;", 1)
+ self.emit("return 0;", 1)
self.emit("}", 0)
+ self.emit("", 0)
+ self.emit("""
+static PyModuleDef_Slot astmodule_slots[] = {
+ {Py_mod_exec, astmodule_exec},
+ {0, NULL}
+};
+
+static struct PyModuleDef _astmodule = {
+ PyModuleDef_HEAD_INIT,
+ .m_name = "_ast",
+ .m_size = sizeof(astmodulestate),
+ .m_slots = astmodule_slots,
+ .m_traverse = astmodule_traverse,
+ .m_clear = astmodule_clear,
+ .m_free = astmodule_free,
+};
+
+PyMODINIT_FUNC
+PyInit__ast(void)
+{
+ return PyModuleDef_Init(&_astmodule);
+}
+""".strip(), 0, reflow=False)
def visitProduct(self, prod, name):
self.addObj(name)
@@ -1095,7 +1116,7 @@ def visitConstructor(self, cons, name):
def addObj(self, name):
self.emit("if (PyModule_AddObject(m, \"%s\", "
"state->%s_type) < 0) {" % (name, name), 1)
- self.emit("goto error;", 2)
+ self.emit("return -1;", 2)
self.emit('}', 1)
self.emit("Py_INCREF(state->%s_type);" % name, 1)
@@ -1255,11 +1276,10 @@ class PartingShots(StaticVisitor):
CODE = """
PyObject* PyAST_mod2obj(mod_ty t)
{
- if (!init_types()) {
+ astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
return NULL;
}
-
- astmodulestate *state = get_global_ast_state();
return ast2obj_mod(state, t);
}
@@ -1281,10 +1301,6 @@ class PartingShots(StaticVisitor):
assert(0 <= mode && mode <= 2);
- if (!init_types()) {
- return NULL;
- }
-
isinstance = PyObject_IsInstance(ast, req_type[mode]);
if (isinstance == -1)
return NULL;
@@ -1303,11 +1319,10 @@ class PartingShots(StaticVisitor):
int PyAST_Check(PyObject* obj)
{
- if (!init_types()) {
+ astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
return -1;
}
-
- astmodulestate *state = get_global_ast_state();
return PyObject_IsInstance(obj, state->AST_type);
}
"""
@@ -1358,12 +1373,35 @@ def generate_module_def(f, mod):
f.write(' PyObject *' + s + ';\n')
f.write('} astmodulestate;\n\n')
f.write("""
-static astmodulestate global_ast_state;
+static astmodulestate*
+get_ast_state(PyObject *module)
+{
+ void *state = PyModule_GetState(module);
+ assert(state != NULL);
+ return (astmodulestate*)state;
+}
-static astmodulestate *
-get_ast_state(PyObject *Py_UNUSED(module))
+static astmodulestate*
+get_global_ast_state(void)
{
- return &global_ast_state;
+ _Py_IDENTIFIER(_ast);
+ PyObject *name = _PyUnicode_FromId(&PyId__ast); // borrowed reference
+ if (name == NULL) {
+ return NULL;
+ }
+ PyObject *module = PyImport_GetModule(name);
+ if (module == NULL) {
+ if (PyErr_Occurred()) {
+ return NULL;
+ }
+ module = PyImport_Import(name);
+ if (module == NULL) {
+ return NULL;
+ }
+ }
+ astmodulestate *state = get_ast_state(module);
+ Py_DECREF(module);
+ return state;
}
static int astmodule_clear(PyObject *module)
@@ -1390,17 +1428,6 @@ def generate_module_def(f, mod):
astmodule_clear((PyObject*)module);
}
-static struct PyModuleDef _astmodule = {
- PyModuleDef_HEAD_INIT,
- .m_name = "_ast",
- .m_size = -1,
- .m_traverse = astmodule_traverse,
- .m_clear = astmodule_clear,
- .m_free = astmodule_free,
-};
-
-#define get_global_ast_state() (&global_ast_state)
-
""")
f.write('static int init_identifiers(astmodulestate *state)\n')
f.write('{\n')
diff --git a/Python/Python-ast.c b/Python/Python-ast.c
index 844033ee37e28..b81b282a03965 100644
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -224,12 +224,35 @@ typedef struct {
} astmodulestate;
-static astmodulestate global_ast_state;
+static astmodulestate*
+get_ast_state(PyObject *module)
+{
+ void *state = PyModule_GetState(module);
+ assert(state != NULL);
+ return (astmodulestate*)state;
+}
-static astmodulestate *
-get_ast_state(PyObject *Py_UNUSED(module))
+static astmodulestate*
+get_global_ast_state(void)
{
- return &global_ast_state;
+ _Py_IDENTIFIER(_ast);
+ PyObject *name = _PyUnicode_FromId(&PyId__ast); // borrowed reference
+ if (name == NULL) {
+ return NULL;
+ }
+ PyObject *module = PyImport_GetModule(name);
+ if (module == NULL) {
+ if (PyErr_Occurred()) {
+ return NULL;
+ }
+ module = PyImport_Import(name);
+ if (module == NULL) {
+ return NULL;
+ }
+ }
+ astmodulestate *state = get_ast_state(module);
+ Py_DECREF(module);
+ return state;
}
static int astmodule_clear(PyObject *module)
@@ -676,17 +699,6 @@ static void astmodule_free(void* module) {
astmodule_clear((PyObject*)module);
}
-static struct PyModuleDef _astmodule = {
- PyModuleDef_HEAD_INIT,
- .m_name = "_ast",
- .m_size = -1,
- .m_traverse = astmodule_traverse,
- .m_clear = astmodule_clear,
- .m_free = astmodule_free,
-};
-
-#define get_global_ast_state() (&global_ast_state)
-
static int init_identifiers(astmodulestate *state)
{
if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
@@ -1132,6 +1144,9 @@ ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
int res = -1;
PyObject *key, *value, *fields;
astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
+ goto cleanup;
+ }
if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) {
goto cleanup;
}
@@ -1201,6 +1216,10 @@ static PyObject *
ast_type_reduce(PyObject *self, PyObject *unused)
{
astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
+ return NULL;
+ }
+
PyObject *dict;
if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) {
return NULL;
@@ -1408,9 +1427,8 @@ static int add_ast_fields(astmodulestate *state)
}
-static int init_types(void)
+static int init_types(astmodulestate *state)
{
- astmodulestate *state = get_global_ast_state();
if (state->initialized) return 1;
if (init_identifiers(state) < 0) return 0;
state->AST_type = PyType_FromSpec(&AST_type_spec);
@@ -9839,472 +9857,484 @@ obj2ast_type_ignore(astmodulestate *state, PyObject* obj, type_ignore_ty* out,
}
-PyMODINIT_FUNC
-PyInit__ast(void)
+static int
+astmodule_exec(PyObject *m)
{
- PyObject *m = PyModule_Create(&_astmodule);
- if (!m) {
- return NULL;
- }
astmodulestate *state = get_ast_state(m);
- if (!init_types()) {
- goto error;
+ if (!init_types(state)) {
+ return -1;
}
if (PyModule_AddObject(m, "AST", state->AST_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AST_type);
if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
- goto error;
+ return -1;
}
if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {
- goto error;
+ return -1;
}
if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
- goto error;
+ return -1;
}
if (PyModule_AddObject(m, "mod", state->mod_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->mod_type);
if (PyModule_AddObject(m, "Module", state->Module_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Module_type);
if (PyModule_AddObject(m, "Interactive", state->Interactive_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Interactive_type);
if (PyModule_AddObject(m, "Expression", state->Expression_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Expression_type);
if (PyModule_AddObject(m, "FunctionType", state->FunctionType_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->FunctionType_type);
if (PyModule_AddObject(m, "stmt", state->stmt_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->stmt_type);
if (PyModule_AddObject(m, "FunctionDef", state->FunctionDef_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->FunctionDef_type);
if (PyModule_AddObject(m, "AsyncFunctionDef", state->AsyncFunctionDef_type)
< 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AsyncFunctionDef_type);
if (PyModule_AddObject(m, "ClassDef", state->ClassDef_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->ClassDef_type);
if (PyModule_AddObject(m, "Return", state->Return_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Return_type);
if (PyModule_AddObject(m, "Delete", state->Delete_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Delete_type);
if (PyModule_AddObject(m, "Assign", state->Assign_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Assign_type);
if (PyModule_AddObject(m, "AugAssign", state->AugAssign_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AugAssign_type);
if (PyModule_AddObject(m, "AnnAssign", state->AnnAssign_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AnnAssign_type);
if (PyModule_AddObject(m, "For", state->For_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->For_type);
if (PyModule_AddObject(m, "AsyncFor", state->AsyncFor_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AsyncFor_type);
if (PyModule_AddObject(m, "While", state->While_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->While_type);
if (PyModule_AddObject(m, "If", state->If_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->If_type);
if (PyModule_AddObject(m, "With", state->With_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->With_type);
if (PyModule_AddObject(m, "AsyncWith", state->AsyncWith_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->AsyncWith_type);
if (PyModule_AddObject(m, "Raise", state->Raise_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Raise_type);
if (PyModule_AddObject(m, "Try", state->Try_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Try_type);
if (PyModule_AddObject(m, "Assert", state->Assert_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Assert_type);
if (PyModule_AddObject(m, "Import", state->Import_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Import_type);
if (PyModule_AddObject(m, "ImportFrom", state->ImportFrom_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->ImportFrom_type);
if (PyModule_AddObject(m, "Global", state->Global_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Global_type);
if (PyModule_AddObject(m, "Nonlocal", state->Nonlocal_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Nonlocal_type);
if (PyModule_AddObject(m, "Expr", state->Expr_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Expr_type);
if (PyModule_AddObject(m, "Pass", state->Pass_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Pass_type);
if (PyModule_AddObject(m, "Break", state->Break_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Break_type);
if (PyModule_AddObject(m, "Continue", state->Continue_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Continue_type);
if (PyModule_AddObject(m, "expr", state->expr_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->expr_type);
if (PyModule_AddObject(m, "BoolOp", state->BoolOp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->BoolOp_type);
if (PyModule_AddObject(m, "NamedExpr", state->NamedExpr_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->NamedExpr_type);
if (PyModule_AddObject(m, "BinOp", state->BinOp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->BinOp_type);
if (PyModule_AddObject(m, "UnaryOp", state->UnaryOp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->UnaryOp_type);
if (PyModule_AddObject(m, "Lambda", state->Lambda_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Lambda_type);
if (PyModule_AddObject(m, "IfExp", state->IfExp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->IfExp_type);
if (PyModule_AddObject(m, "Dict", state->Dict_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Dict_type);
if (PyModule_AddObject(m, "Set", state->Set_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Set_type);
if (PyModule_AddObject(m, "ListComp", state->ListComp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->ListComp_type);
if (PyModule_AddObject(m, "SetComp", state->SetComp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->SetComp_type);
if (PyModule_AddObject(m, "DictComp", state->DictComp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->DictComp_type);
if (PyModule_AddObject(m, "GeneratorExp", state->GeneratorExp_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->GeneratorExp_type);
if (PyModule_AddObject(m, "Await", state->Await_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Await_type);
if (PyModule_AddObject(m, "Yield", state->Yield_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Yield_type);
if (PyModule_AddObject(m, "YieldFrom", state->YieldFrom_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->YieldFrom_type);
if (PyModule_AddObject(m, "Compare", state->Compare_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Compare_type);
if (PyModule_AddObject(m, "Call", state->Call_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Call_type);
if (PyModule_AddObject(m, "FormattedValue", state->FormattedValue_type) <
0) {
- goto error;
+ return -1;
}
Py_INCREF(state->FormattedValue_type);
if (PyModule_AddObject(m, "JoinedStr", state->JoinedStr_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->JoinedStr_type);
if (PyModule_AddObject(m, "Constant", state->Constant_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Constant_type);
if (PyModule_AddObject(m, "Attribute", state->Attribute_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Attribute_type);
if (PyModule_AddObject(m, "Subscript", state->Subscript_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Subscript_type);
if (PyModule_AddObject(m, "Starred", state->Starred_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Starred_type);
if (PyModule_AddObject(m, "Name", state->Name_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Name_type);
if (PyModule_AddObject(m, "List", state->List_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->List_type);
if (PyModule_AddObject(m, "Tuple", state->Tuple_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Tuple_type);
if (PyModule_AddObject(m, "Slice", state->Slice_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Slice_type);
if (PyModule_AddObject(m, "expr_context", state->expr_context_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->expr_context_type);
if (PyModule_AddObject(m, "Load", state->Load_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Load_type);
if (PyModule_AddObject(m, "Store", state->Store_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Store_type);
if (PyModule_AddObject(m, "Del", state->Del_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Del_type);
if (PyModule_AddObject(m, "boolop", state->boolop_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->boolop_type);
if (PyModule_AddObject(m, "And", state->And_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->And_type);
if (PyModule_AddObject(m, "Or", state->Or_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Or_type);
if (PyModule_AddObject(m, "operator", state->operator_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->operator_type);
if (PyModule_AddObject(m, "Add", state->Add_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Add_type);
if (PyModule_AddObject(m, "Sub", state->Sub_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Sub_type);
if (PyModule_AddObject(m, "Mult", state->Mult_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Mult_type);
if (PyModule_AddObject(m, "MatMult", state->MatMult_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->MatMult_type);
if (PyModule_AddObject(m, "Div", state->Div_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Div_type);
if (PyModule_AddObject(m, "Mod", state->Mod_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Mod_type);
if (PyModule_AddObject(m, "Pow", state->Pow_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Pow_type);
if (PyModule_AddObject(m, "LShift", state->LShift_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->LShift_type);
if (PyModule_AddObject(m, "RShift", state->RShift_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->RShift_type);
if (PyModule_AddObject(m, "BitOr", state->BitOr_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->BitOr_type);
if (PyModule_AddObject(m, "BitXor", state->BitXor_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->BitXor_type);
if (PyModule_AddObject(m, "BitAnd", state->BitAnd_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->BitAnd_type);
if (PyModule_AddObject(m, "FloorDiv", state->FloorDiv_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->FloorDiv_type);
if (PyModule_AddObject(m, "unaryop", state->unaryop_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->unaryop_type);
if (PyModule_AddObject(m, "Invert", state->Invert_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Invert_type);
if (PyModule_AddObject(m, "Not", state->Not_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Not_type);
if (PyModule_AddObject(m, "UAdd", state->UAdd_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->UAdd_type);
if (PyModule_AddObject(m, "USub", state->USub_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->USub_type);
if (PyModule_AddObject(m, "cmpop", state->cmpop_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->cmpop_type);
if (PyModule_AddObject(m, "Eq", state->Eq_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Eq_type);
if (PyModule_AddObject(m, "NotEq", state->NotEq_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->NotEq_type);
if (PyModule_AddObject(m, "Lt", state->Lt_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Lt_type);
if (PyModule_AddObject(m, "LtE", state->LtE_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->LtE_type);
if (PyModule_AddObject(m, "Gt", state->Gt_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Gt_type);
if (PyModule_AddObject(m, "GtE", state->GtE_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->GtE_type);
if (PyModule_AddObject(m, "Is", state->Is_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->Is_type);
if (PyModule_AddObject(m, "IsNot", state->IsNot_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->IsNot_type);
if (PyModule_AddObject(m, "In", state->In_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->In_type);
if (PyModule_AddObject(m, "NotIn", state->NotIn_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->NotIn_type);
if (PyModule_AddObject(m, "comprehension", state->comprehension_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->comprehension_type);
if (PyModule_AddObject(m, "excepthandler", state->excepthandler_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->excepthandler_type);
if (PyModule_AddObject(m, "ExceptHandler", state->ExceptHandler_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->ExceptHandler_type);
if (PyModule_AddObject(m, "arguments", state->arguments_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->arguments_type);
if (PyModule_AddObject(m, "arg", state->arg_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->arg_type);
if (PyModule_AddObject(m, "keyword", state->keyword_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->keyword_type);
if (PyModule_AddObject(m, "alias", state->alias_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->alias_type);
if (PyModule_AddObject(m, "withitem", state->withitem_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->withitem_type);
if (PyModule_AddObject(m, "type_ignore", state->type_ignore_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->type_ignore_type);
if (PyModule_AddObject(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
- goto error;
+ return -1;
}
Py_INCREF(state->TypeIgnore_type);
- return m;
+ return 0;
+}
-error:
- Py_DECREF(m);
- return NULL;
+static PyModuleDef_Slot astmodule_slots[] = {
+ {Py_mod_exec, astmodule_exec},
+ {0, NULL}
+};
+
+static struct PyModuleDef _astmodule = {
+ PyModuleDef_HEAD_INIT,
+ .m_name = "_ast",
+ .m_size = sizeof(astmodulestate),
+ .m_slots = astmodule_slots,
+ .m_traverse = astmodule_traverse,
+ .m_clear = astmodule_clear,
+ .m_free = astmodule_free,
+};
+
+PyMODINIT_FUNC
+PyInit__ast(void)
+{
+ return PyModuleDef_Init(&_astmodule);
}
PyObject* PyAST_mod2obj(mod_ty t)
{
- if (!init_types()) {
+ astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
return NULL;
}
-
- astmodulestate *state = get_global_ast_state();
return ast2obj_mod(state, t);
}
@@ -10326,10 +10356,6 @@ mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
assert(0 <= mode && mode <= 2);
- if (!init_types()) {
- return NULL;
- }
-
isinstance = PyObject_IsInstance(ast, req_type[mode]);
if (isinstance == -1)
return NULL;
@@ -10348,11 +10374,10 @@ mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
int PyAST_Check(PyObject* obj)
{
- if (!init_types()) {
+ astmodulestate *state = get_global_ast_state();
+ if (state == NULL) {
return -1;
}
-
- astmodulestate *state = get_global_ast_state();
return PyObject_IsInstance(obj, state->AST_type);
}
More information about the Python-checkins
mailing list