diff options
| -rw-r--r-- | Doc/lib/lib.tex | 1 | ||||
| -rw-r--r-- | Doc/lib/libast.tex | 46 | ||||
| -rw-r--r-- | Misc/NEWS | 2 | ||||
| -rw-r--r-- | Modules/config.c.in | 4 | ||||
| -rw-r--r-- | PC/config.c | 2 | ||||
| -rwxr-xr-x | Parser/asdl_c.py | 277 | ||||
| -rw-r--r-- | Python/Python-ast.c | 374 |
7 files changed, 485 insertions, 221 deletions
diff --git a/Doc/lib/lib.tex b/Doc/lib/lib.tex index 44e7c96..fad8fe7 100644 --- a/Doc/lib/lib.tex +++ b/Doc/lib/lib.tex @@ -416,6 +416,7 @@ and how to embed it in other applications. \input{distutils} \input{compiler} % compiler package +\input{libast} \input{libmisc} % Miscellaneous Services \input{libformatter} diff --git a/Doc/lib/libast.tex b/Doc/lib/libast.tex new file mode 100644 index 0000000..9fdd4fb --- /dev/null +++ b/Doc/lib/libast.tex @@ -0,0 +1,46 @@ +% XXX Label can't be _ast? +% XXX Where should this section/chapter go? +\chapter{Abstract Syntax Trees\label{ast}} + +\sectionauthor{Martin v. L\"owis}{martin@v.loewis.de} + +The \code{_ast} module helps Python applications to process +trees of the Python abstract syntax grammar. The Python compiler +currently provides read-only access to such trees, meaning that +applications can only create a tree for a given piece of Python +source code; generating byte code from a (potentially modified) +tree is not supported. The abstract syntax itself might change with +each Python release; this module helps to find out programmatically +what the current grammar looks like. + +An abstract syntax tree can be generated by passing \code{_ast.PyCF_ONLY_AST} +as a flag to the \function{compile} builtin function. The result will be a tree +of objects whose classes all inherit from \code{_ast.AST}. + +The actual classes are derived from the \code{Parser/Python.asdl} file, +which is reproduced below. There is one class defined for each left-hand +side symbol in the abstract grammar (for example, \code{_ast.stmt} or \code{_ast.expr}). +In addition, there is one class defined for each constructor on the +right-hand side; these classes inherit from the classes for the left-hand +side trees. For example, \code{_ast.BinOp} inherits from \code{_ast.expr}. +For production rules with alternatives (aka "sums"), the left-hand side +class is abstract: only instances of specific constructor nodes are ever +created. + +Each concrete class has an attribute \code{_fields} which gives the +names of all child nodes. + +Each instance of a concrete class has one attribute for each child node, +of the type as defined in the grammar. For example, \code{_ast.BinOp} +instances have an attribute \code{left} of type \code{_ast.expr}. + +If these attributes are marked as optional in the grammar (using a +question mark), the value might be \code{None}. If the attributes +can have zero-or-more values (marked with an asterisk), the +values are represented as Python lists. + +\subsection{Abstract Grammar} + +The abstract grammar is currently defined as follows: + +\verbatiminput{../../Parser/Python.asdl}
\ No newline at end of file @@ -76,7 +76,7 @@ Core and builtins - A new AST parser implementation was completed. The abstract syntax tree is available for read-only (non-compile) access - to Python code. + to Python code; an _ast module was added. - SF bug #1167751: fix incorrect code being for generator expressions. The following code now raises a SyntaxError: foo(a = i for i in range(10)) diff --git a/Modules/config.c.in b/Modules/config.c.in index 3b4d037..9ec281c 100644 --- a/Modules/config.c.in +++ b/Modules/config.c.in @@ -23,6 +23,7 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. extern void PyMarshal_Init(void); extern void initimp(void); extern void initgc(void); +extern void init_ast(void); struct _inittab _PyImport_Inittab[] = { @@ -34,6 +35,9 @@ struct _inittab _PyImport_Inittab[] = { /* This lives in import.c */ {"imp", initimp}, + /* This lives in Python/Python-ast.c */ + {"_ast", init_ast}, + /* These entries are here for sys.builtin_module_names */ {"__main__", NULL}, {"__builtin__", NULL}, diff --git a/PC/config.c b/PC/config.c index 45a0977..ee62dc5 100644 --- a/PC/config.c +++ b/PC/config.c @@ -67,6 +67,7 @@ extern void init_codecs_kr(void); extern void init_codecs_tw(void); extern void init_subprocess(void); extern void init_lsprof(void); +extern void init_ast(void); /* tools/freeze/makeconfig.py marker for additional "extern" */ /* -- ADDMODULE MARKER 1 -- */ @@ -77,6 +78,7 @@ extern void initimp(void); struct _inittab _PyImport_Inittab[] = { {"array", initarray}, + {"_ast", init_ast}, #ifdef MS_WINDOWS #ifndef MS_WIN64 {"audioop", initaudioop}, diff --git a/Parser/asdl_c.py b/Parser/asdl_c.py index e1dd463..4ac3f74 100755 --- a/Parser/asdl_c.py +++ b/Parser/asdl_c.py @@ -346,10 +346,6 @@ class MarshalPrototypeVisitor(PickleVisitor): class PyTypesDeclareVisitor(PickleVisitor): - def prototype(self, sum, name): - ctype = get_c_type(name) - self.emit("void free_%s(%s);" % (name, ctype), 0) - def visitProduct(self, prod, name): self.emit("PyTypeObject *%s_type;" % name, 0) self.emit("static PyObject* ast2obj_%s(void*);" % name, 0) @@ -361,6 +357,11 @@ class PyTypesDeclareVisitor(PickleVisitor): def visitSum(self, sum, name): self.emit("PyTypeObject *%s_type;" % name, 0) + if sum.attributes: + self.emit("char *%s_attributes[] = {" % name, 0) + for a in sum.attributes: + self.emit('"%s",' % a.name, 1) + self.emit("};", 0) ptype = "void*" if is_simple(sum): ptype = get_c_type(name) @@ -404,11 +405,28 @@ static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int } PyTuple_SET_ITEM(fnames, i, field); } - result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sO}", type, base, "_fields", fnames); + result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}", + type, base, "_fields", fnames, "__module__", "_ast"); Py_DECREF(fnames); return (PyTypeObject*)result; } +static int add_attributes(PyTypeObject* type, char**attrs, int num_fields) +{ + int i; + PyObject *s, *l = PyList_New(num_fields); + if (!l) return 0; + for(i=0; i < num_fields; i++) { + s = PyString_FromString(attrs[i]); + if (!s) { + Py_DECREF(l); + return 0; + } + PyList_SET_ITEM(l, i, s); + } + return PyObject_SetAttrString((PyObject*)type, "_attributes", l) >=0; +} + static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*)) { int i, n = asdl_seq_LEN(seq); @@ -440,16 +458,22 @@ static PyObject* ast2obj_bool(bool b) { return PyBool_FromLong(b); } + +static PyObject* ast2obj_int(bool b) +{ + return PyInt_FromLong(b); +} """, 0, reflow=False) self.emit("static int initialized;", 0) self.emit("static int init_types(void)",0) self.emit("{", 0) self.emit("if (initialized) return 1;", 1) - self.emit("initialized = 1;", 1) + self.emit('AST_type = make_type("AST", &PyBaseObject_Type, NULL, 0);', 1) for dfn in mod.dfns: self.visit(dfn) - self.emit("return 1;", 0); + self.emit("initialized = 1;", 1) + self.emit("return 1;", 1); self.emit("}", 0) def visitProduct(self, prod, name): @@ -457,11 +481,18 @@ static PyObject* ast2obj_bool(bool b) fields = name.value+"_fields" else: fields = "NULL" - self.emit('%s_type = make_type("%s", &PyBaseObject_Type, %s, %d);' % + self.emit('%s_type = make_type("%s", AST_type, %s, %d);' % (name, name, fields, len(prod.fields)), 1) + self.emit("if (!%s_type) return 0;" % name, 1) def visitSum(self, sum, name): - self.emit('%s_type = make_type("%s", &PyBaseObject_Type, NULL, 0);' % (name, name), 1) + self.emit('%s_type = make_type("%s", AST_type, NULL, 0);' % (name, name), 1) + self.emit("if (!%s_type) return 0;" % name, 1) + if sum.attributes: + self.emit("if (!add_attributes(%s_type, %s_attributes, %d)) return 0;" % + (name, name, len(sum.attributes)), 1) + else: + self.emit("if (!add_attributes(%s_type, NULL, 0)) return 0;" % name, 1) simple = is_simple(sum) for t in sum.types: self.visitConstructor(t, name, simple) @@ -473,9 +504,43 @@ static PyObject* ast2obj_bool(bool b) fields = "NULL" self.emit('%s_type = make_type("%s", %s_type, %s, %d);' % (cons.name, cons.name, name, fields, len(cons.fields)), 1) + self.emit("if (!%s_type) return 0;" % cons.name, 1) if simple: self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" % (cons.name, cons.name), 1) + self.emit("if (!%s_singleton) return 0;" % cons.name, 1) + +class ASTModuleVisitor(PickleVisitor): + + def visitModule(self, mod): + self.emit("PyMODINIT_FUNC", 0) + self.emit("init_ast(void)", 0) + self.emit("{", 0) + self.emit("PyObject *m, *d;", 1) + self.emit("if (!init_types()) return;", 1) + self.emit('m = Py_InitModule3("_ast", NULL, NULL);', 1) + self.emit("if (!m) return;", 1) + self.emit("d = PyModule_GetDict(m);", 1) + self.emit('if (PyDict_SetItemString(d, "AST", (PyObject*)AST_type) < 0) return;', 1) + self.emit('if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)', 1) + self.emit("return;", 2) + for dfn in mod.dfns: + self.visit(dfn) + self.emit("}", 0) + + def visitProduct(self, prod, name): + self.addObj(name) + + def visitSum(self, sum, name): + self.addObj(name) + for t in sum.types: + self.visitConstructor(t, name) + + def visitConstructor(self, cons, name): + self.addObj(cons.name) + + def addObj(self, name): + self.emit('if(PyDict_SetItemString(d, "%s", (PyObject*)%s_type) < 0) return;' % (name, name), 1) _SPECIALIZED_SEQUENCES = ('stmt', 'expr') @@ -502,32 +567,9 @@ class StaticVisitor(PickleVisitor): def visit(self, object): self.emit(self.CODE, 0, reflow=False) -class FreeUtilVisitor(StaticVisitor): - - CODE = '''static void -free_seq_exprs(asdl_seq *seq) -{ - int i, n; - n = asdl_seq_LEN(seq); - for (i = 0; i < n; i++) - free_expr((expr_ty)asdl_seq_GET(seq, i)); - asdl_seq_free(seq); -} - -static void -free_seq_stmts(asdl_seq *seq) -{ - int i, n; - n = asdl_seq_LEN(seq); - for (i = 0; i < n; i++) - free_stmt((stmt_ty)asdl_seq_GET(seq, i)); - asdl_seq_free(seq); -} -''' - class ObjVisitor(PickleVisitor): - def func_begin(self, name, has_seq): + def func_begin(self, name): ctype = get_c_type(name) self.emit("PyObject*", 0) self.emit("ast2obj_%s(void* _o)" % (name), 0) @@ -540,7 +582,7 @@ class ObjVisitor(PickleVisitor): self.emit("}", 1) self.emit('', 0) - def func_end(self, has_seq): + def func_end(self): self.emit("return result;", 1) self.emit("failed:", 0) self.emit("Py_XDECREF(value);", 1) @@ -553,15 +595,17 @@ class ObjVisitor(PickleVisitor): if is_simple(sum): self.simpleSum(sum, name) return - has_seq = has_sequence(sum.types, False) - self.func_begin(name, has_seq) + self.func_begin(name) self.emit("switch (o->kind) {", 1) for i in range(len(sum.types)): t = sum.types[i] self.visitConstructor(t, i + 1, name) self.emit("}", 1) - self.emit("", 0) - self.func_end(has_seq) + for a in sum.attributes: + self.emit("value = ast2obj_%s(o->%s);" % (a.type, a.name), 1) + self.emit("if (!value) goto failed;", 1) + self.emit('PyObject_SetAttrString(result, "%s", value);' % a.name, 1) + self.func_end() def simpleSum(self, sum, name): self.emit("PyObject* ast2obj_%s(%s_ty o)" % (name, name), 0) @@ -576,14 +620,12 @@ class ObjVisitor(PickleVisitor): self.emit("}", 0) def visitProduct(self, prod, name): - has_seq = find_sequence(prod.fields, False) - self.func_begin(name, has_seq) + self.func_begin(name) self.emit("result = PyType_GenericNew(%s_type, NULL, NULL);" % name, 1); self.emit("if (!result) return NULL;", 1) for field in prod.fields: self.visitField(field, name, 1, True) - self.emit("", 0) - self.func_end(has_seq) + self.func_end() def visitConstructor(self, cons, enum, name): self.emit("case %s_kind:" % cons.name, 1) @@ -640,150 +682,6 @@ class ObjVisitor(PickleVisitor): self.emit("value = ast2obj_%s(%s);" % (field.type, value), depth, reflow=False) -class MarshalUtilVisitor(StaticVisitor): - - CODE = ''' -#define CHECKSIZE(BUF, OFF, MIN) { \\ - int need = *(OFF) + MIN; \\ - if (need >= PyString_GET_SIZE(*(BUF))) { \\ - int newsize = PyString_GET_SIZE(*(BUF)) * 2; \\ - if (newsize < need) \\ - newsize = need; \\ - if (_PyString_Resize((BUF), newsize) < 0) \\ - return 0; \\ - } \\ -} - -static int -marshal_write_int(PyObject **buf, int *offset, int x) -{ - char *s; - - CHECKSIZE(buf, offset, 4) - s = PyString_AS_STRING(*buf) + (*offset); - s[0] = (x & 0xff); - s[1] = (x >> 8) & 0xff; - s[2] = (x >> 16) & 0xff; - s[3] = (x >> 24) & 0xff; - *offset += 4; - return 1; -} - -static int -marshal_write_bool(PyObject **buf, int *offset, bool b) -{ - if (b) - marshal_write_int(buf, offset, 1); - else - marshal_write_int(buf, offset, 0); - return 1; -} - -static int -marshal_write_identifier(PyObject **buf, int *offset, identifier id) -{ - int l = PyString_GET_SIZE(id); - marshal_write_int(buf, offset, l); - CHECKSIZE(buf, offset, l); - memcpy(PyString_AS_STRING(*buf) + *offset, - PyString_AS_STRING(id), l); - *offset += l; - return 1; -} - -static int -marshal_write_string(PyObject **buf, int *offset, string s) -{ - int len = PyString_GET_SIZE(s); - marshal_write_int(buf, offset, len); - CHECKSIZE(buf, offset, len); - memcpy(PyString_AS_STRING(*buf) + *offset, - PyString_AS_STRING(s), len); - *offset += len; - return 1; -} - -static int -marshal_write_object(PyObject **buf, int *offset, object s) -{ - /* XXX */ - return 0; -} -''' - -class MarshalFunctionVisitor(PickleVisitor): - - def func_begin(self, name, has_seq): - ctype = get_c_type(name) - self.emit("static int", 0) - self.emit("marshal_write_%s(PyObject **buf, int *off, %s o)" % - (name, ctype), 0) - self.emit("{", 0) - if has_seq: - self.emit("int i;", 1) - - def func_end(self): - self.emit("return 1;", 1) - self.emit("}", 0) - self.emit("", 0) - - def visitSum(self, sum, name): - self.func_begin(name, has_sequence(sum.types, False)) - simple = is_simple(sum) - if simple: - self.emit("switch (o) {", 1) - else: - self.emit("switch (o->kind) {", 1) - for i in range(len(sum.types)): - t = sum.types[i] - self.visitConstructor(t, i + 1, name, simple) - self.emit("}", 1) - self.func_end() - - def visitProduct(self, prod, name): - self.func_begin(name, find_sequence(prod.fields, False)) - for field in prod.fields: - self.visitField(field, name, 1, 1) - self.func_end() - - def visitConstructor(self, cons, enum, name, simple): - if simple: - self.emit("case %s:" % cons.name, 1) - self.emit("marshal_write_int(buf, off, %d);" % enum, 2); - self.emit("break;", 2) - else: - self.emit("case %s_kind:" % cons.name, 1) - self.emit("marshal_write_int(buf, off, %d);" % enum, 2) - for f in cons.fields: - self.visitField(f, cons.name, 2, 0) - self.emit("break;", 2) - - def visitField(self, field, name, depth, product): - def emit(s, d): - self.emit(s, depth + d) - if product: - value = "o->%s" % field.name - else: - value = "o->v.%s.%s" % (name, field.name) - if field.seq: - emit("marshal_write_int(buf, off, asdl_seq_LEN(%s));" % value, 0) - emit("for (i = 0; i < asdl_seq_LEN(%s); i++) {" % value, 0) - emit("void *elt = asdl_seq_GET(%s, i);" % value, 1); - ctype = get_c_type(field.type); - emit("marshal_write_%s(buf, off, (%s)elt);" % (field.type, - ctype), 1) - emit("}", 0) - elif field.opt: - emit("if (%s) {" % value, 0) - emit("marshal_write_int(buf, off, 1);", 1) - emit("marshal_write_%s(buf, off, %s);" % (field.type, value), 1) - emit("}", 0) - emit("else {", 0) - emit("marshal_write_int(buf, off, 0);", 1) - emit("}", 0) - else: - emit("marshal_write_%s(buf, off, %s);" % (field.type, value), 0) - class PartingShots(StaticVisitor): CODE = """ @@ -821,7 +719,6 @@ def main(srcfile): c = ChainOfVisitors(TypeDefVisitor(f), StructVisitor(f), PrototypeVisitor(f), -## FreePrototypeVisitor(f), ) c.visit(mod) print >>f, "PyObject* PyAST_mod2obj(mod_ty t);" @@ -836,15 +733,13 @@ def main(srcfile): print >> f, '#include "Python.h"' print >> f, '#include "%s-ast.h"' % mod.name print >> f + print >>f, "PyTypeObject* AST_type;" v = ChainOfVisitors( - # MarshalPrototypeVisitor(f), PyTypesDeclareVisitor(f), PyTypesVisitor(f), FunctionVisitor(f), -## FreeUtilVisitor(f), ObjVisitor(f), - #MarshalUtilVisitor(f), - #MarshalFunctionVisitor(f), + ASTModuleVisitor(f), PartingShots(f), ) v.visit(mod) diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 8d148e3..f3b4053 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -3,6 +3,7 @@ #include "Python.h" #include "Python-ast.h" +PyTypeObject* AST_type; PyTypeObject *mod_type; static PyObject* ast2obj_mod(void*); PyTypeObject *Module_type; @@ -22,6 +23,9 @@ char *Suite_fields[]={ "body", }; PyTypeObject *stmt_type; +char *stmt_attributes[] = { + "lineno", +}; static PyObject* ast2obj_stmt(void*); PyTypeObject *FunctionDef_type; char *FunctionDef_fields[]={ @@ -129,6 +133,9 @@ PyTypeObject *Pass_type; PyTypeObject *Break_type; PyTypeObject *Continue_type; PyTypeObject *expr_type; +char *expr_attributes[] = { + "lineno", +}; static PyObject* ast2obj_expr(void*); PyTypeObject *BoolOp_type; char *BoolOp_fields[]={ @@ -357,11 +364,28 @@ static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int } PyTuple_SET_ITEM(fnames, i, field); } - result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sO}", type, base, "_fields", fnames); + result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}", + type, base, "_fields", fnames, "__module__", "_ast"); Py_DECREF(fnames); return (PyTypeObject*)result; } +static int add_attributes(PyTypeObject* type, char**attrs, int num_fields) +{ + int i; + PyObject *s, *l = PyList_New(num_fields); + if (!l) return 0; + for(i=0; i < num_fields; i++) { + s = PyString_FromString(attrs[i]); + if (!s) { + Py_DECREF(l); + return 0; + } + PyList_SET_ITEM(l, i, s); + } + return PyObject_SetAttrString((PyObject*)type, "_attributes", l) >=0; +} + static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*)) { int i, n = asdl_seq_LEN(seq); @@ -394,154 +418,297 @@ static PyObject* ast2obj_bool(bool b) return PyBool_FromLong(b); } +static PyObject* ast2obj_int(bool b) +{ + return PyInt_FromLong(b); +} + static int initialized; static int init_types(void) { if (initialized) return 1; - initialized = 1; - mod_type = make_type("mod", &PyBaseObject_Type, NULL, 0); + AST_type = make_type("AST", &PyBaseObject_Type, NULL, 0); + mod_type = make_type("mod", AST_type, NULL, 0); + if (!mod_type) return 0; + if (!add_attributes(mod_type, NULL, 0)) return 0; Module_type = make_type("Module", mod_type, Module_fields, 1); + if (!Module_type) return 0; Interactive_type = make_type("Interactive", mod_type, Interactive_fields, 1); + if (!Interactive_type) return 0; Expression_type = make_type("Expression", mod_type, Expression_fields, 1); + if (!Expression_type) return 0; Suite_type = make_type("Suite", mod_type, Suite_fields, 1); - stmt_type = make_type("stmt", &PyBaseObject_Type, NULL, 0); + if (!Suite_type) return 0; + stmt_type = make_type("stmt", AST_type, NULL, 0); + if (!stmt_type) return 0; + if (!add_attributes(stmt_type, stmt_attributes, 1)) return 0; FunctionDef_type = make_type("FunctionDef", stmt_type, FunctionDef_fields, 4); + if (!FunctionDef_type) return 0; ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 3); + if (!ClassDef_type) return 0; Return_type = make_type("Return", stmt_type, Return_fields, 1); + if (!Return_type) return 0; Delete_type = make_type("Delete", stmt_type, Delete_fields, 1); + if (!Delete_type) return 0; Assign_type = make_type("Assign", stmt_type, Assign_fields, 2); + if (!Assign_type) return 0; AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3); + if (!AugAssign_type) return 0; Print_type = make_type("Print", stmt_type, Print_fields, 3); + if (!Print_type) return 0; For_type = make_type("For", stmt_type, For_fields, 4); + if (!For_type) return 0; While_type = make_type("While", stmt_type, While_fields, 3); + if (!While_type) return 0; If_type = make_type("If", stmt_type, If_fields, 3); + if (!If_type) return 0; Raise_type = make_type("Raise", stmt_type, Raise_fields, 3); + if (!Raise_type) return 0; TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3); + if (!TryExcept_type) return 0; TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields, 2); + if (!TryFinally_type) return 0; Assert_type = make_type("Assert", stmt_type, Assert_fields, 2); + if (!Assert_type) return 0; Import_type = make_type("Import", stmt_type, Import_fields, 1); + if (!Import_type) return 0; ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields, 2); + if (!ImportFrom_type) return 0; Exec_type = make_type("Exec", stmt_type, Exec_fields, 3); + if (!Exec_type) return 0; Global_type = make_type("Global", stmt_type, Global_fields, 1); + if (!Global_type) return 0; Expr_type = make_type("Expr", stmt_type, Expr_fields, 1); + if (!Expr_type) return 0; Pass_type = make_type("Pass", stmt_type, NULL, 0); + if (!Pass_type) return 0; Break_type = make_type("Break", stmt_type, NULL, 0); + if (!Break_type) return 0; Continue_type = make_type("Continue", stmt_type, NULL, 0); - expr_type = make_type("expr", &PyBaseObject_Type, NULL, 0); + if (!Continue_type) return 0; + expr_type = make_type("expr", AST_type, NULL, 0); + if (!expr_type) return 0; + if (!add_attributes(expr_type, expr_attributes, 1)) return 0; BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2); + if (!BoolOp_type) return 0; BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3); + if (!BinOp_type) return 0; UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2); + if (!UnaryOp_type) return 0; Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2); + if (!Lambda_type) return 0; IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3); + if (!IfExp_type) return 0; Dict_type = make_type("Dict", expr_type, Dict_fields, 2); + if (!Dict_type) return 0; ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2); + if (!ListComp_type) return 0; GeneratorExp_type = make_type("GeneratorExp", expr_type, GeneratorExp_fields, 2); + if (!GeneratorExp_type) return 0; Yield_type = make_type("Yield", expr_type, Yield_fields, 1); + if (!Yield_type) return 0; Compare_type = make_type("Compare", expr_type, Compare_fields, 3); + if (!Compare_type) return 0; Call_type = make_type("Call", expr_type, Call_fields, 5); + if (!Call_type) return 0; Repr_type = make_type("Repr", expr_type, Repr_fields, 1); + if (!Repr_type) return 0; Num_type = make_type("Num", expr_type, Num_fields, 1); + if (!Num_type) return 0; Str_type = make_type("Str", expr_type, Str_fields, 1); + if (!Str_type) return 0; Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3); + if (!Attribute_type) return 0; Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3); + if (!Subscript_type) return 0; Name_type = make_type("Name", expr_type, Name_fields, 2); + if (!Name_type) return 0; List_type = make_type("List", expr_type, List_fields, 2); + if (!List_type) return 0; Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2); - expr_context_type = make_type("expr_context", &PyBaseObject_Type, NULL, - 0); + if (!Tuple_type) return 0; + expr_context_type = make_type("expr_context", AST_type, NULL, 0); + if (!expr_context_type) return 0; + if (!add_attributes(expr_context_type, NULL, 0)) return 0; Load_type = make_type("Load", expr_context_type, NULL, 0); + if (!Load_type) return 0; Load_singleton = PyType_GenericNew(Load_type, NULL, NULL); + if (!Load_singleton) return 0; Store_type = make_type("Store", expr_context_type, NULL, 0); + if (!Store_type) return 0; Store_singleton = PyType_GenericNew(Store_type, NULL, NULL); + if (!Store_singleton) return 0; Del_type = make_type("Del", expr_context_type, NULL, 0); + if (!Del_type) return 0; Del_singleton = PyType_GenericNew(Del_type, NULL, NULL); + if (!Del_singleton) return 0; AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0); + if (!AugLoad_type) return 0; AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL); + if (!AugLoad_singleton) return 0; AugStore_type = make_type("AugStore", expr_context_type, NULL, 0); + if (!AugStore_type) return 0; AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL); + if (!AugStore_singleton) return 0; Param_type = make_type("Param", expr_context_type, NULL, 0); + if (!Param_type) return 0; Param_singleton = PyType_GenericNew(Param_type, NULL, NULL); - slice_type = make_type("slice", &PyBaseObject_Type, NULL, 0); + if (!Param_singleton) return 0; + slice_type = make_type("slice", AST_type, NULL, 0); + if (!slice_type) return 0; + if (!add_attributes(slice_type, NULL, 0)) return 0; Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0); + if (!Ellipsis_type) return 0; Slice_type = make_type("Slice", slice_type, Slice_fields, 3); + if (!Slice_type) return 0; ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1); + if (!ExtSlice_type) return 0; Index_type = make_type("Index", slice_type, Index_fields, 1); - boolop_type = make_type("boolop", &PyBaseObject_Type, NULL, 0); + if (!Index_type) return 0; + boolop_type = make_type("boolop", AST_type, NULL, 0); + if (!boolop_type) return 0; + if (!add_attributes(boolop_type, NULL, 0)) return 0; And_type = make_type("And", boolop_type, NULL, 0); + if (!And_type) return 0; And_singleton = PyType_GenericNew(And_type, NULL, NULL); + if (!And_singleton) return 0; Or_type = make_type("Or", boolop_type, NULL, 0); + if (!Or_type) return 0; Or_singleton = PyType_GenericNew(Or_type, NULL, NULL); - operator_type = make_type("operator", &PyBaseObject_Type, NULL, 0); + if (!Or_singleton) return 0; + operator_type = make_type("operator", AST_type, NULL, 0); + if (!operator_type) return 0; + if (!add_attributes(operator_type, NULL, 0)) return 0; Add_type = make_type("Add", operator_type, NULL, 0); + if (!Add_type) return 0; Add_singleton = PyType_GenericNew(Add_type, NULL, NULL); + if (!Add_singleton) return 0; Sub_type = make_type("Sub", operator_type, NULL, 0); + if (!Sub_type) return 0; Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL); + if (!Sub_singleton) return 0; Mult_type = make_type("Mult", operator_type, NULL, 0); + if (!Mult_type) return 0; Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL); + if (!Mult_singleton) return 0; Div_type = make_type("Div", operator_type, NULL, 0); + if (!Div_type) return 0; Div_singleton = PyType_GenericNew(Div_type, NULL, NULL); + if (!Div_singleton) return 0; Mod_type = make_type("Mod", operator_type, NULL, 0); + if (!Mod_type) return 0; Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL); + if (!Mod_singleton) return 0; Pow_type = make_type("Pow", operator_type, NULL, 0); + if (!Pow_type) return 0; Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL); + if (!Pow_singleton) return 0; LShift_type = make_type("LShift", operator_type, NULL, 0); + if (!LShift_type) return 0; LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL); + if (!LShift_singleton) return 0; RShift_type = make_type("RShift", operator_type, NULL, 0); + if (!RShift_type) return 0; RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL); + if (!RShift_singleton) return 0; BitOr_type = make_type("BitOr", operator_type, NULL, 0); + if (!BitOr_type) return 0; BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL); + if (!BitOr_singleton) return 0; BitXor_type = make_type("BitXor", operator_type, NULL, 0); + if (!BitXor_type) return 0; BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL); + if (!BitXor_singleton) return 0; BitAnd_type = make_type("BitAnd", operator_type, NULL, 0); + if (!BitAnd_type) return 0; BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL); + if (!BitAnd_singleton) return 0; FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0); + if (!FloorDiv_type) return 0; FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL); - unaryop_type = make_type("unaryop", &PyBaseObject_Type, NULL, 0); + if (!FloorDiv_singleton) return 0; + unaryop_type = make_type("unaryop", AST_type, NULL, 0); + if (!unaryop_type) return 0; + if (!add_attributes(unaryop_type, NULL, 0)) return 0; Invert_type = make_type("Invert", unaryop_type, NULL, 0); + if (!Invert_type) return 0; Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL); + if (!Invert_singleton) return 0; Not_type = make_type("Not", unaryop_type, NULL, 0); + if (!Not_type) return 0; Not_singleton = PyType_GenericNew(Not_type, NULL, NULL); + if (!Not_singleton) return 0; UAdd_type = make_type("UAdd", unaryop_type, NULL, 0); + if (!UAdd_type) return 0; UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL); + if (!UAdd_singleton) return 0; USub_type = make_type("USub", unaryop_type, NULL, 0); + if (!USub_type) return 0; USub_singleton = PyType_GenericNew(USub_type, NULL, NULL); - cmpop_type = make_type("cmpop", &PyBaseObject_Type, NULL, 0); + if (!USub_singleton) return 0; + cmpop_type = make_type("cmpop", AST_type, NULL, 0); + if (!cmpop_type) return 0; + if (!add_attributes(cmpop_type, NULL, 0)) return 0; Eq_type = make_type("Eq", cmpop_type, NULL, 0); + if (!Eq_type) return 0; Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL); + if (!Eq_singleton) return 0; NotEq_type = make_type("NotEq", cmpop_type, NULL, 0); + if (!NotEq_type) return 0; NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL); + if (!NotEq_singleton) return 0; Lt_type = make_type("Lt", cmpop_type, NULL, 0); + if (!Lt_type) return 0; Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL); + if (!Lt_singleton) return 0; LtE_type = make_type("LtE", cmpop_type, NULL, 0); + if (!LtE_type) return 0; LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL); + if (!LtE_singleton) return 0; Gt_type = make_type("Gt", cmpop_type, NULL, 0); + if (!Gt_type) return 0; Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL); + if (!Gt_singleton) return 0; GtE_type = make_type("GtE", cmpop_type, NULL, 0); + if (!GtE_type) return 0; GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL); + if (!GtE_singleton) return 0; Is_type = make_type("Is", cmpop_type, NULL, 0); + if (!Is_type) return 0; Is_singleton = PyType_GenericNew(Is_type, NULL, NULL); + if (!Is_singleton) return 0; IsNot_type = make_type("IsNot", cmpop_type, NULL, 0); + if (!IsNot_type) return 0; IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL); + if (!IsNot_singleton) return 0; In_type = make_type("In", cmpop_type, NULL, 0); + if (!In_type) return 0; In_singleton = PyType_GenericNew(In_type, NULL, NULL); + if (!In_singleton) return 0; NotIn_type = make_type("NotIn", cmpop_type, NULL, 0); + if (!NotIn_type) return 0; NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL); - comprehension_type = make_type("comprehension", &PyBaseObject_Type, + if (!NotIn_singleton) return 0; + comprehension_type = make_type("comprehension", AST_type, comprehension_fields, 3); - excepthandler_type = make_type("excepthandler", &PyBaseObject_Type, + if (!comprehension_type) return 0; + excepthandler_type = make_type("excepthandler", AST_type, excepthandler_fields, 3); - arguments_type = make_type("arguments", &PyBaseObject_Type, - arguments_fields, 4); - keyword_type = make_type("keyword", &PyBaseObject_Type, keyword_fields, - 2); - alias_type = make_type("alias", &PyBaseObject_Type, alias_fields, 2); -return 1; + if (!excepthandler_type) return 0; + arguments_type = make_type("arguments", AST_type, arguments_fields, 4); + if (!arguments_type) return 0; + keyword_type = make_type("keyword", AST_type, keyword_fields, 2); + if (!keyword_type) return 0; + alias_type = make_type("alias", AST_type, alias_fields, 2); + if (!alias_type) return 0; + initialized = 1; + return 1; } mod_ty @@ -1702,7 +1869,6 @@ ast2obj_mod(void* _o) Py_DECREF(value); break; } - return result; failed: Py_XDECREF(value); @@ -2036,7 +2202,9 @@ ast2obj_stmt(void* _o) if (!result) goto failed; break; } - + value = ast2obj_int(o->lineno); + if (!value) goto failed; + PyObject_SetAttrString(result, "lineno", value); return result; failed: Py_XDECREF(value); @@ -2350,7 +2518,9 @@ ast2obj_expr(void* _o) Py_DECREF(value); break; } - + value = ast2obj_int(o->lineno); + if (!value) goto failed; + PyObject_SetAttrString(result, "lineno", value); return result; failed: Py_XDECREF(value); @@ -2435,7 +2605,6 @@ ast2obj_slice(void* _o) Py_DECREF(value); break; } - return result; failed: Py_XDECREF(value); @@ -2578,7 +2747,6 @@ ast2obj_comprehension(void* _o) if (PyObject_SetAttrString(result, "ifs", value) == -1) goto failed; Py_DECREF(value); - return result; failed: Py_XDECREF(value); @@ -2613,7 +2781,6 @@ ast2obj_excepthandler(void* _o) if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); - return result; failed: Py_XDECREF(value); @@ -2653,7 +2820,6 @@ ast2obj_arguments(void* _o) if (PyObject_SetAttrString(result, "defaults", value) == -1) goto failed; Py_DECREF(value); - return result; failed: Py_XDECREF(value); @@ -2683,7 +2849,6 @@ ast2obj_keyword(void* _o) if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); - return result; failed: Py_XDECREF(value); @@ -2713,7 +2878,6 @@ ast2obj_alias(void* _o) if (PyObject_SetAttrString(result, "asname", value) == -1) goto failed; Py_DECREF(value); - return result; failed: Py_XDECREF(value); @@ -2722,6 +2886,158 @@ failed: } +PyMODINIT_FUNC +init_ast(void) +{ + PyObject *m, *d; + if (!init_types()) return; + m = Py_InitModule3("_ast", NULL, NULL); + if (!m) return; + d = PyModule_GetDict(m); + if (PyDict_SetItemString(d, "AST", (PyObject*)AST_type) < 0) return; + if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0) + return; + if(PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return; + if(PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0) + return; + if(PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type) + < 0) return; + if(PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) < + 0) return; + if(PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return; + if(PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return; + if(PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type) + < 0) return; + if(PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0) + return; + if(PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0) + return; + if(PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0) + return; + if(PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0) + return; + if(PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) < 0) + return; + if(PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return; + if(PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return; + if(PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return; + if(PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return; + if(PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return; + if(PyDict_SetItemString(d, "TryExcept", (PyObject*)TryExcept_type) < 0) + return; + if(PyDict_SetItemString(d, "TryFinally", (PyObject*)TryFinally_type) < + 0) return; + if(PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0) + return; + if(PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0) + return; + if(PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) < + 0) return; + if(PyDict_SetItemString(d, "Exec", (PyObject*)Exec_type) < 0) return; + if(PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0) + return; + if(PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return; + if(PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return; + if(PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return; + if(PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0) + return; + if(PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return; + if(PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0) + return; + if(PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return; + if(PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0) + return; + if(PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0) + return; + if(PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return; + if(PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return; + if(PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0) + return; + if(PyDict_SetItemString(d, "GeneratorExp", + (PyObject*)GeneratorExp_type) < 0) return; + if(PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return; + if(PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0) + return; + if(PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return; + if(PyDict_SetItemString(d, "Repr", (PyObject*)Repr_type) < 0) return; + if(PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return; + if(PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return; + if(PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) < 0) + return; + if(PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) < 0) + return; + if(PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return; + if(PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return; + if(PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return; + if(PyDict_SetItemString(d, "expr_context", + (PyObject*)expr_context_type) < 0) return; + if(PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return; + if(PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return; + if(PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return; + if(PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0) + return; + if(PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0) + return; + if(PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return; + if(PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return; + if(PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0) + return; + if(PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return; + if(PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0) + return; + if(PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return; + if(PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0) + return; + if(PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return; + if(PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return; + if(PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0) + return; + if(PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return; + if(PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return; + if(PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return; + if(PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return; + if(PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return; + if(PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return; + if(PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0) + return; + if(PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0) + return; + if(PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return; + if(PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0) + return; + if(PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0) + return; + if(PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0) + return; + if(PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0) + return; + if(PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0) + return; + if(PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return; + if(PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return; + if(PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return; + if(PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return; + if(PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return; + if(PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return; + if(PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return; + if(PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return; + if(PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return; + if(PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return; + if(PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return; + if(PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return; + if(PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return; + if(PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return; + if(PyDict_SetItemString(d, "comprehension", + (PyObject*)comprehension_type) < 0) return; + if(PyDict_SetItemString(d, "excepthandler", + (PyObject*)excepthandler_type) < 0) return; + if(PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) < 0) + return; + if(PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0) + return; + if(PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return; +} + PyObject* PyAST_mod2obj(mod_ty t) { |