/* 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.
*/
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 */
/* __doc__ */
"Intermediate representation of a Python parse tree."
-}; /* PyAST_Type */
+}; /* PyST_Type */
static int
}
-/* 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
*
*/
static int
-parser_compare(PyAST_Object *left, PyAST_Object *right)
+parser_compare(PyST_Object *left, PyST_Object *right)
{
if (left == right)
return (0);
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;
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],
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;
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);
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);
}
/* 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;
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);
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;
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);
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}
};
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");
}
*
*/
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
*
* 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.
*/
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);
}
/*
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. */
/* 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;
}
* 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)) {
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
{
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);
/* 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}
};
{
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);
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));
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);
projects / thirdparty / Python / cpython.git / commitdiff
