"""Parse tree transformation module.

Transforms Python source code into an abstract syntax tree (AST)

defined in the ast module.

The simplest ways to invoke this module are via parse and parseFile.

parse(buf) -> AST

parseFile(path) -> AST

"""

# Original version written by Greg Stein (gstein@lyra.org)

#                         and Bill Tutt (rassilon@lima.mudlib.org)

# February 1997.

#

# Modifications and improvements for Python 2.0 by Jeremy Hylton and

# Mark Hammond

#

# Some fixes to try to have correct line number on almost all nodes

# (except Module, Discard and Stmt) added by Sylvain Thenault

#

# Portions of this file are:

# Copyright (C) 1997-1998 Greg Stein. All Rights Reserved.

#

# This module is provided under a BSD-ish license. See

#   http://www.opensource.org/licenses/bsd-license.html

# and replace OWNER, ORGANIZATION, and YEAR as appropriate.

from compiler.ast import *

import parser

import symbol

import token

class WalkerError(StandardError):

    pass

from compiler.consts import CO_VARARGS, CO_VARKEYWORDS

from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY

def parseFile(path):

    f = open(path, "U")

    # XXX The parser API tolerates files without a trailing newline,

    # but not strings without a trailing newline.  Always add an extra

    # newline to the file contents, since we're going through the string

    # version of the API.

    src = f.read() + "\n"

    f.close()

    return parse(src)

def parse(buf, mode="exec"):

    if mode == "exec" or mode == "single":

        return Transformer().parsesuite(buf)

    elif mode == "eval":

        return Transformer().parseexpr(buf)

    else:

        raise ValueError("compile() arg 3 must be"

                         " 'exec' or 'eval' or 'single'")

def asList(nodes):

    l = []

    for item in nodes:

        if hasattr(item, "asList"):

            l.append(item.asList())

        else:

            if type(item) is type( (None, None) ):

                l.append(tuple(asList(item)))

            elif type(item) is type( [] ):

                l.append(asList(item))

            else:

                l.append(item)

    return l

def extractLineNo(ast):

    if not isinstance(ast[1], tuple):

        # get a terminal node

        return ast[2]

    for child in ast[1:]:

        if isinstance(child, tuple):

            lineno = extractLineNo(child)

            if lineno is not None:

                return lineno

def Node(*args):

    kind = args[0]

    if nodes.has_key(kind):

        try:

            return nodes[kind](*args[1:])

        except TypeError:

            print nodes[kind], len(args), args

            raise

    else:

        raise WalkerError, "Can't find appropriate Node type: %s" % str(args)

        #return apply(ast.Node, args)

class Transformer:

    """Utility object for transforming Python parse trees.

    Exposes the following methods:

        tree = transform(ast_tree)

        tree = parsesuite(text)

        tree = parseexpr(text)

        tree = parsefile(fileob | filename)

    """

    def __init__(self):

        self._dispatch = {}

        for value, name in symbol.sym_name.items():

            if hasattr(self, name):

                self._dispatch[value] = getattr(self, name)

        self._dispatch[token.NEWLINE] = self.com_NEWLINE

        self._atom_dispatch = {token.LPAR: self.atom_lpar,

                               token.LSQB: self.atom_lsqb,

                               token.LBRACE: self.atom_lbrace,

                               token.BACKQUOTE: self.atom_backquote,

                               token.NUMBER: self.atom_number,

                               token.STRING: self.atom_string,

                               token.NAME: self.atom_name,

                               }

        self.encoding = None

    def transform(self, tree):

        """Transform an AST into a modified parse tree."""

        if not (isinstance(tree, tuple) or isinstance(tree, list)):

            tree = parser.ast2tuple(tree, line_info=1)

        return self.compile_node(tree)

    def parsesuite(self, text):

        """Return a modified parse tree for the given suite text."""

        return self.transform(parser.suite(text))

    def parseexpr(self, text):

        """Return a modified parse tree for the given expression text."""

        return self.transform(parser.expr(text))

    def parsefile(self, file):

        """Return a modified parse tree for the contents of the given file."""

        if type(file) == type(''):

            file = open(file)

        return self.parsesuite(file.read())

    # --------------------------------------------------------------

    #

    # PRIVATE METHODS

    #

    def compile_node(self, node):

        ### emit a line-number node?

        n = node[0]

        if n == symbol.encoding_decl:

            self.encoding = node[2]

            node = node[1]

            n = node[0]

        if n == symbol.single_input:

            return self.single_input(node[1:])

        if n == symbol.file_input:

            return self.file_input(node[1:])

        if n == symbol.eval_input:

            return self.eval_input(node[1:])

        if n == symbol.lambdef:

            return self.lambdef(node[1:])

        if n == symbol.funcdef:

            return self.funcdef(node[1:])

        if n == symbol.classdef:

            return self.classdef(node[1:])

        raise WalkerError, ('unexpected node type', n)

    def single_input(self, node):

        ### do we want to do anything about being "interactive" ?

        # NEWLINE | simple_stmt | compound_stmt NEWLINE

        n = node[0][0]

        if n != token.NEWLINE:

            return self.com_stmt(node[0])

        return Pass()

    def file_input(self, nodelist):

        doc = self.get_docstring(nodelist, symbol.file_input)

        if doc is not None:

            i = 1

        else:

            i = 0

        stmts = []

        for node in nodelist[i:]:

            if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:

                self.com_append_stmt(stmts, node)

        return Module(doc, Stmt(stmts))

    def eval_input(self, nodelist):

        # from the built-in function input()

        ### is this sufficient?

        return Expression(self.com_node(nodelist[0]))

    def decorator_name(self, nodelist):

        listlen = len(nodelist)

        assert listlen >= 1 and listlen % 2 == 1

        item = self.atom_name(nodelist)

        i = 1

        while i < listlen:

            assert nodelist[i][0] == token.DOT

            assert nodelist[i + 1][0] == token.NAME

            item = Getattr(item, nodelist[i + 1][1])

            i += 2

        return item

    def decorator(self, nodelist):

        # '@' dotted_name [ '(' [arglist] ')' ]

        assert len(nodelist) in (3, 5, 6)

        assert nodelist[0][0] == token.AT

        assert nodelist[-1][0] == token.NEWLINE

        assert nodelist[1][0] == symbol.dotted_name

        funcname = self.decorator_name(nodelist[1][1:])

        if len(nodelist) > 3:

            assert nodelist[2][0] == token.LPAR

            expr = self.com_call_function(funcname, nodelist[3])

        else:

            expr = funcname

        return expr

    def decorators(self, nodelist):

        # decorators: decorator ([NEWLINE] decorator)* NEWLINE

        items = []

        for dec_nodelist in nodelist:

            assert dec_nodelist[0] == symbol.decorator

            items.append(self.decorator(dec_nodelist[1:]))

        return Decorators(items)

    def decorated(self, nodelist):

        assert nodelist[0][0] == symbol.decorators

        if nodelist[1][0] == symbol.funcdef:

            n = [nodelist[0]] + list(nodelist[1][1:])

            return self.funcdef(n)

        elif nodelist[1][0] == symbol.classdef:

            decorators = self.decorators(nodelist[0][1:])

            cls = self.classdef(nodelist[1][1:])

            cls.decorators = decorators

            return cls

        raise WalkerError()

    def funcdef(self, nodelist):

        #                    -6   -5    -4         -3  -2    -1

        # funcdef: [decorators] 'def' NAME parameters ':' suite

        # parameters: '(' [varargslist] ')'

        if len(nodelist) == 6:

            assert nodelist[0][0] == symbol.decorators

            decorators = self.decorators(nodelist[0][1:])

        else:

            assert len(nodelist) == 5

            decorators = None

        lineno = nodelist[-4][2]

        name = nodelist[-4][1]

        args = nodelist[-3][2]

        if args[0] == symbol.varargslist:

            names, defaults, flags = self.com_arglist(args[1:])

        else:

            names = defaults = ()

            flags = 0

        doc = self.get_docstring(nodelist[-1])

        # code for function

        code = self.com_node(nodelist[-1])

        if doc is not None:

            assert isinstance(code, Stmt)

            assert isinstance(code.nodes[0], Discard)

            del code.nodes[0]

        return Function(decorators, name, names, defaults, flags, doc, code,

                     lineno=lineno)

    def lambdef(self, nodelist):

        # lambdef: 'lambda' [varargslist] ':' test

        if nodelist[2][0] == symbol.varargslist:

            names, defaults, flags = self.com_arglist(nodelist[2][1:])

        else:

            names = defaults = ()

            flags = 0

        # code for lambda

        code = self.com_node(nodelist[-1])

        return Lambda(names, defaults, flags, code, lineno=nodelist[1][2])

    old_lambdef = lambdef

    def classdef(self, nodelist):

        # classdef: 'class' NAME ['(' [testlist] ')'] ':' suite

        name = nodelist[1][1]

        doc = self.get_docstring(nodelist[-1])

        if nodelist[2][0] == token.COLON:

            bases = []

        elif nodelist[3][0] == token.RPAR:

            bases = []

        else:

            bases = self.com_bases(nodelist[3])

        # code for class

        code = self.com_node(nodelist[-1])

        if doc is not None:

            assert isinstance(code, Stmt)

            assert isinstance(code.nodes[0], Discard)

            del code.nodes[0]

        return Class(name, bases, doc, code, lineno=nodelist[1][2])

    def stmt(self, nodelist):

        return self.com_stmt(nodelist[0])

    small_stmt = stmt

    flow_stmt = stmt

    compound_stmt = stmt

    def simple_stmt(self, nodelist):

        # small_stmt (';' small_stmt)* [';'] NEWLINE

        stmts = []

        for i in range(0, len(nodelist), 2):

            self.com_append_stmt(stmts, nodelist[i])

        return Stmt(stmts)

    def parameters(self, nodelist):

        raise WalkerError

    def varargslist(self, nodelist):

        raise WalkerError

    def fpdef(self, nodelist):

        raise WalkerError

    def fplist(self, nodelist):

        raise WalkerError

    def dotted_name(self, nodelist):

        raise WalkerError

    def comp_op(self, nodelist):

        raise WalkerError

    def trailer(self, nodelist):

        raise WalkerError

    def sliceop(self, nodelist):

        raise WalkerError

    def argument(self, nodelist):

        raise WalkerError

    # --------------------------------------------------------------

    #

    # STATEMENT NODES  (invoked by com_node())

    #

    def expr_stmt(self, nodelist):

        # augassign testlist | testlist ('=' testlist)*

        en = nodelist[-1]

        exprNode = self.lookup_node(en)(en[1:])

        if len(nodelist) == 1:

            return Discard(exprNode, lineno=exprNode.lineno)

        if nodelist[1][0] == token.EQUAL:

            nodesl = []

            for i in range(0, len(nodelist) - 2, 2):

                nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))

            return Assign(nodesl, exprNode, lineno=nodelist[1][2])

        else:

            lval = self.com_augassign(nodelist[0])

            op = self.com_augassign_op(nodelist[1])

            return AugAssign(lval, op[1], exprNode, lineno=op[2])

        raise WalkerError, "can't get here"

    def print_stmt(self, nodelist):

        # print ([ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ])

        items = []

        if len(nodelist) == 1:

            start = 1

            dest = None

        elif nodelist[1][0] == token.RIGHTSHIFT:

            assert len(nodelist) == 3 \

                   or nodelist[3][0] == token.COMMA

            dest = self.com_node(nodelist[2])

            start = 4

        else:

            dest = None

            start = 1

        for i in range(start, len(nodelist), 2):

            items.append(self.com_node(nodelist[i]))

        if nodelist[-1][0] == token.COMMA:

            return Print(items, dest, lineno=nodelist[0][2])

        return Printnl(items, dest, lineno=nodelist[0][2])

    def del_stmt(self, nodelist):

        return self.com_assign(nodelist[1], OP_DELETE)

    def pass_stmt(self, nodelist):

        return Pass(lineno=nodelist[0][2])

    def break_stmt(self, nodelist):

        return Break(lineno=nodelist[0][2])

    def continue_stmt(self, nodelist):

        return Continue(lineno=nodelist[0][2])

    def return_stmt(self, nodelist):

        # return: [testlist]

        if len(nodelist) < 2:

            return Return(Const(None), lineno=nodelist[0][2])

        return Return(self.com_node(nodelist[1]), lineno=nodelist[0][2])

    def yield_stmt(self, nodelist):

        expr = self.com_node(nodelist[0])

        return Discard(expr, lineno=expr.lineno)

    def yield_expr(self, nodelist):

        if len(nodelist) > 1:

            value = self.com_node(nodelist[1])

        else:

            value = Const(None)

        return Yield(value, lineno=nodelist[0][2])

    def raise_stmt(self, nodelist):

        # raise: [test [',' test [',' test]]]

        if len(nodelist) > 5:

            expr3 = self.com_node(nodelist[5])

        else:

            expr3 = None

        if len(nodelist) > 3:

            expr2 = self.com_node(nodelist[3])

        else:

            expr2 = None

        if len(nodelist) > 1:

            expr1 = self.com_node(nodelist[1])

        else:

            expr1 = None

        return Raise(expr1, expr2, expr3, lineno=nodelist[0][2])

    def import_stmt(self, nodelist):

        # import_stmt: import_name | import_from

        assert len(nodelist) == 1

        return self.com_node(nodelist[0])

    def import_name(self, nodelist):

        # import_name: 'import' dotted_as_names

        return Import(self.com_dotted_as_names(nodelist[1]),

                      lineno=nodelist[0][2])

    def import_from(self, nodelist):

        # import_from: 'from' ('.'* dotted_name | '.') 'import' ('*' |

        #    '(' import_as_names ')' | import_as_names)

        assert nodelist[0][1] == 'from'

        idx = 1

        while nodelist[idx][1] == '.':

            idx += 1

        level = idx - 1

        if nodelist[idx][0] == symbol.dotted_name:

            fromname = self.com_dotted_name(nodelist[idx])

            idx += 1

        else:

            fromname = ""

        assert nodelist[idx][1] == 'import'

        if nodelist[idx + 1][0] == token.STAR:

            return From(fromname, [('*', None)], level,

                        lineno=nodelist[0][2])

        else:

            node = nodelist[idx + 1 + (nodelist[idx + 1][0] == token.LPAR)]

            return From(fromname, self.com_import_as_names(node), level,

                        lineno=nodelist[0][2])

    def global_stmt(self, nodelist):

        # global: NAME (',' NAME)*

        names = []

        for i in range(1, len(nodelist), 2):

            names.append(nodelist[i][1])

        return Global(names, lineno=nodelist[0][2])

    def exec_stmt(self, nodelist):

        # exec_stmt: 'exec' expr ['in' expr [',' expr]]

        expr1 = self.com_node(nodelist[1])

        if len(nodelist) >= 4:

            expr2 = self.com_node(nodelist[3])

            if len(nodelist) >= 6:

                expr3 = self.com_node(nodelist[5])

            else:

                expr3 = None

        else:

            expr2 = expr3 = None

        return Exec(expr1, expr2, expr3, lineno=nodelist[0][2])

    def assert_stmt(self, nodelist):

        # 'assert': test, [',' test]

        expr1 = self.com_node(nodelist[1])

        if (len(nodelist) == 4):

            expr2 = self.com_node(nodelist[3])

        else:

            expr2 = None

        return Assert(expr1, expr2, lineno=nodelist[0][2])

    def if_stmt(self, nodelist):

        # if: test ':' suite ('elif' test ':' suite)* ['else' ':' suite]

        tests = []

        for i in range(0, len(nodelist) - 3, 4):

            testNode = self.com_node(nodelist[i + 1])

            suiteNode = self.com_node(nodelist[i + 3])

            tests.append((testNode, suiteNode))

        if len(nodelist) % 4 == 3:

            elseNode = self.com_node(nodelist[-1])

##      elseNode.lineno = nodelist[-1][1][2]

        else:

            elseNode = None

        return If(tests, elseNode, lineno=nodelist[0][2])

    def while_stmt(self, nodelist):

        # 'while' test ':' suite ['else' ':' suite]

        testNode = self.com_node(nodelist[1])

        bodyNode = self.com_node(nodelist[3])

        if len(nodelist) > 4:

            elseNode = self.com_node(nodelist[6])