eric: DebugClients/Python/DebugClientBase.py@446515c955f6 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2012 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a debug client base class.
 """
 import sys
 import socket
 import select
 import codeop
 import traceback
 import os
 import time
 import imp
 import re
 import DebugProtocol
 import DebugClientCapabilities
 from DebugBase import setRecursionLimit, printerr   # __IGNORE_WARNING__
 from AsyncFile import AsyncFile, AsyncPendingWrite
 from DebugConfig import ConfigVarTypeStrings
 from FlexCompleter import Completer
 DebugClientInstance = None
 ################################################################################
 def DebugClientRawInput(prompt="", echo=1):
     """
     Replacement for the standard raw_input builtin.
     This function works with the split debugger.
     @param prompt The prompt to be shown. (string)
     @param echo Flag indicating echoing of the input (boolean)
     """
     if DebugClientInstance is None or DebugClientInstance.redirect == 0:
         return DebugClientOrigRawInput(prompt)
     return DebugClientInstance.raw_input(prompt, echo)
 # Use our own raw_input().
 try:
     DebugClientOrigRawInput = __builtins__.__dict__['raw_input']
     __builtins__.__dict__['raw_input'] = DebugClientRawInput
 except (AttributeError, KeyError):
     import __main__
     DebugClientOrigRawInput = __main__.__builtins__.__dict__['raw_input']
     __main__.__builtins__.__dict__['raw_input'] = DebugClientRawInput
 ################################################################################
 def DebugClientInput(prompt=""):
     """
     Replacement for the standard input builtin.
     This function works with the split debugger.
     @param prompt The prompt to be shown. (string)
     """
     if DebugClientInstance is None or DebugClientInstance.redirect == 0:
         return DebugClientOrigInput(prompt)
     return DebugClientInstance.input(prompt)
 # Use our own input().
 try:
     DebugClientOrigInput = __builtins__.__dict__['input']
     __builtins__.__dict__['input'] = DebugClientInput
 except (AttributeError, KeyError):
     import __main__
     DebugClientOrigInput = __main__.__builtins__.__dict__['input']
     __main__.__builtins__.__dict__['input'] = DebugClientInput
 ################################################################################
 def DebugClientFork():
     """
     Replacement for the standard os.fork().
     """
     if DebugClientInstance is None:
         return DebugClientOrigFork()
     return DebugClientInstance.fork()
 # use our own fork().
 if 'fork' in dir(os):
     DebugClientOrigFork = os.fork
     os.fork = DebugClientFork
 ################################################################################
 def DebugClientClose(fd):
     """
     Replacement for the standard os.close(fd).
     @param fd open file descriptor to be closed (integer)
     """
     if DebugClientInstance is None:
         DebugClientOrigClose(fd)
     DebugClientInstance.close(fd)
 # use our own close().
 if 'close' in dir(os):
     DebugClientOrigClose = os.close
     os.close = DebugClientClose
 ################################################################################
 def DebugClientSetRecursionLimit(limit):
     """
     Replacement for the standard sys.setrecursionlimit(limit).
     @param limit recursion limit (integer)
     """
     rl = max(limit, 64)
     setRecursionLimit(rl)
     DebugClientOrigSetRecursionLimit(rl + 64)
 # use our own setrecursionlimit().
 if 'setrecursionlimit' in dir(sys):
     DebugClientOrigSetRecursionLimit = sys.setrecursionlimit
     sys.setrecursionlimit = DebugClientSetRecursionLimit
     DebugClientSetRecursionLimit(sys.getrecursionlimit())
 ################################################################################
 class DebugClientBase(object):
     """
     Class implementing the client side of the debugger.
     It provides access to the Python interpeter from a debugger running in another
     process whether or not the Qt event loop is running.
     The protocol between the debugger and the client assumes that there will be
     a single source of debugger commands and a single source of Python
     statements.  Commands and statement are always exactly one line and may be
     interspersed.
     The protocol is as follows.  First the client opens a connection to the
     debugger and then sends a series of one line commands.  A command is either
     &gt;Load&lt;, &gt;Step&lt;, &gt;StepInto&lt;, ... or a Python statement.
     See DebugProtocol.py for a listing of valid protocol tokens.
     A Python statement consists of the statement to execute, followed (in a
     separate line) by &gt;OK?&lt;.  If the statement was incomplete then the response
     is &gt;Continue&lt;.  If there was an exception then the response is
     &gt;Exception&lt;.
     Otherwise the response is &gt;OK&lt;.  The reason for the &gt;OK?&lt; part is to
     provide a sentinal (ie. the responding &gt;OK&lt;) after any possible output as a
     result of executing the command.
     The client may send any other lines at any other time which should be
     interpreted as program output.
     If the debugger closes the session there is no response from the client.
     The client may close the session at any time as a result of the script
     being debugged closing or crashing.
     <b>Note</b>: This class is meant to be subclassed by individual DebugClient classes.
     Do not instantiate it directly.
     """
     clientCapabilities = DebugClientCapabilities.HasAll
     def __init__(self):
         """
         Constructor
         """
         self.breakpoints = {}
         self.redirect = 1
         # The next couple of members are needed for the threaded version.
         # For this base class they contain static values for the non threaded
         # debugger
         # dictionary of all threads running
         self.threads = {}
         # the "current" thread, basically the thread we are at a breakpoint for.
         self.currentThread = self
         # special objects representing the main scripts thread and frame
         self.mainThread = self
         self.mainFrame = None
         self.framenr = 0
         # The context to run the debugged program in.
         self.debugMod = imp.new_module('__main__')
         # The list of complete lines to execute.
         self.buffer = ''
         # The list of regexp objects to filter variables against
         self.globalsFilterObjects = []
         self.localsFilterObjects = []
         self.pendingResponse = DebugProtocol.ResponseOK
         self.fncache = {}
         self.dircache = []
         self.inRawMode = 0
         self.mainProcStr = None     # used for the passive mode
         self.passive = 0            # used to indicate the passive mode
         self.running = None
         self.test = None
         self.tracePython = 0
         self.debugging = 0
         self.fork_auto = False
         self.fork_child = False
         self.readstream = None
         self.writestream = None
         self.errorstream = None
         self.pollingDisabled = False
         self.skipdirs = sys.path[:]
         self.variant = 'You should not see this'
         # commandline completion stuff
         self.complete = Completer(self.debugMod.__dict__).complete
         if sys.hexversion < 0x2020000:
             self.compile_command = codeop.compile_command
         else:
             self.compile_command = codeop.CommandCompiler()
         self.coding_re = re.compile(r"coding[:=]\s*([-\w_.]+)")
         self.defaultCoding = 'utf-8'
         self.__coding = self.defaultCoding
         self.noencoding = False
     def getCoding(self):
         """
         Public method to return the current coding.
         @return codec name (string)
         """
         return self.__coding
     def __setCoding(self, filename):
         """
         Private method to set the coding used by a python file.
         @param filename name of the file to inspect (string)
         """
         if self.noencoding:
             self.__coding = sys.getdefaultencoding()
         else:
             default = 'latin-1'
             try:
                 f = open(filename, 'rb')
                 # read the first and second line
                 text = f.readline()
                 text = "%s%s" % (text, f.readline())
                 f.close()
             except IOError:
                 self.__coding = default
                 return
             for l in text.splitlines():
                 m = self.coding_re.search(l)
                 if m:
                     self.__coding = m.group(1)
                     return
             self.__coding = default
     def attachThread(self, target=None, args=None, kwargs=None, mainThread=0):
         """
         Public method to setup a thread for DebugClient to debug.
         If mainThread is non-zero, then we are attaching to the already
         started mainthread of the app and the rest of the args are ignored.
         This is just an empty function and is overridden in the threaded
         debugger.
         @param target the start function of the target thread (i.e. the user code)
         @param args arguments to pass to target
         @param kwargs keyword arguments to pass to target
         @param mainThread non-zero, if we are attaching to the already
               started mainthread of the app
         @return The identifier of the created thread
         """
         if self.debugging:
             sys.setprofile(self.profile)
     def __dumpThreadList(self):
         """
         Public method to send the list of threads.
         """
         threadList = []
         if self.threads and self.currentThread:    # indication for the threaded debugger
             currentId = self.currentThread.get_ident()
             for t in self.threads.values():
                 d = {}
                 d["id"] = t.get_ident()
                 d["name"] = t.get_name()
                 d["broken"] = t.isBroken()
                 threadList.append(d)
         else:
             currentId = -1
             d = {}
             d["id"] = -1
             d["name"] = "MainThread"
             d["broken"] = self.isBroken()
             threadList.append(d)
         self.write('%s%s\n' % (DebugProtocol.ResponseThreadList,
                                unicode((currentId, threadList))))
     def raw_input(self, prompt, echo):
         """
         Public method to implement raw_input() using the event loop.
         @param prompt the prompt to be shown (string)
         @param echo Flag indicating echoing of the input (boolean)
         @return the entered string
         """
         self.write("%s%s\n" % (DebugProtocol.ResponseRaw, unicode((prompt, echo))))
         self.inRawMode = 1
         self.eventLoop(True)
         return self.rawLine
     def input(self, prompt):
         """
         Public method to implement input() using the event loop.
         @param prompt the prompt to be shown (string)
         @return the entered string evaluated as a Python expresion
         """
         return eval(self.raw_input(prompt, 1))
     def __exceptionRaised(self):
         """
         Private method called in the case of an exception
         It ensures that the debug server is informed of the raised exception.
         """
         self.pendingResponse = DebugProtocol.ResponseException
     def sessionClose(self, exit=1):
         """
         Public method to close the session with the debugger and optionally terminate.
         @param exit flag indicating to terminate (boolean)
         """
         try:
             self.set_quit()
         except:
             pass
         # clean up asyncio.
         self.disconnect()
         self.debugging = 0
         # make sure we close down our end of the socket
         # might be overkill as normally stdin, stdout and stderr
         # SHOULD be closed on exit, but it does not hurt to do it here
         self.readstream.close(1)
         self.writestream.close(1)
         self.errorstream.close(1)
         if exit:
             # Ok, go away.
             sys.exit()
     def handleLine(self, line):
         """
         Public method to handle the receipt of a complete line.
         It first looks for a valid protocol token at the start of the line. Thereafter
         it trys to execute the lines accumulated so far.
         @param line the received line
         """
         # Remove any newline.
         if line[-1] == '\n':
             line = line[:-1]
 ##        printerr(line)          ##debug
         eoc = line.find('<')
         if eoc >= 0 and line[0] == '>':
             # Get the command part and any argument.
             cmd = line[:eoc + 1]
             arg = line[eoc + 1:]
             if cmd == DebugProtocol.RequestVariables:
                 frmnr, scope, filter = eval(arg)
                 self.__dumpVariables(int(frmnr), int(scope), filter)
                 return
             if cmd == DebugProtocol.RequestVariable:
                 var, frmnr, scope, filter = eval(arg)
                 self.__dumpVariable(var, int(frmnr), int(scope), filter)
                 return
             if cmd == DebugProtocol.RequestThreadList:
                 self.__dumpThreadList()
                 return
             if cmd == DebugProtocol.RequestThreadSet:
                 tid = eval(arg)
                 if tid in self.threads:
                     self.setCurrentThread(tid)
                     self.write(DebugProtocol.ResponseThreadSet + '\n')
                     stack = self.currentThread.getStack()
                     self.write('%s%s\n' % (DebugProtocol.ResponseStack, unicode(stack)))
                 return
             if cmd == DebugProtocol.RequestStep:
                 self.currentThread.step(1)
                 self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestStepOver:
                 self.currentThread.step(0)
                 self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestStepOut:
                 self.currentThread.stepOut()
                 self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestStepQuit:
                 if self.passive:
                     self.progTerminated(42)
                 else:
                     self.set_quit()
                     self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestContinue:
                 special = int(arg)
                 self.currentThread.go(special)
                 self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestOK:
                 self.write(self.pendingResponse + '\n')
                 self.pendingResponse = DebugProtocol.ResponseOK
                 return
             if cmd == DebugProtocol.RequestEnv:
                 env = eval(arg)
                 for key, value in env.items():
                     if key.endswith("+"):
                         if key[:-1] in os.environ:
                             os.environ[key[:-1]] += value
                         else:
                             os.environ[key[:-1]] = value
                     else:
                         os.environ[key] = value
                 return
             if cmd == DebugProtocol.RequestLoad:
                 self.fncache = {}
                 self.dircache = []
                 sys.argv = []
                 wd, fn, args, tracePython = arg.split('|')
                 self.__setCoding(fn)
                 sys.argv.append(fn)
                 sys.argv.extend(eval(args))
                 sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
                 if wd == '':
                     os.chdir(sys.path[1])
                 else:
                     os.chdir(wd)
                 tracePython = int(tracePython)
                 self.running = sys.argv[0]
                 self.mainFrame = None
                 self.inRawMode = 0
                 self.debugging = 1
                 self.threads.clear()
                 self.attachThread(mainThread=1)
                 # set the system exception handling function to ensure, that
                 # we report on all unhandled exceptions
                 sys.excepthook = self.__unhandled_exception
                 # clear all old breakpoints, they'll get set after we have started
                 self.mainThread.clear_all_breaks()
                 self.mainThread.tracePython = tracePython
                 # This will eventually enter a local event loop.
                 # Note the use of backquotes to cause a repr of self.running. The
                 # need for this is on Windows os where backslash is the path separator.
                 # They will get inadvertantly stripped away during the eval causing
                 # IOErrors, if self.running is passed as a normal str.
                 self.debugMod.__dict__['__file__'] = self.running
                 sys.modules['__main__'] = self.debugMod
                 res = self.mainThread.run('execfile(' + repr(self.running) + ')',
                                           self.debugMod.__dict__)
                 self.progTerminated(res)
                 return
             if cmd == DebugProtocol.RequestRun:
                 sys.argv = []
                 wd, fn, args = arg.split('|')
                 self.__setCoding(fn)
                 sys.argv.append(fn)
                 sys.argv.extend(eval(args))
                 sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
                 if wd == '':
                     os.chdir(sys.path[1])
                 else:
                     os.chdir(wd)
                 self.running = sys.argv[0]
                 self.mainFrame = None
                 self.botframe = None
                 self.inRawMode = 0
                 self.threads.clear()
                 self.attachThread(mainThread=1)
                 # set the system exception handling function to ensure, that
                 # we report on all unhandled exceptions
                 sys.excepthook = self.__unhandled_exception
                 self.mainThread.tracePython = 0
                 self.debugMod.__dict__['__file__'] = sys.argv[0]
                 sys.modules['__main__'] = self.debugMod
                 execfile(sys.argv[0], self.debugMod.__dict__)
                 self.writestream.flush()
                 return
             if cmd == DebugProtocol.RequestCoverage:
                 from coverage import coverage
                 sys.argv = []
                 wd, fn, args, erase = arg.split('@@')
                 self.__setCoding(fn)
                 sys.argv.append(fn)
                 sys.argv.extend(eval(args))
                 sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
                 if wd == '':
                     os.chdir(sys.path[1])
                 else:
                     os.chdir(wd)
                 # set the system exception handling function to ensure, that
                 # we report on all unhandled exceptions
                 sys.excepthook = self.__unhandled_exception
                 # generate a coverage object
                 self.cover = coverage(auto_data=True,
                     data_file="%s.coverage" % os.path.splitext(sys.argv[0])[0])
                 self.cover.use_cache(True)
                 if int(erase):
                     self.cover.erase()
                 sys.modules['__main__'] = self.debugMod
                 self.debugMod.__dict__['__file__'] = sys.argv[0]
                 self.cover.start()
                 execfile(sys.argv[0], self.debugMod.__dict__)
                 self.cover.stop()
                 self.cover.save()
                 self.writestream.flush()
                 return
             if cmd == DebugProtocol.RequestProfile:
                 sys.setprofile(None)
                 import PyProfile
                 sys.argv = []
                 wd, fn, args, erase = arg.split('|')
                 self.__setCoding(fn)
                 sys.argv.append(fn)
                 sys.argv.extend(eval(args))
                 sys.path = self.__getSysPath(os.path.dirname(sys.argv[0]))
                 if wd == '':
                     os.chdir(sys.path[1])
                 else:
                     os.chdir(wd)
                 # set the system exception handling function to ensure, that
                 # we report on all unhandled exceptions
                 sys.excepthook = self.__unhandled_exception
                 # generate a profile object
                 self.prof = PyProfile.PyProfile(sys.argv[0])
                 if int(erase):
                     self.prof.erase()
                 self.debugMod.__dict__['__file__'] = sys.argv[0]
                 sys.modules['__main__'] = self.debugMod
                 self.prof.run('execfile(%r)' % sys.argv[0])
                 self.prof.save()
                 self.writestream.flush()
                 return
             if cmd == DebugProtocol.RequestShutdown:
                 self.sessionClose()
                 return
             if cmd == DebugProtocol.RequestBreak:
                 fn, line, temporary, set, cond = arg.split('@@')
                 line = int(line)
                 set = int(set)
                 temporary = int(temporary)
                 if set:
                     if cond == 'None' or cond == '':
                         cond = None
                     else:
                         try:
                             compile(cond, '<string>', 'eval')
                         except SyntaxError:
                             self.write('%s%s,%d\n' % \
                                 (DebugProtocol.ResponseBPConditionError, fn, line))
                             return
                     self.mainThread.set_break(fn, line, temporary, cond)
                 else:
                     self.mainThread.clear_break(fn, line)
                 return
             if cmd == DebugProtocol.RequestBreakEnable:
                 fn, line, enable = arg.split(',')
                 line = int(line)
                 enable = int(enable)
                 bp = self.mainThread.get_break(fn, line)
                 if bp is not None:
                     if enable:
                         bp.enable()
                     else:
                         bp.disable()
                 return
             if cmd == DebugProtocol.RequestBreakIgnore:
                 fn, line, count = arg.split(',')
                 line = int(line)
                 count = int(count)
                 bp = self.mainThread.get_break(fn, line)
                 if bp is not None:
                     bp.ignore = count
                 return
             if cmd == DebugProtocol.RequestWatch:
                 cond, temporary, set = arg.split('@@')
                 set = int(set)
                 temporary = int(temporary)
                 if set:
                     if not cond.endswith('??created??') and \
                        not cond.endswith('??changed??'):
                         try:
                             compile(cond, '<string>', 'eval')
                         except SyntaxError:
                             self.write('%s%s\n' % (
                                 DebugProtocol.ResponseWPConditionError, cond))
                             return
                     self.mainThread.set_watch(cond, temporary)
                 else:
                     self.mainThread.clear_watch(cond)
                 return
             if cmd == DebugProtocol.RequestWatchEnable:
                 cond, enable = arg.split(',')
                 enable = int(enable)
                 bp = self.mainThread.get_watch(cond)
                 if bp is not None:
                     if enable:
                         bp.enable()
                     else:
                         bp.disable()
                 return
             if cmd == DebugProtocol.RequestWatchIgnore:
                 cond, count = arg.split(',')
                 count = int(count)
                 bp = self.mainThread.get_watch(cond)
                 if bp is not None:
                     bp.ignore = count
                 return
             if cmd == DebugProtocol.RequestEval:
                 try:
                     value = eval(arg, self.currentThread.getCurrentFrame().f_globals,
                                       self.currentThread.getCurrentFrameLocals())
                 except:
                     # Report the exception and the traceback
                     try:
                         type, value, tb = sys.exc_info()
                         sys.last_type = type
                         sys.last_value = value
                         sys.last_traceback = tb
                         tblist = traceback.extract_tb(tb)
                         del tblist[:1]
                         list = traceback.format_list(tblist)
                         if list:
                             list.insert(0, "Traceback (innermost last):\n")
                             list[len(list):] = \
                                 traceback.format_exception_only(type, value)
                     finally:
                         tblist = tb = None
                     map(self.write, list)
                     self.write(DebugProtocol.ResponseException + '\n')
                 else:
                     self.write(unicode(value) + '\n')
                     self.write(DebugProtocol.ResponseOK + '\n')
                 return
             if cmd == DebugProtocol.RequestExec:
                 _globals = self.currentThread.getCurrentFrame().f_globals
                 _locals = self.currentThread.getCurrentFrameLocals()
                 try:
                     code = compile(arg + '\n', '<stdin>', 'single')
                     exec code in _globals, _locals
                 except:
                     # Report the exception and the traceback
                     try:
                         type, value, tb = sys.exc_info()
                         sys.last_type = type
                         sys.last_value = value
                         sys.last_traceback = tb
                         tblist = traceback.extract_tb(tb)
                         del tblist[:1]
                         list = traceback.format_list(tblist)
                         if list:
                             list.insert(0, "Traceback (innermost last):\n")
                             list[len(list):] = \
                                 traceback.format_exception_only(type, value)
                     finally:
                         tblist = tb = None
                     map(self.write, list)
                     self.write(DebugProtocol.ResponseException + '\n')
                 return
             if cmd == DebugProtocol.RequestBanner:
                 self.write('%s%s\n' % (DebugProtocol.ResponseBanner,
                     unicode(("Python %s" % sys.version, socket.gethostname(),
                              self.variant))))
                 return
             if cmd == DebugProtocol.RequestCapabilities:
                 self.write('%s%d, "Python"\n' % (DebugProtocol.ResponseCapabilities,
                     self.__clientCapabilities()))
                 return
             if cmd == DebugProtocol.RequestCompletion:
                 self.__completionList(arg)
                 return
             if cmd == DebugProtocol.RequestSetFilter:
                 scope, filterString = eval(arg)
                 self.__generateFilterObjects(int(scope), filterString)
                 return
             if cmd == DebugProtocol.RequestUTPrepare:
                 fn, tn, tfn, failed, cov, covname, erase = arg.split('|')
                 sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
                 os.chdir(sys.path[0])
                 failed = eval(failed)
                 # set the system exception handling function to ensure, that
                 # we report on all unhandled exceptions
                 sys.excepthook = self.__unhandled_exception
                 try:
                     import unittest
                     utModule = __import__(tn)
                     try:
                         if failed:
                             self.test = unittest.defaultTestLoader\
                                         .loadTestsFromNames(failed, utModule)
                         else:
                             self.test = unittest.defaultTestLoader\
                                         .loadTestsFromName(tfn, utModule)
                     except AttributeError:
                         self.test = unittest.defaultTestLoader\
                                     .loadTestsFromModule(utModule)
                 except:
                     exc_type, exc_value, exc_tb = sys.exc_info()
                     self.write('%s%s\n' % (DebugProtocol.ResponseUTPrepared,
                         unicode((0, str(exc_type), str(exc_value)))))
                     self.__exceptionRaised()
                     return
                 # generate a coverage object
                 if int(cov):
                     from coverage import coverage
                     self.cover = coverage(auto_data=True,
                         data_file="%s.coverage" % os.path.splitext(covname)[0])
                     self.cover.use_cache(True)
                     if int(erase):
                         self.cover.erase()
                 else:
                     self.cover = None
                 self.write('%s%s\n' % (DebugProtocol.ResponseUTPrepared,
                     unicode((self.test.countTestCases(), "", ""))))
                 return
             if cmd == DebugProtocol.RequestUTRun:
                 from DCTestResult import DCTestResult
                 self.testResult = DCTestResult(self)
                 if self.cover:
                     self.cover.start()
                 self.test.run(self.testResult)
                 if self.cover:
                     self.cover.stop()
                     self.cover.save()
                 self.write('%s\n' % DebugProtocol.ResponseUTFinished)
                 return
             if cmd == DebugProtocol.RequestUTStop:
                 self.testResult.stop()
                 return
             if cmd == DebugProtocol.ResponseForkTo:
                 # this results from a separate event loop
                 self.fork_child = (arg == 'child')
                 self.eventExit = 1
                 return
             if cmd == DebugProtocol.RequestForkMode:
                 self.fork_auto, self.fork_child = eval(arg)
                 return
         # If we are handling raw mode input then reset the mode and break out
         # of the current event loop.
         if self.inRawMode:
             self.inRawMode = 0
             self.rawLine = line
             self.eventExit = 1
             return
         if self.buffer:
             self.buffer = self.buffer + '\n' + line
         else:
             self.buffer = line
         try:
             code = self.compile_command(self.buffer, self.readstream.name)
         except (OverflowError, SyntaxError, ValueError):
             # Report the exception
             sys.last_type, sys.last_value, sys.last_traceback = sys.exc_info()
             map(self.write, traceback.format_exception_only(sys.last_type, sys.last_value))
             self.buffer = ''
             self.__exceptionRaised()
         else:
             if code is None:
                 self.pendingResponse = DebugProtocol.ResponseContinue
             else:
                 self.buffer = ''
                 try:
                     if self.running is None:
                         exec code in self.debugMod.__dict__
                     else:
                         if self.currentThread is None:
                             # program has terminated
                             self.running = None
                             _globals = self.debugMod.__dict__
                             _locals = _globals
                         else:
                             cf = self.currentThread.getCurrentFrame()
                             # program has terminated
                             if cf is None:
                                 self.running = None
                                 _globals = self.debugMod.__dict__
                                 _locals = _globals
                             else:
                                 frmnr = self.framenr
                                 while cf is not None and frmnr > 0:
                                     cf = cf.f_back
                                     frmnr -= 1
                                 _globals = cf.f_globals
                                 _locals = self.currentThread.getCurrentFrameLocals()
                         # reset sys.stdout to our redirector (unconditionally)
                         if "sys" in _globals:
                             __stdout = _globals["sys"].stdout
                             _globals["sys"].stdout = self.writestream
                             exec code in _globals, _locals
                             _globals["sys"].stdout = __stdout
                         elif "sys" in _locals:
                             __stdout = _locals["sys"].stdout
                             _locals["sys"].stdout = self.writestream
                             exec code in _globals, _locals
                             _locals["sys"].stdout = __stdout
                         else:
                             exec code in _globals, _locals
                 except SystemExit, exc:
                     self.progTerminated(exc.code)
                 except:
                     # Report the exception and the traceback
                     try:
                         type, value, tb = sys.exc_info()
                         sys.last_type = type
                         sys.last_value = value
                         sys.last_traceback = tb
                         tblist = traceback.extract_tb(tb)
                         del tblist[:1]
                         list = traceback.format_list(tblist)
                         if list:
                             list.insert(0, "Traceback (innermost last):\n")
                             list[len(list):] = \
                                 traceback.format_exception_only(type, value)
                     finally:
                         tblist = tb = None
                     map(self.write, list)
                     self.__exceptionRaised()
     def __clientCapabilities(self):
         """
         Private method to determine the clients capabilities.
         @return client capabilities (integer)
         """
         try:
             import PyProfile    # __IGNORE_WARNING__
             try:
                 del sys.modules['PyProfile']
             except KeyError:
                 pass
             return self.clientCapabilities
         except ImportError:
             return self.clientCapabilities & ~DebugClientCapabilities.HasProfiler
     def write(self, s):
         """
         Public method to write data to the output stream.
         @param s data to be written (string)
         """
         self.writestream.write(s)
         self.writestream.flush()
     def __interact(self):
         """
         Private method to Interact with  the debugger.
         """
         global DebugClientInstance
         self.setDescriptors(self.readstream, self.writestream)
         DebugClientInstance = self
         if not self.passive:
             # At this point simulate an event loop.
             self.eventLoop()
     def eventLoop(self, disablePolling=False):
         """
         Public method implementing our event loop.
         @param disablePolling flag indicating to enter an event loop with
             polling disabled (boolean)
         """
         self.eventExit = None
         self.pollingDisabled = disablePolling
         while self.eventExit is None:
             wrdy = []
             if AsyncPendingWrite(self.writestream):
                 wrdy.append(self.writestream)
             if AsyncPendingWrite(self.errorstream):
                 wrdy.append(self.errorstream)
             try:
                 rrdy, wrdy, xrdy = select.select([self.readstream], wrdy, [])
             except (select.error, KeyboardInterrupt, socket.error):
                 # just carry on
                 continue
             if self.readstream in rrdy:
                 self.readReady(self.readstream.fileno())
             if self.writestream in wrdy:
                 self.writeReady(self.writestream.fileno())
             if self.errorstream in wrdy:
                 self.writeReady(self.errorstream.fileno())
         self.eventExit = None
         self.pollingDisabled = False
     def eventPoll(self):
         """
         Public method to poll for events like 'set break point'.
         """
         if self.pollingDisabled:
             return
         # the choice of a ~0.5 second poll interval is arbitrary.
         lasteventpolltime = getattr(self, 'lasteventpolltime', time.time())
         now = time.time()
         if now - lasteventpolltime < 0.5:
             self.lasteventpolltime = lasteventpolltime
             return
         else:
             self.lasteventpolltime = now
         wrdy = []
         if AsyncPendingWrite(self.writestream):
             wrdy.append(self.writestream)
         if AsyncPendingWrite(self.errorstream):
             wrdy.append(self.errorstream)
         # immediate return if nothing is ready.
         try:
             rrdy, wrdy, xrdy = select.select([self.readstream], wrdy, [], 0)
         except (select.error, KeyboardInterrupt, socket.error):
             return
         if self.readstream in rrdy:
             self.readReady(self.readstream.fileno())
         if self.writestream in wrdy:
             self.writeReady(self.writestream.fileno())
         if self.errorstream in wrdy:
             self.writeReady(self.errorstream.fileno())
     def connectDebugger(self, port, remoteAddress=None, redirect=1):
         """
         Public method to establish a session with the debugger.
         It opens a network connection to the debugger, connects it to stdin,
         stdout and stderr and saves these file objects in case the application
         being debugged redirects them itself.
         @param port the port number to connect to (int)
         @param remoteAddress the network address of the debug server host (string)
         @param redirect flag indicating redirection of stdin, stdout and stderr (boolean)
         """
         if remoteAddress is None:                               # default: 127.0.0.1
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.connect((DebugProtocol.DebugAddress, port))
         else:
             if "@@i" in remoteAddress:
                 remoteAddress, index = remoteAddress.split("@@i")
             else:
                 index = 0
             if ":" in remoteAddress:                              # IPv6
                 sockaddr = socket.getaddrinfo(
                     remoteAddress, port, 0, 0, socket.SOL_TCP)[0][-1]
                 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                 sockaddr = sockaddr[:-1] + (int(index),)
                 sock.connect(sockaddr)
             else:                                                   # IPv4
                 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                 sock.connect((remoteAddress, port))
         self.readstream = AsyncFile(sock, sys.stdin.mode, sys.stdin.name)
         self.writestream = AsyncFile(sock, sys.stdout.mode, sys.stdout.name)
         self.errorstream = AsyncFile(sock, sys.stderr.mode, sys.stderr.name)
         if redirect:
             sys.stdin = self.readstream
             sys.stdout = self.writestream
             sys.stderr = self.errorstream
         self.redirect = redirect
         # attach to the main thread here
         self.attachThread(mainThread=1)
     def __unhandled_exception(self, exctype, excval, exctb):
         """
         Private method called to report an uncaught exception.
         @param exctype the type of the exception
         @param excval data about the exception
         @param exctb traceback for the exception
         """
         self.mainThread.user_exception(None, (exctype, excval, exctb), 1)
     def absPath(self, fn):
         """
         Public method to convert a filename to an absolute name.
         sys.path is used as a set of possible prefixes. The name stays
         relative if a file could not be found.
         @param fn filename (string)
         @return the converted filename (string)
         """
         if os.path.isabs(fn):
             return fn
         # Check the cache.
         if fn in self.fncache:
             return self.fncache[fn]
         # Search sys.path.
         for p in sys.path:
             afn = os.path.abspath(os.path.join(p, fn))
             nafn = os.path.normcase(afn)

Mercurial Repositories > eric / annotate

DebugClients/Python/DebugClientBase.py@446515c955f6 (annotated)

DebugClients/Python/DebugClientBase.py