#!/usr/bin/env python

"""

Simplified AST nodes for easier type propagation and analysis.

Copyright (C) 2006 Paul Boddie <paul@boddie.org.uk>

This software is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License as

published by the Free Software Foundation; either version 2 of

the License, or (at your option) any later version.

This software is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public

License along with this library; see the file LICENCE.txt

If not, write to the Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

"""

from compiler.visitor import ASTVisitor

# Elementary visitor support.

class Visitor(ASTVisitor):

    "A visitor base class."

    def __init__(self):

        ASTVisitor.__init__(self)

    def default(self, node, *args):

        raise ValueError, node.__class__

    def dispatch(self, node, *args):

        return ASTVisitor.dispatch(self, node, *args)

    def dispatches(self, nodes, *args):

        results = []

        for node in nodes:

            results.append(self.dispatch(node, *args))

        return results

# Simplified program nodes.

class Node:

    """

    A result node with common attributes:

    original    The original node from which this node was created.

    name        Any name involved (variable or attribute).

    index       Any index involved (temporary variable name).

    value       Any constant value.

    ref         Any reference to (for example) subprograms.

    Expression-related attributes:

    expr        Any contributing expression.

    lvalue      Any target expression.

    test        Any test expression in a conditional instruction.

    handler     Any exception handler selector expression.

    Invocation and subprogram attributes:

    args        Any collection of argument nodes.

    params      Any collection of parameter nodes and defaults.

    Statement-grouping attributes:

    body        Any conditional code depending on the success of a test.

    else_       Any conditional code depending on the failure of a test.

    finally_    Any code which will be executed regardless.

    code        Any unconditional code.

    """

    def __init__(self, original=None, **kw):

        self.original = original

        if self.original is not None:

            self.original._node = self

        for name, value in kw.items():

            setattr(self, name, value)

    def __repr__(self):

        if hasattr(self, "name"):

            return "%s '%s' (at %x)" % (self.__class__, self.name, id(self))

        if hasattr(self, "index"):

            return "%s (%s) (at %x)" % (self.__class__, self.index, id(self))

        elif hasattr(self, "value"):

            return "%s %s (at %x)" % (self.__class__, repr(self.value), id(self))

        elif hasattr(self, "ref"):

            return "%s '%s' (at %x)" % (self.__class__, self.ref.name, id(self))

        else:

            return "%s (at %x)" % (self.__class__, id(self))

    def _pprint(self, indent, continuation, s):

        if continuation:

            print (" " * max(0, indent - len(continuation))) + continuation + s

        else:

            print (" " * indent) + s

    def pprint(self, indent=0, continuation=None):

        self._pprint(indent, continuation, repr(self))

        # Show other details.

        if hasattr(self, "params"):

            for name, default in self.params:

                self._pprint(indent + 2, "( ", "%s -> %s" % (name, default))

            if hasattr(self, "star") and self.star:

                name, default = self.star

                self._pprint(indent + 2, "( ", "%s -> %s" % (name, default))

            if hasattr(self, "dstar") and self.dstar:

                name, default = self.dstar

                self._pprint(indent + 2, "( ", "%s -> %s" % (name, default))

        if getattr(self, "acquire_locals", 0):

            self._pprint(indent + 2, "( ", "acquiring locals")

        if getattr(self, "structure", 0):

            self._pprint(indent + 2, "( ", "structure '%s'" % self.structure.name)

        if hasattr(self, "test"):

            self.test.pprint(indent + 2, "? ")

        for attr in "code", "body", "else_", "finally_":

            if hasattr(self, attr) and getattr(self, attr):

                self._pprint(indent, "", "{ (%s)" % attr)

                for node in getattr(self, attr):

                    node.pprint(indent + 2)

                self._pprint(indent, "", "}")

        if hasattr(self, "handler"):

            self.handler.pprint(indent + 2, "! ")

        if hasattr(self, "expr"):

            self.expr.pprint(indent + 2, "- ")

        if hasattr(self, "nodes"):

            for node in self.nodes:

                node.pprint(indent + 2, "- ")

        if hasattr(self, "lvalue"):

            self.lvalue.pprint(indent + 2, "= ")

        if hasattr(self, "args"):

            for arg in self.args:

                arg.pprint(indent + 2, "( ")

            if hasattr(self, "star") and self.star:

                self.star.pprint(indent + 2, "( ")

            if hasattr(self, "dstar") and self.dstar:

                self.dstar.pprint(indent + 2, "( ")

class Module(Node): "A Python module."

class Subprogram(Node): "A subprogram: functions, methods and loops."

class Constant(Node): "A constant."

class Pass(Node): "A placeholder node corresponding to pass."

class Invoke(Node): "A function, method or loop invocation."

class Return(Node): "Return an evaluated expression."

class Assign(Node): "A grouping node for assignment-related operations."

class Keyword(Node): "A grouping node for keyword arguments."

class Global(Node): "A global name designator."

class Import(Node): "A module import operation."

class LoadTemp(Node): "Load a previously-stored temporary value."

class LoadName(Node): "Load a named object."

class LoadGlobal(Node): "Load a named global object."

class LoadAttr(Node): "Load an object attribute."

class LoadRef(Node): "Load a reference, typically a subprogram."

class LoadExc(Node): "Load a handled exception."

class StoreTemp(Node): "Store a temporary value."

class StoreName(Node): "Associate a name with an object."

class StoreGlobal(Node): "Associate a name with an object in the global namespace."

class StoreAttr(Node): "Associate an object's attribute with a value."

class ReleaseTemp(Node): "Release a temporary value."

class Conditional(Node): "A conditional node consisting of a test and outcomes."

class Try(Node): "A try...except...else...finally grouping node."

class Raise(Node): "An exception raising node."

class Not(Node): "A negation of an expression."

class Class(Node): "A Python class."

# vim: tabstop=4 expandtab shiftwidth=4