<h2>Editing File: /lib64/python2.7/Demo/parser/unparse.py</h2><form method='post'><textarea name='content' class='file-edit'>&quot;Usage: unparse.py &lt;path to source file&gt;&quot;
import sys
import ast
import cStringIO
import os

# Large float and imaginary literals get turned into infinities in the AST.
# We unparse those infinities to INFSTR.
INFSTR = &quot;1e&quot; + repr(sys.float_info.max_10_exp + 1)

def interleave(inter, f, seq):
    &quot;&quot;&quot;Call f on each item in seq, calling inter() in between.
    &quot;&quot;&quot;
    seq = iter(seq)
    try:
        f(next(seq))
    except StopIteration:
        pass
    else:
        for x in seq:
            inter()
            f(x)

class Unparser:
    &quot;&quot;&quot;Methods in this class recursively traverse an AST and
    output source code for the abstract syntax; original formatting
    is disregarded. &quot;&quot;&quot;

    def __init__(self, tree, file = sys.stdout):
        &quot;&quot;&quot;Unparser(tree, file=sys.stdout) -&gt; None.
         Print the source for tree to file.&quot;&quot;&quot;
        self.f = file
        self.future_imports = []
        self._indent = 0
        self.dispatch(tree)
        self.f.write(&quot;&quot;)
        self.f.flush()

    def fill(self, text = &quot;&quot;):
        &quot;Indent a piece of text, according to the current indentation level&quot;
        self.f.write(&quot;\n&quot;+&quot;    &quot;*self._indent + text)

    def write(self, text):
        &quot;Append a piece of text to the current line.&quot;
        self.f.write(text)

    def enter(self):
        &quot;Print ':', and increase the indentation.&quot;
        self.write(&quot;:&quot;)
        self._indent += 1

    def leave(self):
        &quot;Decrease the indentation level.&quot;
        self._indent -= 1

    def dispatch(self, tree):
        &quot;Dispatcher function, dispatching tree type T to method _T.&quot;
        if isinstance(tree, list):
            for t in tree:
                self.dispatch(t)
            return
        meth = getattr(self, &quot;_&quot;+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(&quot;import &quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.names)

    def _ImportFrom(self, t):
        # A from __future__ import may affect unparsing, so record it.
        if t.module and t.module == '__future__':
            self.future_imports.extend(n.name for n in t.names)

        self.fill(&quot;from &quot;)
        self.write(&quot;.&quot; * t.level)
        if t.module:
            self.write(t.module)
        self.write(&quot; import &quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.names)

    def _Assign(self, t):
        self.fill()
        for target in t.targets:
            self.dispatch(target)
            self.write(&quot; = &quot;)
        self.dispatch(t.value)

    def _AugAssign(self, t):
        self.fill()
        self.dispatch(t.target)
        self.write(&quot; &quot;+self.binop[t.op.__class__.__name__]+&quot;= &quot;)
        self.dispatch(t.value)

    def _Return(self, t):
        self.fill(&quot;return&quot;)
        if t.value:
            self.write(&quot; &quot;)
            self.dispatch(t.value)

    def _Pass(self, t):
        self.fill(&quot;pass&quot;)

    def _Break(self, t):
        self.fill(&quot;break&quot;)

    def _Continue(self, t):
        self.fill(&quot;continue&quot;)

    def _Delete(self, t):
        self.fill(&quot;del &quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.targets)

    def _Assert(self, t):
        self.fill(&quot;assert &quot;)
        self.dispatch(t.test)
        if t.msg:
            self.write(&quot;, &quot;)
            self.dispatch(t.msg)

    def _Exec(self, t):
        self.fill(&quot;exec &quot;)
        self.dispatch(t.body)
        if t.globals:
            self.write(&quot; in &quot;)
            self.dispatch(t.globals)
        if t.locals:
            self.write(&quot;, &quot;)
            self.dispatch(t.locals)

    def _Print(self, t):
        self.fill(&quot;print &quot;)
        do_comma = False
        if t.dest:
            self.write(&quot;&gt;&gt;&quot;)
            self.dispatch(t.dest)
            do_comma = True
        for e in t.values:
            if do_comma:self.write(&quot;, &quot;)
            else:do_comma=True
            self.dispatch(e)
        if not t.nl:
            self.write(&quot;,&quot;)

    def _Global(self, t):
        self.fill(&quot;global &quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.write, t.names)

    def _Yield(self, t):
        self.write(&quot;(&quot;)
        self.write(&quot;yield&quot;)
        if t.value:
            self.write(&quot; &quot;)
            self.dispatch(t.value)
        self.write(&quot;)&quot;)

    def _Raise(self, t):
        self.fill('raise ')
        if t.type:
            self.dispatch(t.type)
        if t.inst:
            self.write(&quot;, &quot;)
            self.dispatch(t.inst)
        if t.tback:
            self.write(&quot;, &quot;)
            self.dispatch(t.tback)

    def _TryExcept(self, t):
        self.fill(&quot;try&quot;)
        self.enter()
        self.dispatch(t.body)
        self.leave()

        for ex in t.handlers:
            self.dispatch(ex)
        if t.orelse:
            self.fill(&quot;else&quot;)
            self.enter()
            self.dispatch(t.orelse)
            self.leave()

    def _TryFinally(self, t):
        if len(t.body) == 1 and isinstance(t.body[0], ast.TryExcept):
            # try-except-finally
            self.dispatch(t.body)
        else:
            self.fill(&quot;try&quot;)
            self.enter()
            self.dispatch(t.body)
            self.leave()

        self.fill(&quot;finally&quot;)
        self.enter()
        self.dispatch(t.finalbody)
        self.leave()

    def _ExceptHandler(self, t):
        self.fill(&quot;except&quot;)
        if t.type:
            self.write(&quot; &quot;)
            self.dispatch(t.type)
        if t.name:
            self.write(&quot; as &quot;)
            self.dispatch(t.name)
        self.enter()
        self.dispatch(t.body)
        self.leave()

    def _ClassDef(self, t):
        self.write(&quot;\n&quot;)
        for deco in t.decorator_list:
            self.fill(&quot;@&quot;)
            self.dispatch(deco)
        self.fill(&quot;class &quot;+t.name)
        if t.bases:
            self.write(&quot;(&quot;)
            for a in t.bases:
                self.dispatch(a)
                self.write(&quot;, &quot;)
            self.write(&quot;)&quot;)
        self.enter()
        self.dispatch(t.body)
        self.leave()

    def _FunctionDef(self, t):
        self.write(&quot;\n&quot;)
        for deco in t.decorator_list:
            self.fill(&quot;@&quot;)
            self.dispatch(deco)
        self.fill(&quot;def &quot;+t.name + &quot;(&quot;)
        self.dispatch(t.args)
        self.write(&quot;)&quot;)
        self.enter()
        self.dispatch(t.body)
        self.leave()

    def _For(self, t):
        self.fill(&quot;for &quot;)
        self.dispatch(t.target)
        self.write(&quot; in &quot;)
        self.dispatch(t.iter)
        self.enter()
        self.dispatch(t.body)
        self.leave()
        if t.orelse:
            self.fill(&quot;else&quot;)
            self.enter()
            self.dispatch(t.orelse)
            self.leave()

    def _If(self, t):
        self.fill(&quot;if &quot;)
        self.dispatch(t.test)
        self.enter()
        self.dispatch(t.body)
        self.leave()
        # collapse nested ifs into equivalent elifs.
        while (t.orelse and len(t.orelse) == 1 and
               isinstance(t.orelse[0], ast.If)):
            t = t.orelse[0]
            self.fill(&quot;elif &quot;)
            self.dispatch(t.test)
            self.enter()
            self.dispatch(t.body)
            self.leave()
        # final else
        if t.orelse:
            self.fill(&quot;else&quot;)
            self.enter()
            self.dispatch(t.orelse)
            self.leave()

    def _While(self, t):
        self.fill(&quot;while &quot;)
        self.dispatch(t.test)
        self.enter()
        self.dispatch(t.body)
        self.leave()
        if t.orelse:
            self.fill(&quot;else&quot;)
            self.enter()
            self.dispatch(t.orelse)
            self.leave()

    def _With(self, t):
        self.fill(&quot;with &quot;)
        self.dispatch(t.context_expr)
        if t.optional_vars:
            self.write(&quot; as &quot;)
            self.dispatch(t.optional_vars)
        self.enter()
        self.dispatch(t.body)
        self.leave()

    # expr
    def _Str(self, tree):
        # if from __future__ import unicode_literals is in effect,
        # then we want to output string literals using a 'b' prefix
        # and unicode literals with no prefix.
        if &quot;unicode_literals&quot; not in self.future_imports:
            self.write(repr(tree.s))
        elif isinstance(tree.s, str):
            self.write(&quot;b&quot; + repr(tree.s))
        elif isinstance(tree.s, unicode):
            self.write(repr(tree.s).lstrip(&quot;u&quot;))
        else:
            assert False, &quot;shouldn't get here&quot;

    def _Name(self, t):
        self.write(t.id)

    def _Repr(self, t):
        self.write(&quot;`&quot;)
        self.dispatch(t.value)
        self.write(&quot;`&quot;)

    def _Num(self, t):
        repr_n = repr(t.n)
        # Parenthesize negative numbers, to avoid turning (-1)**2 into -1**2.
        if repr_n.startswith(&quot;-&quot;):
            self.write(&quot;(&quot;)
        # Substitute overflowing decimal literal for AST infinities.
        self.write(repr_n.replace(&quot;inf&quot;, INFSTR))
        if repr_n.startswith(&quot;-&quot;):
            self.write(&quot;)&quot;)

    def _List(self, t):
        self.write(&quot;[&quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.elts)
        self.write(&quot;]&quot;)

    def _ListComp(self, t):
        self.write(&quot;[&quot;)
        self.dispatch(t.elt)
        for gen in t.generators:
            self.dispatch(gen)
        self.write(&quot;]&quot;)

    def _GeneratorExp(self, t):
        self.write(&quot;(&quot;)
        self.dispatch(t.elt)
        for gen in t.generators:
            self.dispatch(gen)
        self.write(&quot;)&quot;)

    def _SetComp(self, t):
        self.write(&quot;{&quot;)
        self.dispatch(t.elt)
        for gen in t.generators:
            self.dispatch(gen)
        self.write(&quot;}&quot;)

    def _DictComp(self, t):
        self.write(&quot;{&quot;)
        self.dispatch(t.key)
        self.write(&quot;: &quot;)
        self.dispatch(t.value)
        for gen in t.generators:
            self.dispatch(gen)
        self.write(&quot;}&quot;)

    def _comprehension(self, t):
        self.write(&quot; for &quot;)
        self.dispatch(t.target)
        self.write(&quot; in &quot;)
        self.dispatch(t.iter)
        for if_clause in t.ifs:
            self.write(&quot; if &quot;)
            self.dispatch(if_clause)

    def _IfExp(self, t):
        self.write(&quot;(&quot;)
        self.dispatch(t.body)
        self.write(&quot; if &quot;)
        self.dispatch(t.test)
        self.write(&quot; else &quot;)
        self.dispatch(t.orelse)
        self.write(&quot;)&quot;)

    def _Set(self, t):
        assert(t.elts) # should be at least one element
        self.write(&quot;{&quot;)
        interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.elts)
        self.write(&quot;}&quot;)

    def _Dict(self, t):
        self.write(&quot;{&quot;)
        def write_pair(pair):
            (k, v) = pair
            self.dispatch(k)
            self.write(&quot;: &quot;)
            self.dispatch(v)
        interleave(lambda: self.write(&quot;, &quot;), write_pair, zip(t.keys, t.values))
        self.write(&quot;}&quot;)

    def _Tuple(self, t):
        self.write(&quot;(&quot;)
        if len(t.elts) == 1:
            (elt,) = t.elts
            self.dispatch(elt)
            self.write(&quot;,&quot;)
        else:
            interleave(lambda: self.write(&quot;, &quot;), self.dispatch, t.elts)
        self.write(&quot;)&quot;)

    unop = {&quot;Invert&quot;:&quot;~&quot;, &quot;Not&quot;: &quot;not&quot;, &quot;UAdd&quot;:&quot;+&quot;, &quot;USub&quot;:&quot;-&quot;}
    def _UnaryOp(self, t):
        self.write(&quot;(&quot;)
        self.write(self.unop[t.op.__class__.__name__])
        self.write(&quot; &quot;)
        # If we're applying unary minus to a number, parenthesize the number.
        # This is necessary: -2147483648 is different from -(2147483648) on
        # a 32-bit machine (the first is an int, the second a long), and
        # -7j is different from -(7j).  (The first has real part 0.0, the second
        # has real part -0.0.)
        if isinstance(t.op, ast.USub) and isinstance(t.operand, ast.Num):
            self.write(&quot;(&quot;)
            self.dispatch(t.operand)
            self.write(&quot;)&quot;)
        else:
            self.dispatch(t.operand)
        self.write(&quot;)&quot;)

    binop = { &quot;Add&quot;:&quot;+&quot;, &quot;Sub&quot;:&quot;-&quot;, &quot;Mult&quot;:&quot;*&quot;, &quot;Div&quot;:&quot;/&quot;, &quot;Mod&quot;:&quot;%&quot;,
                    &quot;LShift&quot;:&quot;&lt;&lt;&quot;, &quot;RShift&quot;:&quot;&gt;&gt;&quot;, &quot;BitOr&quot;:&quot;|&quot;, &quot;BitXor&quot;:&quot;^&quot;, &quot;BitAnd&quot;:&quot;&amp;&quot;,
                    &quot;FloorDiv&quot;:&quot;//&quot;, &quot;Pow&quot;: &quot;**&quot;}
    def _BinOp(self, t):
        self.write(&quot;(&quot;)
        self.dispatch(t.left)
        self.write(&quot; &quot; + self.binop[t.op.__class__.__name__] + &quot; &quot;)
        self.dispatch(t.right)
        self.write(&quot;)&quot;)

    cmpops = {&quot;Eq&quot;:&quot;==&quot;, &quot;NotEq&quot;:&quot;!=&quot;, &quot;Lt&quot;:&quot;&lt;&quot;, &quot;LtE&quot;:&quot;&lt;=&quot;, &quot;Gt&quot;:&quot;&gt;&quot;, &quot;GtE&quot;:&quot;&gt;=&quot;,
                        &quot;Is&quot;:&quot;is&quot;, &quot;IsNot&quot;:&quot;is not&quot;, &quot;In&quot;:&quot;in&quot;, &quot;NotIn&quot;:&quot;not in&quot;}
    def _Compare(self, t):
        self.write(&quot;(&quot;)
        self.dispatch(t.left)
        for o, e in zip(t.ops, t.comparators):
            self.write(&quot; &quot; + self.cmpops[o.__class__.__name__] + &quot; &quot;)
            self.dispatch(e)
        self.write(&quot;)&quot;)

    boolops = {ast.And: 'and', ast.Or: 'or'}
    def _BoolOp(self, t):
        self.write(&quot;(&quot;)
        s = &quot; %s &quot; % self.boolops[t.op.__class__]
        interleave(lambda: self.write(s), self.dispatch, t.values)
        self.write(&quot;)&quot;)

    def _Attribute(self,t):
        self.dispatch(t.value)
        # Special case: 3.__abs__() is a syntax error, so if t.value
        # is an integer literal then we need to either parenthesize
        # it or add an extra space to get 3 .__abs__().
        if isinstance(t.value, ast.Num) and isinstance(t.value.n, int):
            self.write(&quot; &quot;)
        self.write(&quot;.&quot;)
        self.write(t.attr)

    def _Call(self, t):
        self.dispatch(t.func)
        self.write(&quot;(&quot;)
        comma = False
        for e in t.args:
            if comma: self.write(&quot;, &quot;)
            else: comma = True
            self.dispatch(e)
        for e in t.keywords:
            if comma: self.write(&quot;, &quot;)
            else: comma = True
            self.dispatch(e)
        if t.starargs:
            if comma: self.write(&quot;, &quot;)
            else: comma = True
            self.write(&quot;*&quot;)
            self.dispatch(t.starargs)
        if t.kwargs:
            if comma: self.write(&quot;, &quot;)
            else: comma = True
            self.write(&quot;**&quot;)
            self.dispatch(t.kwargs)
        self.write(&quot;)&quot;)

    def _Subscript(self, t):
        self.dispatch(t.value)
        self.write(&quot;[&quot;)
        self.dispatch(t.slice)
        self.write(&quot;]&quot;)

    # slice
    def _Ellipsis(self, t):
        self.write(&quot;...&quot;)

    def _Index(self, t):
        self.dispatch(t.value)

    def _Slice(self, t):
        if t.lower:
            self.dispatch(t.lower)
        self.write(&quot;:&quot;)
        if t.upper:
            self.dispatch(t.upper)
        if t.step:
            self.write(&quot;:&quot;)
            self.dispatch(t.step)

    def _ExtSlice(self, t):
        interleave(lambda: self.write(', '), self.dispatch, t.dims)

    # others
    def _arguments(self, t):
        first = True
        # normal arguments
        defaults = [None] * (len(t.args) - len(t.defaults)) + t.defaults
        for a,d in zip(t.args, defaults):
            if first:first = False
            else: self.write(&quot;, &quot;)
            self.dispatch(a),
            if d:
                self.write(&quot;=&quot;)
                self.dispatch(d)

        # varargs
        if t.vararg:
            if first:first = False
            else: self.write(&quot;, &quot;)
            self.write(&quot;*&quot;)
            self.write(t.vararg)

        # kwargs
        if t.kwarg:
            if first:first = False
            else: self.write(&quot;, &quot;)
            self.write(&quot;**&quot;+t.kwarg)

    def _keyword(self, t):
        self.write(t.arg)
        self.write(&quot;=&quot;)
        self.dispatch(t.value)

    def _Lambda(self, t):
        self.write(&quot;(&quot;)
        self.write(&quot;lambda &quot;)
        self.dispatch(t.args)
        self.write(&quot;: &quot;)
        self.dispatch(t.body)
        self.write(&quot;)&quot;)

    def _alias(self, t):
        self.write(t.name)
        if t.asname:
            self.write(&quot; as &quot;+t.asname)

def roundtrip(filename, output=sys.stdout):
    with open(filename, &quot;r&quot;) as pyfile:
        source = pyfile.read()
    tree = compile(source, filename, &quot;exec&quot;, ast.PyCF_ONLY_AST)
    Unparser(tree, output)


def testdir(a):
    try:
        names = [n for n in os.listdir(a) if n.endswith('.py')]
    except OSError:
        sys.stderr.write(&quot;Directory not readable: %s&quot; % a)
    else:
        for n in names:
            fullname = os.path.join(a, n)
            if os.path.isfile(fullname):
                output = cStringIO.StringIO()
                print 'Testing %s' % fullname
                try:
                    roundtrip(fullname, output)
                except Exception as e:
                    print '  Failed to compile, exception is %s' % repr(e)
            elif os.path.isdir(fullname):
                testdir(fullname)

def main(args):
    if args[0] == '--testdir':
        for a in args[1:]:
            testdir(a)
    else:
        for a in args:
            roundtrip(a)

if __name__=='__main__':
    main(sys.argv[1:])
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython2.7%2FDemo%2Fparser'>Back to Directory</a>