diff options
Diffstat (limited to 'Modules/parsermodule.c')
| -rw-r--r-- | Modules/parsermodule.c | 268 |
1 files changed, 136 insertions, 132 deletions
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c index 6ff98de..cc1a44f 100644 --- a/Modules/parsermodule.c +++ b/Modules/parsermodule.c @@ -133,22 +133,18 @@ node2tuple(node *n, /* node to convert */ /* There are two types of intermediate objects we're interested in: - * 'eval' and 'exec' types. These constants can be used in the ast_type + * 'eval' and 'exec' types. These constants can be used in the st_type * field of the object type to identify which any given object represents. * These should probably go in an external header to allow other extensions * to use them, but then, we really should be using C++ too. ;-) - * - * The PyAST_FRAGMENT type is not currently supported. Maybe not useful? - * Haven't decided yet. */ -#define PyAST_EXPR 1 -#define PyAST_SUITE 2 -#define PyAST_FRAGMENT 3 +#define PyST_EXPR 1 +#define PyST_SUITE 2 /* These are the internal objects and definitions required to implement the - * AST type. Most of the internal names are more reminiscent of the 'old' + * ST type. Most of the internal names are more reminiscent of the 'old' * naming style, but the code uses the new naming convention. */ @@ -156,29 +152,29 @@ static PyObject* parser_error = 0; -typedef struct _PyAST_Object { +typedef struct { PyObject_HEAD /* standard object header */ - node* ast_node; /* the node* returned by the parser */ - int ast_type; /* EXPR or SUITE ? */ -} PyAST_Object; + node* st_node; /* the node* returned by the parser */ + int st_type; /* EXPR or SUITE ? */ +} PyST_Object; staticforward void -parser_free(PyAST_Object *ast); +parser_free(PyST_Object *st); staticforward int -parser_compare(PyAST_Object *left, PyAST_Object *right); +parser_compare(PyST_Object *left, PyST_Object *right); staticforward PyObject * parser_getattr(PyObject *self, char *name); static -PyTypeObject PyAST_Type = { +PyTypeObject PyST_Type = { PyObject_HEAD_INIT(NULL) 0, - "ast", /* tp_name */ - (int) sizeof(PyAST_Object), /* tp_basicsize */ + "st", /* tp_name */ + (int) sizeof(PyST_Object), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)parser_free, /* tp_dealloc */ 0, /* tp_print */ @@ -202,7 +198,7 @@ PyTypeObject PyAST_Type = { /* __doc__ */ "Intermediate representation of a Python parse tree." -}; /* PyAST_Type */ +}; /* PyST_Type */ static int @@ -235,7 +231,7 @@ parser_compare_nodes(node *left, node *right) } -/* int parser_compare(PyAST_Object* left, PyAST_Object* right) +/* int parser_compare(PyST_Object* left, PyST_Object* right) * * Comparison function used by the Python operators ==, !=, <, >, <=, >= * This really just wraps a call to parser_compare_nodes() with some easy @@ -243,7 +239,7 @@ parser_compare_nodes(node *left, node *right) * */ static int -parser_compare(PyAST_Object *left, PyAST_Object *right) +parser_compare(PyST_Object *left, PyST_Object *right) { if (left == right) return (0); @@ -251,54 +247,54 @@ parser_compare(PyAST_Object *left, PyAST_Object *right) if ((left == 0) || (right == 0)) return (-1); - return (parser_compare_nodes(left->ast_node, right->ast_node)); + return (parser_compare_nodes(left->st_node, right->st_node)); } -/* parser_newastobject(node* ast) +/* parser_newstobject(node* st) * - * Allocates a new Python object representing an AST. This is simply the + * Allocates a new Python object representing an ST. This is simply the * 'wrapper' object that holds a node* and allows it to be passed around in * Python code. * */ static PyObject* -parser_newastobject(node *ast, int type) +parser_newstobject(node *st, int type) { - PyAST_Object* o = PyObject_New(PyAST_Object, &PyAST_Type); + PyST_Object* o = PyObject_New(PyST_Object, &PyST_Type); if (o != 0) { - o->ast_node = ast; - o->ast_type = type; + o->st_node = st; + o->st_type = type; } else { - PyNode_Free(ast); + PyNode_Free(st); } return ((PyObject*)o); } -/* void parser_free(PyAST_Object* ast) +/* void parser_free(PyST_Object* st) * * This is called by a del statement that reduces the reference count to 0. * */ static void -parser_free(PyAST_Object *ast) +parser_free(PyST_Object *st) { - PyNode_Free(ast->ast_node); - PyObject_Del(ast); + PyNode_Free(st->st_node); + PyObject_Del(st); } -/* parser_ast2tuple(PyObject* self, PyObject* args, PyObject* kw) +/* parser_st2tuple(PyObject* self, PyObject* args, PyObject* kw) * * This provides conversion from a node* to a tuple object that can be - * returned to the Python-level caller. The AST object is not modified. + * returned to the Python-level caller. The ST object is not modified. * */ static PyObject* -parser_ast2tuple(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_st2tuple(PyST_Object *self, PyObject *args, PyObject *kw) { PyObject *line_option = 0; PyObject *res = 0; @@ -307,8 +303,8 @@ parser_ast2tuple(PyAST_Object *self, PyObject *args, PyObject *kw) static char *keywords[] = {"ast", "line_info", NULL}; if (self == NULL) { - ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:ast2tuple", keywords, - &PyAST_Type, &self, &line_option); + ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:st2tuple", keywords, + &PyST_Type, &self, &line_option); } else ok = PyArg_ParseTupleAndKeywords(args, kw, "|O:totuple", &keywords[1], @@ -319,24 +315,24 @@ parser_ast2tuple(PyAST_Object *self, PyObject *args, PyObject *kw) lineno = (PyObject_IsTrue(line_option) != 0) ? 1 : 0; } /* - * Convert AST into a tuple representation. Use Guido's function, + * Convert ST into a tuple representation. Use Guido's function, * since it's known to work already. */ - res = node2tuple(((PyAST_Object*)self)->ast_node, + res = node2tuple(((PyST_Object*)self)->st_node, PyTuple_New, PyTuple_SetItem, lineno); } return (res); } -/* parser_ast2list(PyObject* self, PyObject* args, PyObject* kw) +/* parser_st2list(PyObject* self, PyObject* args, PyObject* kw) * * This provides conversion from a node* to a list object that can be - * returned to the Python-level caller. The AST object is not modified. + * returned to the Python-level caller. The ST object is not modified. * */ static PyObject* -parser_ast2list(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_st2list(PyST_Object *self, PyObject *args, PyObject *kw) { PyObject *line_option = 0; PyObject *res = 0; @@ -345,8 +341,8 @@ parser_ast2list(PyAST_Object *self, PyObject *args, PyObject *kw) static char *keywords[] = {"ast", "line_info", NULL}; if (self == NULL) - ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:ast2list", keywords, - &PyAST_Type, &self, &line_option); + ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:st2list", keywords, + &PyST_Type, &self, &line_option); else ok = PyArg_ParseTupleAndKeywords(args, kw, "|O:tolist", &keywords[1], &line_option); @@ -356,40 +352,40 @@ parser_ast2list(PyAST_Object *self, PyObject *args, PyObject *kw) lineno = PyObject_IsTrue(line_option) ? 1 : 0; } /* - * Convert AST into a tuple representation. Use Guido's function, + * Convert ST into a tuple representation. Use Guido's function, * since it's known to work already. */ - res = node2tuple(self->ast_node, + res = node2tuple(self->st_node, PyList_New, PyList_SetItem, lineno); } return (res); } -/* parser_compileast(PyObject* self, PyObject* args) +/* parser_compilest(PyObject* self, PyObject* args) * * This function creates code objects from the parse tree represented by * the passed-in data object. An optional file name is passed in as well. * */ static PyObject* -parser_compileast(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_compilest(PyST_Object *self, PyObject *args, PyObject *kw) { PyObject* res = 0; - char* str = "<ast>"; + char* str = "<syntax-tree>"; int ok; static char *keywords[] = {"ast", "filename", NULL}; if (self == NULL) - ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|s:compileast", keywords, - &PyAST_Type, &self, &str); + ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|s:compilest", keywords, + &PyST_Type, &self, &str); else ok = PyArg_ParseTupleAndKeywords(args, kw, "|s:compile", &keywords[1], &str); if (ok) - res = (PyObject *)PyNode_Compile(self->ast_node, str); + res = (PyObject *)PyNode_Compile(self->st_node, str); return (res); } @@ -398,12 +394,12 @@ parser_compileast(PyAST_Object *self, PyObject *args, PyObject *kw) /* PyObject* parser_isexpr(PyObject* self, PyObject* args) * PyObject* parser_issuite(PyObject* self, PyObject* args) * - * Checks the passed-in AST object to determine if it is an expression or + * Checks the passed-in ST object to determine if it is an expression or * a statement suite, respectively. The return is a Python truth value. * */ static PyObject* -parser_isexpr(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_isexpr(PyST_Object *self, PyObject *args, PyObject *kw) { PyObject* res = 0; int ok; @@ -412,13 +408,13 @@ parser_isexpr(PyAST_Object *self, PyObject *args, PyObject *kw) if (self == NULL) ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:isexpr", keywords, - &PyAST_Type, &self); + &PyST_Type, &self); else ok = PyArg_ParseTupleAndKeywords(args, kw, ":isexpr", &keywords[1]); if (ok) { - /* Check to see if the AST represents an expression or not. */ - res = (self->ast_type == PyAST_EXPR) ? Py_True : Py_False; + /* Check to see if the ST represents an expression or not. */ + res = (self->st_type == PyST_EXPR) ? Py_True : Py_False; Py_INCREF(res); } return (res); @@ -426,7 +422,7 @@ parser_isexpr(PyAST_Object *self, PyObject *args, PyObject *kw) static PyObject* -parser_issuite(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_issuite(PyST_Object *self, PyObject *args, PyObject *kw) { PyObject* res = 0; int ok; @@ -435,13 +431,13 @@ parser_issuite(PyAST_Object *self, PyObject *args, PyObject *kw) if (self == NULL) ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:issuite", keywords, - &PyAST_Type, &self); + &PyST_Type, &self); else ok = PyArg_ParseTupleAndKeywords(args, kw, ":issuite", &keywords[1]); if (ok) { - /* Check to see if the AST represents an expression or not. */ - res = (self->ast_type == PyAST_EXPR) ? Py_False : Py_True; + /* Check to see if the ST represents an expression or not. */ + res = (self->st_type == PyST_EXPR) ? Py_False : Py_True; Py_INCREF(res); } return (res); @@ -452,16 +448,16 @@ parser_issuite(PyAST_Object *self, PyObject *args, PyObject *kw) static PyMethodDef parser_methods[] = { - {"compile", (PyCFunction)parser_compileast, PUBLIC_METHOD_TYPE, - "Compile this AST object into a code object."}, + {"compile", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE, + "Compile this ST object into a code object."}, {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE, - "Determines if this AST object was created from an expression."}, + "Determines if this ST object was created from an expression."}, {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE, - "Determines if this AST object was created from a suite."}, - {"tolist", (PyCFunction)parser_ast2list, PUBLIC_METHOD_TYPE, - "Creates a list-tree representation of this AST."}, - {"totuple", (PyCFunction)parser_ast2tuple, PUBLIC_METHOD_TYPE, - "Creates a tuple-tree representation of this AST."}, + "Determines if this ST object was created from a suite."}, + {"tolist", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE, + "Creates a list-tree representation of this ST."}, + {"totuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE, + "Creates a tuple-tree representation of this ST."}, {NULL, NULL, 0, NULL} }; @@ -502,11 +498,11 @@ parser_do_parse(PyObject *args, PyObject *kw, char *argspec, int type) if (PyArg_ParseTupleAndKeywords(args, kw, argspec, keywords, &string)) { node* n = PyParser_SimpleParseString(string, - (type == PyAST_EXPR) + (type == PyST_EXPR) ? eval_input : file_input); if (n != 0) - res = parser_newastobject(n, type); + res = parser_newstobject(n, type); else err_string("could not parse string"); } @@ -523,23 +519,23 @@ parser_do_parse(PyObject *args, PyObject *kw, char *argspec, int type) * */ static PyObject* -parser_expr(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_expr(PyST_Object *self, PyObject *args, PyObject *kw) { NOTE(ARGUNUSED(self)) - return (parser_do_parse(args, kw, "s:expr", PyAST_EXPR)); + return (parser_do_parse(args, kw, "s:expr", PyST_EXPR)); } static PyObject* -parser_suite(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_suite(PyST_Object *self, PyObject *args, PyObject *kw) { NOTE(ARGUNUSED(self)) - return (parser_do_parse(args, kw, "s:suite", PyAST_SUITE)); + return (parser_do_parse(args, kw, "s:suite", PyST_SUITE)); } -/* This is the messy part of the code. Conversion from a tuple to an AST +/* This is the messy part of the code. Conversion from a tuple to an ST * object requires that the input tuple be valid without having to rely on * catching an exception from the compiler. This is done to allow the * compiler itself to remain fast, since most of its input will come from @@ -549,8 +545,8 @@ parser_suite(PyAST_Object *self, PyObject *args, PyObject *kw) * * Two aspects can be broken out in this code: creating a node tree from * the tuple passed in, and verifying that it is indeed valid. It may be - * advantageous to expand the number of AST types to include funcdefs and - * lambdadefs to take advantage of the optimizer, recognizing those ASTs + * advantageous to expand the number of ST types to include funcdefs and + * lambdadefs to take advantage of the optimizer, recognizing those STs * here. They are not necessary, and not quite as useful in a raw form. * For now, let's get expressions and suites working reliably. */ @@ -561,35 +557,35 @@ staticforward int validate_expr_tree(node *tree); staticforward int validate_file_input(node *tree); -/* PyObject* parser_tuple2ast(PyObject* self, PyObject* args) +/* PyObject* parser_tuple2st(PyObject* self, PyObject* args) * * This is the public function, called from the Python code. It receives a - * single tuple object from the caller, and creates an AST object if the + * single tuple object from the caller, and creates an ST object if the * tuple can be validated. It does this by checking the first code of the * tuple, and, if acceptable, builds the internal representation. If this * step succeeds, the internal representation is validated as fully as * possible with the various validate_*() routines defined below. * - * This function must be changed if support is to be added for PyAST_FRAGMENT - * AST objects. + * This function must be changed if support is to be added for PyST_FRAGMENT + * ST objects. * */ static PyObject* -parser_tuple2ast(PyAST_Object *self, PyObject *args, PyObject *kw) +parser_tuple2st(PyST_Object *self, PyObject *args, PyObject *kw) { NOTE(ARGUNUSED(self)) - PyObject *ast = 0; + PyObject *st = 0; PyObject *tuple; node *tree; static char *keywords[] = {"sequence", NULL}; - if (!PyArg_ParseTupleAndKeywords(args, kw, "O:sequence2ast", keywords, + if (!PyArg_ParseTupleAndKeywords(args, kw, "O:sequence2st", keywords, &tuple)) return (0); if (!PySequence_Check(tuple)) { PyErr_SetString(PyExc_ValueError, - "sequence2ast() requires a single sequence argument"); + "sequence2st() requires a single sequence argument"); return (0); } /* @@ -601,12 +597,12 @@ parser_tuple2ast(PyAST_Object *self, PyObject *args, PyObject *kw) if (start_sym == eval_input) { /* Might be an eval form. */ if (validate_expr_tree(tree)) - ast = parser_newastobject(tree, PyAST_EXPR); + st = parser_newstobject(tree, PyST_EXPR); } else if (start_sym == file_input) { /* This looks like an exec form so far. */ if (validate_file_input(tree)) - ast = parser_newastobject(tree, PyAST_SUITE); + st = parser_newstobject(tree, PyST_SUITE); } else { /* This is a fragment, at best. */ @@ -617,10 +613,10 @@ parser_tuple2ast(PyAST_Object *self, PyObject *args, PyObject *kw) /* Make sure we throw an exception on all errors. We should never * get this, but we'd do well to be sure something is done. */ - if ((ast == 0) && !PyErr_Occurred()) - err_string("unspecified AST error occurred"); + if (st == NULL && !PyErr_Occurred()) + err_string("unspecified ST error occurred"); - return (ast); + return st; } @@ -752,7 +748,7 @@ build_node_tree(PyObject *tuple) * Throw an exception now and be done with it. */ tuple = Py_BuildValue("os", tuple, - "Illegal ast tuple; cannot start with terminal symbol."); + "Illegal syntax-tree; cannot start with terminal symbol."); PyErr_SetObject(parser_error, tuple); } else if (ISNONTERMINAL(num)) { @@ -2726,12 +2722,12 @@ validate_expr_tree(node *tree) static int validate_file_input(node *tree) { - int j = 0; + int j; int nch = NCH(tree) - 1; int res = ((nch >= 0) && validate_ntype(CHILD(tree, nch), ENDMARKER)); - for ( ; res && (j < nch); ++j) { + for (j = 0; res && (j < nch); ++j) { if (TYPE(CHILD(tree, j)) == stmt) res = validate_stmt(CHILD(tree, j)); else @@ -2757,18 +2753,18 @@ parser__pickler(PyObject *self, PyObject *args) { NOTE(ARGUNUSED(self)) PyObject *result = NULL; - PyObject *ast = NULL; + PyObject *st = NULL; PyObject *empty_dict = NULL; - if (PyArg_ParseTuple(args, "O!:_pickler", &PyAST_Type, &ast)) { + if (PyArg_ParseTuple(args, "O!:_pickler", &PyST_Type, &st)) { PyObject *newargs; PyObject *tuple; if ((empty_dict = PyDict_New()) == NULL) goto finally; - if ((newargs = Py_BuildValue("Oi", ast, 1)) == NULL) + if ((newargs = Py_BuildValue("Oi", st, 1)) == NULL) goto finally; - tuple = parser_ast2tuple((PyAST_Object*)NULL, newargs, empty_dict); + tuple = parser_st2tuple((PyST_Object*)NULL, newargs, empty_dict); if (tuple != NULL) { result = Py_BuildValue("O(O)", pickle_constructor, tuple); Py_DECREF(tuple); @@ -2784,34 +2780,44 @@ parser__pickler(PyObject *self, PyObject *args) /* Functions exported by this module. Most of this should probably - * be converted into an AST object with methods, but that is better + * be converted into an ST object with methods, but that is better * done directly in Python, allowing subclasses to be created directly. * We'd really have to write a wrapper around it all anyway to allow * inheritance. */ static PyMethodDef parser_functions[] = { - {"ast2tuple", (PyCFunction)parser_ast2tuple, PUBLIC_METHOD_TYPE, - "Creates a tuple-tree representation of an AST."}, - {"ast2list", (PyCFunction)parser_ast2list, PUBLIC_METHOD_TYPE, - "Creates a list-tree representation of an AST."}, - {"compileast", (PyCFunction)parser_compileast, PUBLIC_METHOD_TYPE, - "Compiles an AST object into a code object."}, - {"expr", (PyCFunction)parser_expr, PUBLIC_METHOD_TYPE, - "Creates an AST object from an expression."}, - {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE, - "Determines if an AST object was created from an expression."}, - {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE, - "Determines if an AST object was created from a suite."}, - {"suite", (PyCFunction)parser_suite, PUBLIC_METHOD_TYPE, - "Creates an AST object from a suite."}, - {"sequence2ast", (PyCFunction)parser_tuple2ast, PUBLIC_METHOD_TYPE, - "Creates an AST object from a tree representation."}, - {"tuple2ast", (PyCFunction)parser_tuple2ast, PUBLIC_METHOD_TYPE, - "Creates an AST object from a tree representation."}, + {"ast2tuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE, + "Creates a tuple-tree representation of an ST."}, + {"ast2list", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE, + "Creates a list-tree representation of an ST."}, + {"compileast", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE, + "Compiles an ST object into a code object."}, + {"compilest", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE, + "Compiles an ST object into a code object."}, + {"expr", (PyCFunction)parser_expr, PUBLIC_METHOD_TYPE, + "Creates an ST object from an expression."}, + {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE, + "Determines if an ST object was created from an expression."}, + {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE, + "Determines if an ST object was created from a suite."}, + {"suite", (PyCFunction)parser_suite, PUBLIC_METHOD_TYPE, + "Creates an ST object from a suite."}, + {"sequence2ast", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, + "Creates an ST object from a tree representation."}, + {"sequence2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, + "Creates an ST object from a tree representation."}, + {"st2tuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE, + "Creates a tuple-tree representation of an ST."}, + {"st2list", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE, + "Creates a list-tree representation of an ST."}, + {"tuple2ast", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, + "Creates an ST object from a tree representation."}, + {"tuple2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, + "Creates an ST object from a tree representation."}, /* private stuff: support pickle module */ {"_pickler", (PyCFunction)parser__pickler, METH_VARARGS, - "Returns the pickle magic to allow ast objects to be pickled."}, + "Returns the pickle magic to allow ST objects to be pickled."}, {NULL, NULL, 0, NULL} }; @@ -2824,8 +2830,8 @@ initparser(void) { PyObject* module; PyObject* dict; - - PyAST_Type.ob_type = &PyType_Type; + + PyST_Type.ob_type = &PyType_Type; module = Py_InitModule("parser", parser_functions); dict = PyModule_GetDict(module); @@ -2833,16 +2839,14 @@ initparser(void) parser_error = PyErr_NewException("parser.ParserError", NULL, NULL); if ((parser_error == 0) - || (PyDict_SetItemString(dict, "ParserError", parser_error) != 0)) - { - /* caller will check PyErr_Occurred() */ - return; + || (PyDict_SetItemString(dict, "ParserError", parser_error) != 0)) { + /* caller will check PyErr_Occurred() */ + return; } - /* - * Nice to have, but don't cry if we fail. - */ - Py_INCREF(&PyAST_Type); - PyDict_SetItemString(dict, "ASTType", (PyObject*)&PyAST_Type); + Py_INCREF(&PyST_Type); + PyDict_SetItemString(dict, "ASTType", (PyObject*)&PyST_Type); + Py_INCREF(&PyST_Type); + PyDict_SetItemString(dict, "STType", (PyObject*)&PyST_Type); PyDict_SetItemString(dict, "__copyright__", PyString_FromString(parser_copyright_string)); @@ -2857,15 +2861,15 @@ initparser(void) PyObject *func, *pickler; func = PyObject_GetAttrString(module, "pickle"); - pickle_constructor = PyDict_GetItemString(dict, "sequence2ast"); + pickle_constructor = PyDict_GetItemString(dict, "sequence2st"); pickler = PyDict_GetItemString(dict, "_pickler"); Py_XINCREF(pickle_constructor); if ((func != NULL) && (pickle_constructor != NULL) && (pickler != NULL)) { PyObject *res; - res = PyObject_CallFunction( - func, "OOO", &PyAST_Type, pickler, pickle_constructor); + res = PyObject_CallFunction(func, "OOO", &PyST_Type, pickler, + pickle_constructor); Py_XDECREF(res); } Py_XDECREF(func); |