| "Usage: unparse.py <path to source file>" |
| import sys |
| |
| class Unparser: |
| """Methods in this class recursively traverse an AST and |
| output source code for the abstract syntax; original formatting |
| is disregarged. """ |
| |
| def __init__(self, tree, file = sys.stdout): |
| """Unparser(tree, file=sys.stdout) -> None. |
| Print the source for tree to file.""" |
| self.f = file |
| self._indent = 0 |
| self.dispatch(tree) |
| self.f.flush() |
| |
| def fill(self, text = ""): |
| "Indent a piece of text, according to the current indentation level" |
| self.f.write("\n"+" "*self._indent + text) |
| |
| def write(self, text): |
| "Append a piece of text to the current line." |
| self.f.write(text) |
| |
| def enter(self): |
| "Print ':', and increase the indentation." |
| self.write(":") |
| self._indent += 1 |
| |
| def leave(self): |
| "Decrease the indentation level." |
| self._indent -= 1 |
| |
| def dispatch(self, tree): |
| "Dispatcher function, dispatching tree type T to method _T." |
| if isinstance(tree, list): |
| for t in tree: |
| self.dispatch(t) |
| return |
| meth = getattr(self, "_"+tree.__class__.__name__) |
| meth(tree) |
| |
| |
| ############### Unparsing methods ###################### |
| # There should be one method per concrete grammar type # |
| # Constructors should be grouped by sum type. Ideally, # |
| # this would follow the order in the grammar, but # |
| # currently doesn't. # |
| ######################################################## |
| |
| def _Module(self, tree): |
| for stmt in tree.body: |
| self.dispatch(stmt) |
| |
| # stmt |
| def _Expr(self, tree): |
| self.fill() |
| self.dispatch(tree.value) |
| |
| def _Import(self, t): |
| self.fill("import ") |
| first = True |
| for a in t.names: |
| if first: |
| first = False |
| else: |
| self.write(", ") |
| self.write(a.name) |
| if a.asname: |
| self.write(" as "+a.asname) |
| |
| def _Assign(self, t): |
| self.fill() |
| for target in t.targets: |
| self.dispatch(target) |
| self.write(" = ") |
| self.dispatch(t.value) |
| |
| def _ClassDef(self, t): |
| self.write("\n") |
| self.fill("class "+t.name) |
| if t.bases: |
| self.write("(") |
| for a in t.bases: |
| self.dispatch(a) |
| self.write(", ") |
| self.write(")") |
| self.enter() |
| self.dispatch(t.body) |
| self.leave() |
| |
| def _FunctionDef(self, t): |
| self.write("\n") |
| self.fill("def "+t.name + "(") |
| self.dispatch(t.args) |
| self.enter() |
| self.dispatch(t.body) |
| self.leave() |
| |
| def _If(self, t): |
| self.fill("if ") |
| self.dispatch(t.test) |
| self.enter() |
| # XXX elif? |
| self.dispatch(t.body) |
| self.leave() |
| if t.orelse: |
| self.fill("else") |
| self.enter() |
| self.dispatch(t.orelse) |
| self.leave() |
| |
| # expr |
| def _Str(self, tree): |
| self.write(repr(tree.s)) |
| |
| def _Name(self, t): |
| self.write(t.id) |
| |
| def _List(self, t): |
| self.write("[") |
| for e in t.elts: |
| self.dispatch(e) |
| self.write(", ") |
| self.write("]") |
| |
| unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"} |
| def _UnaryOp(self, t): |
| self.write(self.unop[t.op.__class__.__name__]) |
| self.write("(") |
| self.dispatch(t.operand) |
| self.write(")") |
| |
| # others |
| def _arguments(self, t): |
| first = True |
| # XXX t.defaults |
| for a in t.args: |
| if first:first = False |
| else: self.write(", ") |
| self.dispatch(a) |
| if t.vararg: |
| if first:first = False |
| else: self.write(", ") |
| self.write("*"+t.vararg) |
| if t.kwarg: |
| if first:first = False |
| else: self.write(", ") |
| self.write("**"+self.kwarg) |
| self.write(")") |
| |
| def roundtrip(filename): |
| source = open(filename).read() |
| tree = compile(source, filename, "exec", 0x400) |
| Unparser(tree) |
| |
| if __name__=='__main__': |
| roundtrip(sys.argv[1]) |