"""Support for remote Python debugging.

Some ASCII art to describe the structure:

       IN PYTHON SUBPROCESS          #             IN IDLE PROCESS

                                     #

                                     #        oid='gui_adapter'

                 +----------+        #       +------------+          +-----+

                 | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |

+-----+--calls-->+----------+        #       +------------+          +-----+

| Idb |                               #                             /

+-----+<-calls--+------------+         #      +----------+<--calls-/

                | IdbAdapter |<--remote#call--| IdbProxy |

                +------------+         #      +----------+

                oid='idb_adapter'      #

The purpose of the Proxy and Adapter classes is to translate certain

arguments and return values that cannot be transported through the RPC

barrier, in particular frame and traceback objects.

"""

import types

import rpc

import Debugger

debugging = 0

idb_adap_oid = "idb_adapter"

gui_adap_oid = "gui_adapter"

#=======================================

#

# In the PYTHON subprocess:

frametable = {}

dicttable = {}

codetable = {}

tracebacktable = {}

def wrap_frame(frame):

    fid = id(frame)

    frametable[fid] = frame

    return fid

def wrap_info(info):

    "replace info[2], a traceback instance, by its ID"

    if info is None:

        return None

    else:

        traceback = info[2]

        assert isinstance(traceback, types.TracebackType)

        traceback_id = id(traceback)

        tracebacktable[traceback_id] = traceback

        modified_info = (info[0], info[1], traceback_id)

        return modified_info

class GUIProxy:

    def __init__(self, conn, gui_adap_oid):

        self.conn = conn

        self.oid = gui_adap_oid

    def interaction(self, message, frame, info=None):

        # calls rpc.SocketIO.remotecall() via run.MyHandler instance

        # pass frame and traceback object IDs instead of the objects themselves

        self.conn.remotecall(self.oid, "interaction",

                             (message, wrap_frame(frame), wrap_info(info)),

                             {})

class IdbAdapter:

    def __init__(self, idb):

        self.idb = idb

    #----------called by an IdbProxy----------

    def set_step(self):

        self.idb.set_step()

    def set_quit(self):

        self.idb.set_quit()

    def set_continue(self):

        self.idb.set_continue()

    def set_next(self, fid):

        frame = frametable[fid]

        self.idb.set_next(frame)

    def set_return(self, fid):

        frame = frametable[fid]

        self.idb.set_return(frame)

    def get_stack(self, fid, tbid):

        ##print >>sys.__stderr__, "get_stack(%r, %r)" % (fid, tbid)

        frame = frametable[fid]

        if tbid is None:

            tb = None

        else:

            tb = tracebacktable[tbid]

        stack, i = self.idb.get_stack(frame, tb)

        ##print >>sys.__stderr__, "get_stack() ->", stack

        stack = [(wrap_frame(frame), k) for frame, k in stack]

        ##print >>sys.__stderr__, "get_stack() ->", stack

        return stack, i

    def run(self, cmd):

        import __main__

        self.idb.run(cmd, __main__.__dict__)

    def set_break(self, filename, lineno):

        msg = self.idb.set_break(filename, lineno)

        return msg

    def clear_break(self, filename, lineno):

        msg = self.idb.clear_break(filename, lineno)

        return msg

    def clear_all_file_breaks(self, filename):

        msg = self.idb.clear_all_file_breaks(filename)

        return msg

    #----------called by a FrameProxy----------

    def frame_attr(self, fid, name):

        frame = frametable[fid]

        return getattr(frame, name)

    def frame_globals(self, fid):

        frame = frametable[fid]

        dict = frame.f_globals

        did = id(dict)

        dicttable[did] = dict

        return did

    def frame_locals(self, fid):

        frame = frametable[fid]

        dict = frame.f_locals

        did = id(dict)

        dicttable[did] = dict

        return did

    def frame_code(self, fid):

        frame = frametable[fid]

        code = frame.f_code

        cid = id(code)

        codetable[cid] = code

        return cid

    #----------called by a CodeProxy----------

    def code_name(self, cid):

        code = codetable[cid]

        return code.co_name

    def code_filename(self, cid):

        code = codetable[cid]

        return code.co_filename

    #----------called by a DictProxy----------

    def dict_keys(self, did):

        dict = dicttable[did]

        return dict.keys()

    def dict_item(self, did, key):

        dict = dicttable[did]

        value = dict[key]

        value = repr(value)

        return value

#----------end class IdbAdapter----------

def start_debugger(rpchandler, gui_adap_oid):

    """Start the debugger and its RPC link in the Python subprocess

    Start the subprocess side of the split debugger and set up that side of the

    RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter

    objects and linking them together.  Register the IdbAdapter with the

    RPCServer to handle RPC requests from the split debugger GUI via the

    IdbProxy.

    """

    gui_proxy = GUIProxy(rpchandler, gui_adap_oid)

    idb = Debugger.Idb(gui_proxy)

    idb_adap = IdbAdapter(idb)

    rpchandler.register(idb_adap_oid, idb_adap)

    return idb_adap_oid

#=======================================

#

# In the IDLE process:

class FrameProxy:

    def __init__(self, conn, fid):

        self._conn = conn

        self._fid = fid

        self._oid = "idb_adapter"

        self._dictcache = {}

    def __getattr__(self, name):

        if name[:1] == "_":

            raise AttributeError, name

        if name == "f_code":

            return self._get_f_code()

        if name == "f_globals":

            return self._get_f_globals()

        if name == "f_locals":

            return self._get_f_locals()

        return self._conn.remotecall(self._oid, "frame_attr",

                                     (self._fid, name), {})

    def _get_f_code(self):

        cid = self._conn.remotecall(self._oid, "frame_code", (self._fid,), {})

        return CodeProxy(self._conn, self._oid, cid)

    def _get_f_globals(self):

        did = self._conn.remotecall(self._oid, "frame_globals",

                                    (self._fid,), {})

        return self._get_dict_proxy(did)

    def _get_f_locals(self):

        did = self._conn.remotecall(self._oid, "frame_locals",

                                    (self._fid,), {})

        return self._get_dict_proxy(did)

    def _get_dict_proxy(self, did):

        if self._dictcache.has_key(did):

            return self._dictcache[did]

        dp = DictProxy(self._conn, self._oid, did)

        self._dictcache[did] = dp

        return dp

class CodeProxy:

    def __init__(self, conn, oid, cid):

        self._conn = conn

        self._oid = oid

        self._cid = cid

    def __getattr__(self, name):

        if name == "co_name":

            return self._conn.remotecall(self._oid, "code_name",

                                         (self._cid,), {})

        if name == "co_filename":

            return self._conn.remotecall(self._oid, "code_filename",

                                         (self._cid,), {})

class DictProxy:

    def __init__(self, conn, oid, did):

        self._conn = conn

        self._oid = oid

        self._did = did

    def keys(self):

        return self._conn.remotecall(self._oid, "dict_keys", (self._did,), {})

    def __getitem__(self, key):

        return self._conn.remotecall(self._oid, "dict_item",

                                     (self._did, key), {})

    def __getattr__(self, name):

        ##print >>sys.__stderr__, "failed DictProxy.__getattr__:", name

        raise AttributeError, name

class GUIAdapter:

    def __init__(self, conn, gui):

        self.conn = conn

        self.gui = gui

    def interaction(self, message, fid, modified_info):

        ##print "interaction: (%s, %s, %s)" % (message, fid, modified_info)

        frame = FrameProxy(self.conn, fid)

        self.gui.interaction(message, frame, modified_info)

class IdbProxy:

    def __init__(self, conn, shell, oid):

        self.oid = oid

        self.conn = conn

        self.shell = shell

    def call(self, methodname, *args, **kwargs):

        ##print "**IdbProxy.call %s %s %s" % (methodname, args, kwargs)

        value = self.conn.remotecall(self.oid, methodname, args, kwargs)

        ##print "**IdbProxy.call %s returns %r" % (methodname, value)

        return value

    def run(self, cmd, locals):

        # Ignores locals on purpose!

        seq = self.conn.asyncqueue(self.oid, "run", (cmd,), {})

        self.shell.interp.active_seq = seq

    def get_stack(self, frame, tbid):

        # passing frame and traceback IDs, not the objects themselves

        stack, i = self.call("get_stack", frame._fid, tbid)

        stack = [(FrameProxy(self.conn, fid), k) for fid, k in stack]

        return stack, i

    def set_continue(self):

        self.call("set_continue")

    def set_step(self):

        self.call("set_step")

    def set_next(self, frame):

        self.call("set_next", frame._fid)

    def set_return(self, frame):

        self.call("set_return", frame._fid)

    def set_quit(self):

        self.call("set_quit")

    def set_break(self, filename, lineno):

        msg = self.call("set_break", filename, lineno)

        return msg

    def clear_break(self, filename, lineno):

        msg = self.call("clear_break", filename, lineno)

        return msg

    def clear_all_file_breaks(self, filename):

        msg = self.call("clear_all_file_breaks", filename)

        return msg

def start_remote_debugger(rpcclt, pyshell):

    """Start the subprocess debugger, initialize the debugger GUI and RPC link

    Request the RPCServer start the Python subprocess debugger and link.  Set

    up the Idle side of the split debugger by instantiating the IdbProxy,

    debugger GUI, and debugger GUIAdapter objects and linking them together.

    Register the GUIAdapter with the RPCClient to handle debugger GUI

    interaction requests coming from the subprocess debugger via the GUIProxy.

    The IdbAdapter will pass execution and environment requests coming from the

    Idle debugger GUI to the subprocess debugger via the IdbProxy.

    """

    global idb_adap_oid

    idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\

                                   (gui_adap_oid,), {})

    idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)

    gui = Debugger.Debugger(pyshell, idb_proxy)

    gui_adap = GUIAdapter(rpcclt, gui)

    rpcclt.register(gui_adap_oid, gui_adap)

    return gui

def close_remote_debugger(rpcclt):

    """Shut down subprocess debugger and Idle side of debugger RPC link

    Request that the RPCServer shut down the subprocess debugger and link.

    Unregister the GUIAdapter, which will cause a GC on the Idle process

    debugger and RPC link objects.  (The second reference to the debugger GUI

    is deleted in PyShell.close_remote_debugger().)

    """

    close_subprocess_debugger(rpcclt)

    rpcclt.unregister(gui_adap_oid)

def close_subprocess_debugger(rpcclt):

    rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {})

def restart_subprocess_debugger(rpcclt):

    idb_adap_oid_ret = rpcclt.remotecall("exec", "start_the_debugger",\

                                         (gui_adap_oid,), {})

    assert idb_adap_oid_ret == idb_adap_oid, 'Idb restarted with different oid'