debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/thread.py

@@ -39,7 +39,7 @@ from __future__ import with_statement
 
 __revision__ = "$Id$"
 
-__all__ = ['Thread']
+__all__ = ["Thread"]
 
 from winappdbg import win32
 from winappdbg import compat
@@ -54,12 +54,13 @@ import warnings
 # delayed imports
 Process = None
 
-#==============================================================================
+# ==============================================================================
 
 # TODO
 # + fetch special registers (MMX, XMM, 3DNow!, etc)
 
-class Thread (object):
+
+class Thread(object):
     """
     Interface to a thread in another process.
 
@@ -126,7 +127,7 @@ class Thread (object):
         when the injected thread is killed.
     """
 
-    def __init__(self, dwThreadId, hThread = None, process = None):
+    def __init__(self, dwThreadId, hThread=None, process=None):
         """
         @type  dwThreadId: int
         @param dwThreadId: Global thread ID.
@@ -137,34 +138,34 @@ class Thread (object):
         @type  process: L{Process}
         @param process: (Optional) Parent Process object.
         """
-        self.dwProcessId     = None
-        self.dwThreadId      = dwThreadId
-        self.hThread         = hThread
+        self.dwProcessId = None
+        self.dwThreadId = dwThreadId
+        self.hThread = hThread
         self.pInjectedMemory = None
         self.set_name(None)
         self.set_process(process)
 
     # Not really sure if it's a good idea...
-##    def __eq__(self, aThread):
-##        """
-##        Compare two Thread objects. The comparison is made using the IDs.
-##
-##        @warning:
-##            If you have two Thread instances with different handles the
-##            equality operator still returns C{True}, so be careful!
-##
-##        @type  aThread: L{Thread}
-##        @param aThread: Another Thread object.
-##
-##        @rtype:  bool
-##        @return: C{True} if the two thread IDs are equal,
-##            C{False} otherwise.
-##        """
-##        return isinstance(aThread, Thread)           and \
-##               self.get_tid() == aThread.get_tid()
+    ##    def __eq__(self, aThread):
+    ##        """
+    ##        Compare two Thread objects. The comparison is made using the IDs.
+    ##
+    ##        @warning:
+    ##            If you have two Thread instances with different handles the
+    ##            equality operator still returns C{True}, so be careful!
+    ##
+    ##        @type  aThread: L{Thread}
+    ##        @param aThread: Another Thread object.
+    ##
+    ##        @rtype:  bool
+    ##        @return: C{True} if the two thread IDs are equal,
+    ##            C{False} otherwise.
+    ##        """
+    ##        return isinstance(aThread, Thread)           and \
+    ##               self.get_tid() == aThread.get_tid()
 
     def __load_Process_class(self):
-        global Process      # delayed import
+        global Process  # delayed import
         if Process is None:
             from winappdbg.process import Process
 
@@ -180,7 +181,7 @@ class Thread (object):
         self.__process = Process(self.get_pid())
         return self.__process
 
-    def set_process(self, process = None):
+    def set_process(self, process=None):
         """
         Manually set the parent Process object. Use with care!
 
@@ -189,11 +190,11 @@ class Thread (object):
         """
         if process is None:
             self.dwProcessId = None
-            self.__process   = None
+            self.__process = None
         else:
             self.__load_Process_class()
             if not isinstance(process, Process):
-                msg  = "Parent process must be a Process instance, "
+                msg = "Parent process must be a Process instance, "
                 msg += "got %s instead" % type(process)
                 raise TypeError(msg)
             self.dwProcessId = process.get_pid()
@@ -217,8 +218,7 @@ class Thread (object):
                 try:
                     # I wish this had been implemented before Vista...
                     # XXX TODO find the real ntdll call under this api
-                    hThread = self.get_handle(
-                                        win32.THREAD_QUERY_LIMITED_INFORMATION)
+                    hThread = self.get_handle(win32.THREAD_QUERY_LIMITED_INFORMATION)
                     self.dwProcessId = win32.GetProcessIdOfThread(hThread)
                 except AttributeError:
                     # This method is really bad :P
@@ -226,7 +226,7 @@ class Thread (object):
         return self.dwProcessId
 
     def __get_pid_by_scanning(self):
-        'Internally used by get_pid().'
+        "Internally used by get_pid()."
         dwProcessId = None
         dwThreadId = self.get_tid()
         with win32.CreateToolhelp32Snapshot(win32.TH32CS_SNAPTHREAD) as hSnapshot:
@@ -255,7 +255,7 @@ class Thread (object):
         """
         return self.name
 
-    def set_name(self, name = None):
+    def set_name(self, name=None):
         """
         Sets the thread's name.
 
@@ -264,9 +264,9 @@ class Thread (object):
         """
         self.name = name
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def open_handle(self, dwDesiredAccess = win32.THREAD_ALL_ACCESS):
+    def open_handle(self, dwDesiredAccess=win32.THREAD_ALL_ACCESS):
         """
         Opens a new handle to the thread, closing the previous one.
 
@@ -289,7 +289,7 @@ class Thread (object):
 
         # In case hThread was set to an actual handle value instead of a Handle
         # object. This shouldn't happen unless the user tinkered with it.
-        if not hasattr(self.hThread, '__del__'):
+        if not hasattr(self.hThread, "__del__"):
             self.close_handle()
 
         self.hThread = hThread
@@ -303,14 +303,14 @@ class Thread (object):
             collector claims them.
         """
         try:
-            if hasattr(self.hThread, 'close'):
+            if hasattr(self.hThread, "close"):
                 self.hThread.close()
             elif self.hThread not in (None, win32.INVALID_HANDLE_VALUE):
                 win32.CloseHandle(self.hThread)
         finally:
             self.hThread = None
 
-    def get_handle(self, dwDesiredAccess = win32.THREAD_ALL_ACCESS):
+    def get_handle(self, dwDesiredAccess=win32.THREAD_ALL_ACCESS):
         """
         Returns a handle to the thread with I{at least} the access rights
         requested.
@@ -349,9 +349,9 @@ class Thread (object):
         finally:
             self.close_handle()
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def wait(self, dwTimeout = None):
+    def wait(self, dwTimeout=None):
         """
         Waits for the thread to finish executing.
 
@@ -361,7 +361,7 @@ class Thread (object):
         """
         self.get_handle(win32.SYNCHRONIZE).wait(dwTimeout)
 
-    def kill(self, dwExitCode = 0):
+    def kill(self, dwExitCode=0):
         """
         Terminates the thread execution.
 
@@ -381,7 +381,7 @@ class Thread (object):
                 self.get_process().free(self.pInjectedMemory)
                 self.pInjectedMemory = None
             except Exception:
-##                raise           # XXX DEBUG
+                ##                raise           # XXX DEBUG
                 pass
 
     # XXX TODO
@@ -441,9 +441,9 @@ class Thread (object):
             dwAccess = win32.THREAD_QUERY_LIMITED_INFORMATION
         else:
             dwAccess = win32.THREAD_QUERY_INFORMATION
-        return win32.GetExitCodeThread( self.get_handle(dwAccess) )
+        return win32.GetExitCodeThread(self.get_handle(dwAccess))
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX TODO
     # Support for string searches on the window captions.
@@ -457,16 +457,13 @@ class Thread (object):
             process = self.get_process()
         except Exception:
             process = None
-        return [
-                Window( hWnd, process, self ) \
-                for hWnd in win32.EnumThreadWindows( self.get_tid() )
-                ]
+        return [Window(hWnd, process, self) for hWnd in win32.EnumThreadWindows(self.get_tid())]
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # TODO
     # A registers cache could be implemented here.
-    def get_context(self, ContextFlags = None, bSuspend = False):
+    def get_context(self, ContextFlags=None, bSuspend=False):
         """
         Retrieves the execution context (i.e. the registers values) for this
         thread.
@@ -523,37 +520,30 @@ class Thread (object):
 
         # If an exception is raised, make sure the thread execution is resumed.
         try:
-
             if win32.bits == self.get_bits():
-
                 # 64 bit debugger attached to 64 bit process, or
                 # 32 bit debugger attached to 32 bit process.
-                ctx = win32.GetThreadContext(hThread,
-                                             ContextFlags = ContextFlags)
+                ctx = win32.GetThreadContext(hThread, ContextFlags=ContextFlags)
 
             else:
                 if self.is_wow64():
-
                     # 64 bit debugger attached to 32 bit process.
                     if ContextFlags is not None:
                         ContextFlags &= ~win32.ContextArchMask
-                        ContextFlags |=  win32.WOW64_CONTEXT_i386
+                        ContextFlags |= win32.WOW64_CONTEXT_i386
                     ctx = win32.Wow64GetThreadContext(hThread, ContextFlags)
 
                 else:
-
                     # 32 bit debugger attached to 64 bit process.
                     # XXX only i386/AMD64 is supported in this particular case
                     if win32.arch not in (win32.ARCH_I386, win32.ARCH_AMD64):
                         raise NotImplementedError()
                     if ContextFlags is not None:
                         ContextFlags &= ~win32.ContextArchMask
-                        ContextFlags |=  win32.context_amd64.CONTEXT_AMD64
-                    ctx = win32.context_amd64.GetThreadContext(hThread,
-                                                 ContextFlags = ContextFlags)
+                        ContextFlags |= win32.context_amd64.CONTEXT_AMD64
+                    ctx = win32.context_amd64.GetThreadContext(hThread, ContextFlags=ContextFlags)
 
         finally:
-
             # Resume the thread if we suspended it.
             if bSuspend:
                 self.resume()
@@ -561,7 +551,7 @@ class Thread (object):
         # Return the context.
         return ctx
 
-    def set_context(self, context, bSuspend = False):
+    def set_context(self, context, bSuspend=False):
         """
         Sets the values of the registers.
 
@@ -614,7 +604,7 @@ class Thread (object):
         @rtype:  int
         @return: Value of the requested register.
         """
-        'Returns the value of a specific register.'
+        "Returns the value of a specific register."
         context = self.get_context()
         return context[register]
 
@@ -632,7 +622,7 @@ class Thread (object):
         context[register] = value
         self.set_context(context)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # TODO: a metaclass would do a better job instead of checking the platform
     #       during module import, also would support mixing 32 and 64 bits
@@ -698,26 +688,27 @@ class Thread (object):
             context.fp = fp
             self.set_context(context)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     if win32.arch in (win32.ARCH_I386, win32.ARCH_AMD64):
 
-        class Flags (object):
-            'Commonly used processor flags'
-            Overflow    = 0x800
-            Direction   = 0x400
-            Interrupts  = 0x200
-            Trap        = 0x100
-            Sign        = 0x80
-            Zero        = 0x40
+        class Flags(object):
+            "Commonly used processor flags"
+
+            Overflow = 0x800
+            Direction = 0x400
+            Interrupts = 0x200
+            Trap = 0x100
+            Sign = 0x80
+            Zero = 0x40
             # 0x20 ???
-            Auxiliary   = 0x10
+            Auxiliary = 0x10
             # 0x8 ???
-            Parity      = 0x4
+            Parity = 0x4
             # 0x2 ???
-            Carry       = 0x1
+            Carry = 0x1
 
-        def get_flags(self, FlagMask = 0xFFFFFFFF):
+        def get_flags(self, FlagMask=0xFFFFFFFF):
             """
             @type  FlagMask: int
             @param FlagMask: (Optional) Bitwise-AND mask.
@@ -726,9 +717,9 @@ class Thread (object):
             @return: Flags register contents, optionally masking out some bits.
             """
             context = self.get_context(win32.CONTEXT_CONTROL)
-            return context['EFlags'] & FlagMask
+            return context["EFlags"] & FlagMask
 
-        def set_flags(self, eflags, FlagMask = 0xFFFFFFFF):
+        def set_flags(self, eflags, FlagMask=0xFFFFFFFF):
             """
             Sets the flags register, optionally masking some bits.
 
@@ -739,7 +730,7 @@ class Thread (object):
             @param FlagMask: (Optional) Bitwise-AND mask.
             """
             context = self.get_context(win32.CONTEXT_CONTROL)
-            context['EFlags'] = (context['EFlags'] & FlagMask) | eflags
+            context["EFlags"] = (context["EFlags"] & FlagMask) | eflags
             self.set_context(context)
 
         def get_flag_value(self, FlagBit):
@@ -750,7 +741,7 @@ class Thread (object):
             @rtype:  bool
             @return: Boolean value of the requested flag.
             """
-            return bool( self.get_flags(FlagBit) )
+            return bool(self.get_flags(FlagBit))
 
         def set_flag_value(self, FlagBit, FlagValue):
             """
@@ -805,46 +796,46 @@ class Thread (object):
             return self.get_flag_value(self.Flags.Trap)
 
         def clear_zf(self):
-            'Clears the Zero flag.'
+            "Clears the Zero flag."
             self.set_flag_value(self.Flags.Zero, False)
 
         def clear_cf(self):
-            'Clears the Carry flag.'
+            "Clears the Carry flag."
             self.set_flag_value(self.Flags.Carry, False)
 
         def clear_sf(self):
-            'Clears the Sign flag.'
+            "Clears the Sign flag."
             self.set_flag_value(self.Flags.Sign, False)
 
         def clear_df(self):
-            'Clears the Direction flag.'
+            "Clears the Direction flag."
             self.set_flag_value(self.Flags.Direction, False)
 
         def clear_tf(self):
-            'Clears the Trap flag.'
+            "Clears the Trap flag."
             self.set_flag_value(self.Flags.Trap, False)
 
         def set_zf(self):
-            'Sets the Zero flag.'
+            "Sets the Zero flag."
             self.set_flag_value(self.Flags.Zero, True)
 
         def set_cf(self):
-            'Sets the Carry flag.'
+            "Sets the Carry flag."
             self.set_flag_value(self.Flags.Carry, True)
 
         def set_sf(self):
-            'Sets the Sign flag.'
+            "Sets the Sign flag."
             self.set_flag_value(self.Flags.Sign, True)
 
         def set_df(self):
-            'Sets the Direction flag.'
+            "Sets the Direction flag."
             self.set_flag_value(self.Flags.Direction, True)
 
         def set_tf(self):
-            'Sets the Trap flag.'
+            "Sets the Trap flag."
             self.set_flag_value(self.Flags.Trap, True)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def is_wow64(self):
         """
@@ -866,7 +857,7 @@ class Thread (object):
         try:
             wow64 = self.__wow64
         except AttributeError:
-            if (win32.bits == 32 and not win32.wow64):
+            if win32.bits == 32 and not win32.wow64:
                 wow64 = False
             else:
                 wow64 = self.get_process().is_wow64()
@@ -909,8 +900,9 @@ class Thread (object):
             events, and thus said events won't be sent to the debugger.
         """
         return win32.NtQueryInformationThread(
-                    self.get_handle(),      # XXX what permissions do I need?
-                    win32.ThreadHideFromDebugger)
+            self.get_handle(),  # XXX what permissions do I need?
+            win32.ThreadHideFromDebugger,
+        )
 
     def get_teb(self):
         """
@@ -921,8 +913,7 @@ class Thread (object):
         @return: TEB structure.
         @raise WindowsError: An exception is raised on error.
         """
-        return self.get_process().read_structure( self.get_teb_address(),
-                                                  win32.TEB )
+        return self.get_process().read_structure(self.get_teb_address(), win32.TEB)
 
     def get_teb_address(self):
         """
@@ -937,11 +928,10 @@ class Thread (object):
         except AttributeError:
             try:
                 hThread = self.get_handle(win32.THREAD_QUERY_INFORMATION)
-                tbi = win32.NtQueryInformationThread( hThread,
-                                                win32.ThreadBasicInformation)
+                tbi = win32.NtQueryInformationThread(hThread, win32.ThreadBasicInformation)
                 address = tbi.TebBaseAddress
             except WindowsError:
-                address = self.get_linear_address('SegFs', 0)   # fs:[0]
+                address = self.get_linear_address("SegFs", 0)  # fs:[0]
                 if not address:
                     raise
             self._teb_ptr = address
@@ -969,20 +959,19 @@ class Thread (object):
             The current architecture does not support selectors.
             Selectors only exist in x86-based systems.
         """
-        hThread  = self.get_handle(win32.THREAD_QUERY_INFORMATION)
+        hThread = self.get_handle(win32.THREAD_QUERY_INFORMATION)
         selector = self.get_register(segment)
-        ldt      = win32.GetThreadSelectorEntry(hThread, selector)
-        BaseLow  = ldt.BaseLow
-        BaseMid  = ldt.HighWord.Bytes.BaseMid << 16
-        BaseHi   = ldt.HighWord.Bytes.BaseHi  << 24
-        Base     = BaseLow | BaseMid | BaseHi
+        ldt = win32.GetThreadSelectorEntry(hThread, selector)
+        BaseLow = ldt.BaseLow
+        BaseMid = ldt.HighWord.Bytes.BaseMid << 16
+        BaseHi = ldt.HighWord.Bytes.BaseHi << 24
+        Base = BaseLow | BaseMid | BaseHi
         LimitLow = ldt.LimitLow
-        LimitHi  = ldt.HighWord.Bits.LimitHi  << 16
-        Limit    = LimitLow | LimitHi
+        LimitHi = ldt.HighWord.Bits.LimitHi << 16
+        Limit = LimitLow | LimitHi
         if address > Limit:
             msg = "Address %s too large for segment %s (selector %d)"
-            msg = msg % (HexDump.address(address, self.get_bits()),
-                         segment, selector)
+            msg = msg % (HexDump.address(address, self.get_bits()), segment, selector)
             raise ValueError(msg)
         return Base + address
 
@@ -991,7 +980,7 @@ class Thread (object):
         @rtype:  str
         @return: Label that points to the instruction currently being executed.
         """
-        return self.get_process().get_label_at_address( self.get_pc() )
+        return self.get_process().get_label_at_address(self.get_pc())
 
     def get_seh_chain_pointer(self):
         """
@@ -1006,12 +995,11 @@ class Thread (object):
             This method is only supported in 32 bits versions of Windows.
         """
         if win32.arch != win32.ARCH_I386:
-            raise NotImplementedError(
-                "SEH chain parsing is only supported in 32-bit Windows.")
+            raise NotImplementedError("SEH chain parsing is only supported in 32-bit Windows.")
 
         process = self.get_process()
-        address = self.get_linear_address( 'SegFs', 0 )
-        return process.read_pointer( address )
+        address = self.get_linear_address("SegFs", 0)
+        return process.read_pointer(address)
 
     def set_seh_chain_pointer(self, value):
         """
@@ -1026,12 +1014,11 @@ class Thread (object):
             This method is only supported in 32 bits versions of Windows.
         """
         if win32.arch != win32.ARCH_I386:
-            raise NotImplementedError(
-                "SEH chain parsing is only supported in 32-bit Windows.")
+            raise NotImplementedError("SEH chain parsing is only supported in 32-bit Windows.")
 
         process = self.get_process()
-        address = self.get_linear_address( 'SegFs', 0 )
-        process.write_pointer( address, value )
+        address = self.get_linear_address("SegFs", 0)
+        process.write_pointer(address, value)
 
     def get_seh_chain(self):
         """
@@ -1051,11 +1038,11 @@ class Thread (object):
             process = self.get_process()
             seh = self.get_seh_chain_pointer()
             while seh != 0xFFFFFFFF:
-                seh_func = process.read_pointer( seh + 4 )
-                seh_chain.append( (seh, seh_func) )
-                seh = process.read_pointer( seh )
+                seh_func = process.read_pointer(seh + 4)
+                seh_chain.append((seh, seh_func))
+                seh = process.read_pointer(seh)
         except WindowsError:
-            seh_chain.append( (seh, None) )
+            seh_chain.append((seh, None))
         return seh_chain
 
     def get_wait_chain(self):
@@ -1073,7 +1060,7 @@ class Thread (object):
             U{http://msdn.microsoft.com/en-us/library/ms681622%28VS.85%29.aspx}
         """
         with win32.OpenThreadWaitChainSession() as hWct:
-            return win32.GetThreadWaitChain(hWct, ThreadId = self.get_tid())
+            return win32.GetThreadWaitChain(hWct, ThreadId=self.get_tid())
 
     def get_stack_range(self):
         """
@@ -1087,10 +1074,9 @@ class Thread (object):
         # TODO use teb.DeallocationStack too (max. possible stack size)
         teb = self.get_teb()
         tib = teb.NtTib
-        return ( tib.StackLimit, tib.StackBase )    # top, bottom
+        return (tib.StackLimit, tib.StackBase)  # top, bottom
 
-    def __get_stack_trace(self, depth = 16, bUseLabels = True,
-                                                           bMakePretty = True):
+    def __get_stack_trace(self, depth=16, bUseLabels=True, bMakePretty=True):
         """
         Tries to get a stack trace for the current function using the debug
         helper API (dbghelp.dll).
@@ -1133,15 +1119,13 @@ class Thread (object):
             msg = "Stack walking is not available for this architecture: %s"
             raise NotImplementedError(msg % arch)
 
-        hProcess = aProcess.get_handle( win32.PROCESS_VM_READ |
-                                        win32.PROCESS_QUERY_INFORMATION )
-        hThread  = self.get_handle( win32.THREAD_GET_CONTEXT |
-                                    win32.THREAD_QUERY_INFORMATION )
+        hProcess = aProcess.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
+        hThread = self.get_handle(win32.THREAD_GET_CONTEXT | win32.THREAD_QUERY_INFORMATION)
 
         StackFrame = win32.STACKFRAME64()
-        StackFrame.AddrPC    = win32.ADDRESS64( self.get_pc() )
-        StackFrame.AddrFrame = win32.ADDRESS64( self.get_fp() )
-        StackFrame.AddrStack = win32.ADDRESS64( self.get_sp() )
+        StackFrame.AddrPC = win32.ADDRESS64(self.get_pc())
+        StackFrame.AddrFrame = win32.ADDRESS64(self.get_fp())
+        StackFrame.AddrStack = win32.ADDRESS64(self.get_sp())
 
         trace = list()
         while win32.StackWalk64(MachineType, hProcess, hThread, StackFrame):
@@ -1162,15 +1146,14 @@ class Thread (object):
             if bUseLabels:
                 label = aProcess.get_label_at_address(ra)
                 if bMakePretty:
-                    label = '%s (%s)' % (HexDump.address(ra, bits), label)
-                trace.append( (fp, label) )
+                    label = "%s (%s)" % (HexDump.address(ra, bits), label)
+                trace.append((fp, label))
             else:
-                trace.append( (fp, ra, lib) )
+                trace.append((fp, ra, lib))
             fp = aProcess.peek_pointer(fp)
         return tuple(trace)
 
-    def __get_stack_trace_manually(self, depth = 16, bUseLabels = True,
-                                                           bMakePretty = True):
+    def __get_stack_trace_manually(self, depth=16, bUseLabels=True, bMakePretty=True):
         """
         Tries to get a stack trace for the current function.
         Only works for functions with standard prologue and epilogue.
@@ -1199,9 +1182,9 @@ class Thread (object):
         @raise WindowsError: Raises an exception on error.
         """
         aProcess = self.get_process()
-        st, sb   = self.get_stack_range()   # top, bottom
-        fp       = self.get_fp()
-        trace    = list()
+        st, sb = self.get_stack_range()  # top, bottom
+        fp = self.get_fp()
+        trace = list()
         if aProcess.get_module_count() == 0:
             aProcess.scan_modules()
         bits = aProcess.get_bits()
@@ -1210,7 +1193,7 @@ class Thread (object):
                 break
             if not st <= fp < sb:
                 break
-            ra  = aProcess.peek_pointer(fp + 4)
+            ra = aProcess.peek_pointer(fp + 4)
             if ra == 0:
                 break
             lib = aProcess.get_module_at_address(ra)
@@ -1224,14 +1207,14 @@ class Thread (object):
             if bUseLabels:
                 label = aProcess.get_label_at_address(ra)
                 if bMakePretty:
-                    label = '%s (%s)' % (HexDump.address(ra, bits), label)
-                trace.append( (fp, label) )
+                    label = "%s (%s)" % (HexDump.address(ra, bits), label)
+                trace.append((fp, label))
             else:
-                trace.append( (fp, ra, lib) )
+                trace.append((fp, ra, lib))
             fp = aProcess.peek_pointer(fp)
         return tuple(trace)
 
-    def get_stack_trace(self, depth = 16):
+    def get_stack_trace(self, depth=16):
         """
         Tries to get a stack trace for the current function.
         Only works for functions with standard prologue and epilogue.
@@ -1249,13 +1232,14 @@ class Thread (object):
             trace = self.__get_stack_trace(depth, False)
         except Exception:
             import traceback
+
             traceback.print_exc()
             trace = ()
         if not trace:
             trace = self.__get_stack_trace_manually(depth, False)
         return trace
 
-    def get_stack_trace_with_labels(self, depth = 16, bMakePretty = True):
+    def get_stack_trace_with_labels(self, depth=16, bMakePretty=True):
         """
         Tries to get a stack trace for the current function.
         Only works for functions with standard prologue and epilogue.
@@ -1300,19 +1284,19 @@ class Thread (object):
 
         @raise WindowsError: An error occured when getting the thread context.
         """
-        st, sb   = self.get_stack_range()   # top, bottom
-        sp       = self.get_sp()
-        fp       = self.get_fp()
-        size     = fp - sp
+        st, sb = self.get_stack_range()  # top, bottom
+        sp = self.get_sp()
+        fp = self.get_fp()
+        size = fp - sp
         if not st <= sp < sb:
-            raise RuntimeError('Stack pointer lies outside the stack')
+            raise RuntimeError("Stack pointer lies outside the stack")
         if not st <= fp < sb:
-            raise RuntimeError('Frame pointer lies outside the stack')
+            raise RuntimeError("Frame pointer lies outside the stack")
         if sp > fp:
-            raise RuntimeError('No valid stack frame found')
+            raise RuntimeError("No valid stack frame found")
         return (sp, fp)
 
-    def get_stack_frame(self, max_size = None):
+    def get_stack_frame(self, max_size=None):
         """
         Reads the contents of the current stack frame.
         Only works for functions with standard prologue and epilogue.
@@ -1332,13 +1316,13 @@ class Thread (object):
         @raise WindowsError: An error occured when getting the thread context
             or reading data from the process memory.
         """
-        sp, fp   = self.get_stack_frame_range()
-        size     = fp - sp
+        sp, fp = self.get_stack_frame_range()
+        size = fp - sp
         if max_size and size > max_size:
             size = max_size
         return self.get_process().peek(sp, size)
 
-    def read_stack_data(self, size = 128, offset = 0):
+    def read_stack_data(self, size=128, offset=0):
         """
         Reads the contents of the top of the stack.
 
@@ -1356,7 +1340,7 @@ class Thread (object):
         aProcess = self.get_process()
         return aProcess.read(self.get_sp() + offset, size)
 
-    def peek_stack_data(self, size = 128, offset = 0):
+    def peek_stack_data(self, size=128, offset=0):
         """
         Tries to read the contents of the top of the stack.
 
@@ -1373,7 +1357,7 @@ class Thread (object):
         aProcess = self.get_process()
         return aProcess.peek(self.get_sp() + offset, size)
 
-    def read_stack_dwords(self, count, offset = 0):
+    def read_stack_dwords(self, count, offset=0):
         """
         Reads DWORDs from the top of the stack.
 
@@ -1390,10 +1374,10 @@ class Thread (object):
         """
         if count > 0:
             stackData = self.read_stack_data(count * 4, offset)
-            return struct.unpack('<'+('L'*count), stackData)
+            return struct.unpack("<" + ("L" * count), stackData)
         return ()
 
-    def peek_stack_dwords(self, count, offset = 0):
+    def peek_stack_dwords(self, count, offset=0):
         """
         Tries to read DWORDs from the top of the stack.
 
@@ -1409,12 +1393,12 @@ class Thread (object):
         """
         stackData = self.peek_stack_data(count * 4, offset)
         if len(stackData) & 3:
-            stackData = stackData[:-len(stackData) & 3]
+            stackData = stackData[: -len(stackData) & 3]
         if not stackData:
             return ()
-        return struct.unpack('<'+('L'*count), stackData)
+        return struct.unpack("<" + ("L" * count), stackData)
 
-    def read_stack_qwords(self, count, offset = 0):
+    def read_stack_qwords(self, count, offset=0):
         """
         Reads QWORDs from the top of the stack.
 
@@ -1430,9 +1414,9 @@ class Thread (object):
         @raise WindowsError: Could not read the requested data.
         """
         stackData = self.read_stack_data(count * 8, offset)
-        return struct.unpack('<'+('Q'*count), stackData)
+        return struct.unpack("<" + ("Q" * count), stackData)
 
-    def peek_stack_qwords(self, count, offset = 0):
+    def peek_stack_qwords(self, count, offset=0):
         """
         Tries to read QWORDs from the top of the stack.
 
@@ -1448,12 +1432,12 @@ class Thread (object):
         """
         stackData = self.peek_stack_data(count * 8, offset)
         if len(stackData) & 7:
-            stackData = stackData[:-len(stackData) & 7]
+            stackData = stackData[: -len(stackData) & 7]
         if not stackData:
             return ()
-        return struct.unpack('<'+('Q'*count), stackData)
+        return struct.unpack("<" + ("Q" * count), stackData)
 
-    def read_stack_structure(self, structure, offset = 0):
+    def read_stack_structure(self, structure, offset=0):
         """
         Reads the given structure at the top of the stack.
 
@@ -1468,12 +1452,11 @@ class Thread (object):
         @return: Tuple of elements read from the stack. The type of each
             element matches the types in the stack frame structure.
         """
-        aProcess  = self.get_process()
+        aProcess = self.get_process()
         stackData = aProcess.read_structure(self.get_sp() + offset, structure)
-        return tuple([ stackData.__getattribute__(name)
-                       for (name, type) in stackData._fields_ ])
+        return tuple([stackData.__getattribute__(name) for (name, type) in stackData._fields_])
 
-    def read_stack_frame(self, structure, offset = 0):
+    def read_stack_frame(self, structure, offset=0):
         """
         Reads the stack frame of the thread.
 
@@ -1488,12 +1471,11 @@ class Thread (object):
         @return: Tuple of elements read from the stack frame. The type of each
             element matches the types in the stack frame structure.
         """
-        aProcess  = self.get_process()
+        aProcess = self.get_process()
         stackData = aProcess.read_structure(self.get_fp() + offset, structure)
-        return tuple([ stackData.__getattribute__(name)
-                       for (name, type) in stackData._fields_ ])
+        return tuple([stackData.__getattribute__(name) for (name, type) in stackData._fields_])
 
-    def read_code_bytes(self, size = 128, offset = 0):
+    def read_code_bytes(self, size=128, offset=0):
         """
         Tries to read some bytes of the code currently being executed.
 
@@ -1510,7 +1492,7 @@ class Thread (object):
         """
         return self.get_process().read(self.get_pc() + offset, size)
 
-    def peek_code_bytes(self, size = 128, offset = 0):
+    def peek_code_bytes(self, size=128, offset=0):
         """
         Tries to read some bytes of the code currently being executed.
 
@@ -1526,7 +1508,7 @@ class Thread (object):
         """
         return self.get_process().peek(self.get_pc() + offset, size)
 
-    def peek_pointers_in_registers(self, peekSize = 16, context = None):
+    def peek_pointers_in_registers(self, peekSize=16, context=None):
         """
         Tries to guess which values in the registers are valid pointers,
         and reads some data from them.
@@ -1542,23 +1524,20 @@ class Thread (object):
         @rtype:  dict( str S{->} str )
         @return: Dictionary mapping register names to the data they point to.
         """
-        peekable_registers = (
-            'Eax', 'Ebx', 'Ecx', 'Edx', 'Esi', 'Edi', 'Ebp'
-        )
+        peekable_registers = ("Eax", "Ebx", "Ecx", "Edx", "Esi", "Edi", "Ebp")
         if not context:
-            context = self.get_context(win32.CONTEXT_CONTROL | \
-                                       win32.CONTEXT_INTEGER)
-        aProcess    = self.get_process()
-        data        = dict()
-        for (reg_name, reg_value) in compat.iteritems(context):
+            context = self.get_context(win32.CONTEXT_CONTROL | win32.CONTEXT_INTEGER)
+        aProcess = self.get_process()
+        data = dict()
+        for reg_name, reg_value in compat.iteritems(context):
             if reg_name not in peekable_registers:
                 continue
-##            if reg_name == 'Ebp':
-##                stack_begin, stack_end = self.get_stack_range()
-##                print hex(stack_end), hex(reg_value), hex(stack_begin)
-##                if stack_begin and stack_end and stack_end < stack_begin and \
-##                   stack_begin <= reg_value <= stack_end:
-##                      continue
+            ##            if reg_name == 'Ebp':
+            ##                stack_begin, stack_end = self.get_stack_range()
+            ##                print hex(stack_end), hex(reg_value), hex(stack_begin)
+            ##                if stack_begin and stack_end and stack_end < stack_begin and \
+            ##                   stack_begin <= reg_value <= stack_end:
+            ##                      continue
             reg_data = aProcess.peek(reg_value, peekSize)
             if reg_data:
                 data[reg_name] = reg_data
@@ -1566,7 +1545,7 @@ class Thread (object):
 
     # TODO
     # try to avoid reading the same page twice by caching it
-    def peek_pointers_in_data(self, data, peekSize = 16, peekStep = 1):
+    def peek_pointers_in_data(self, data, peekSize=16, peekStep=1):
         """
         Tries to guess which values in the given data are valid pointers,
         and reads some data from them.
@@ -1589,7 +1568,7 @@ class Thread (object):
         aProcess = self.get_process()
         return aProcess.peek_pointers_in_data(data, peekSize, peekStep)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # TODO
     # The disassemble_around and disassemble_around_pc methods
@@ -1637,7 +1616,7 @@ class Thread (object):
         aProcess = self.get_process()
         return aProcess.disassemble(lpAddress, dwSize)
 
-    def disassemble_around(self, lpAddress, dwSize = 64):
+    def disassemble_around(self, lpAddress, dwSize=64):
         """
         Disassemble around the given address.
 
@@ -1659,7 +1638,7 @@ class Thread (object):
         aProcess = self.get_process()
         return aProcess.disassemble_around(lpAddress, dwSize)
 
-    def disassemble_around_pc(self, dwSize = 64):
+    def disassemble_around_pc(self, dwSize=64):
         """
         Disassemble around the program counter of the given thread.
 
@@ -1708,11 +1687,13 @@ class Thread (object):
              - Disassembly line of instruction.
              - Hexadecimal dump of instruction.
         """
-        return self.disassemble_instruction( self.get_pc() )
+        return self.disassemble_instruction(self.get_pc())
+
+
+# ==============================================================================
 
-#==============================================================================
 
-class _ThreadContainer (object):
+class _ThreadContainer(object):
     """
     Encapsulates the capability to contain Thread objects.
 
@@ -1830,9 +1811,9 @@ class _ThreadContainer (object):
         self.__initialize_snapshot()
         return len(self.__threadDict)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def find_threads_by_name(self, name, bExactMatch = True):
+    def find_threads_by_name(self, name, bExactMatch=True):
         """
         Find threads by name, using different search methods.
 
@@ -1872,7 +1853,7 @@ class _ThreadContainer (object):
 
         return found_threads
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX TODO
     # Support for string searches on the window captions.
@@ -1884,12 +1865,12 @@ class _ThreadContainer (object):
         """
         window_list = list()
         for thread in self.iter_threads():
-            window_list.extend( thread.get_windows() )
+            window_list.extend(thread.get_windows())
         return window_list
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def start_thread(self, lpStartAddress, lpParameter=0,  bSuspended = False):
+    def start_thread(self, lpStartAddress, lpParameter=0, bSuspended=False):
         """
         Remotely creates a new thread in the process.
 
@@ -1907,18 +1888,19 @@ class _ThreadContainer (object):
             dwCreationFlags = win32.CREATE_SUSPENDED
         else:
             dwCreationFlags = 0
-        hProcess = self.get_handle( win32.PROCESS_CREATE_THREAD     |
-                                    win32.PROCESS_QUERY_INFORMATION |
-                                    win32.PROCESS_VM_OPERATION      |
-                                    win32.PROCESS_VM_WRITE          |
-                                    win32.PROCESS_VM_READ           )
-        hThread, dwThreadId = win32.CreateRemoteThread(
-                hProcess, 0, 0, lpStartAddress, lpParameter, dwCreationFlags)
+        hProcess = self.get_handle(
+            win32.PROCESS_CREATE_THREAD
+            | win32.PROCESS_QUERY_INFORMATION
+            | win32.PROCESS_VM_OPERATION
+            | win32.PROCESS_VM_WRITE
+            | win32.PROCESS_VM_READ
+        )
+        hThread, dwThreadId = win32.CreateRemoteThread(hProcess, 0, 0, lpStartAddress, lpParameter, dwCreationFlags)
         aThread = Thread(dwThreadId, hThread, self)
         self._add_thread(aThread)
         return aThread
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # TODO
     # maybe put all the toolhelp code into their own set of classes?
@@ -1942,11 +1924,10 @@ class _ThreadContainer (object):
         if dwProcessId in (0, 4, 8):
             return
 
-##        dead_tids   = set( self.get_thread_ids() ) # XXX triggers a scan
-        dead_tids   = self._get_thread_ids()
+        ##        dead_tids   = set( self.get_thread_ids() ) # XXX triggers a scan
+        dead_tids = self._get_thread_ids()
         dwProcessId = self.get_pid()
-        hSnapshot   = win32.CreateToolhelp32Snapshot(win32.TH32CS_SNAPTHREAD,
-                                                                 dwProcessId)
+        hSnapshot = win32.CreateToolhelp32Snapshot(win32.TH32CS_SNAPTHREAD, dwProcessId)
         try:
             te = win32.Thread32First(hSnapshot)
             while te is not None:
@@ -1954,9 +1935,9 @@ class _ThreadContainer (object):
                     dwThreadId = te.th32ThreadID
                     if dwThreadId in dead_tids:
                         dead_tids.remove(dwThreadId)
-##                    if not self.has_thread(dwThreadId): # XXX triggers a scan
+                    ##                    if not self.has_thread(dwThreadId): # XXX triggers a scan
                     if not self._has_thread_id(dwThreadId):
-                        aThread = Thread(dwThreadId, process = self)
+                        aThread = Thread(dwThreadId, process=self)
                         self._add_thread(aThread)
                 te = win32.Thread32Next(hSnapshot)
         finally:
@@ -1998,7 +1979,7 @@ class _ThreadContainer (object):
                 except Exception:
                     pass
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX _notify_* methods should not trigger a scan
 
@@ -2009,17 +1990,17 @@ class _ThreadContainer (object):
         @type  aThread: L{Thread}
         @param aThread: Thread object.
         """
-##        if not isinstance(aThread, Thread):
-##            if hasattr(aThread, '__class__'):
-##                typename = aThread.__class__.__name__
-##            else:
-##                typename = str(type(aThread))
-##            msg = "Expected Thread, got %s instead" % typename
-##            raise TypeError(msg)
+        ##        if not isinstance(aThread, Thread):
+        ##            if hasattr(aThread, '__class__'):
+        ##                typename = aThread.__class__.__name__
+        ##            else:
+        ##                typename = str(type(aThread))
+        ##            msg = "Expected Thread, got %s instead" % typename
+        ##            raise TypeError(msg)
         dwThreadId = aThread.dwThreadId
-##        if dwThreadId in self.__threadDict:
-##            msg = "Already have a Thread object with ID %d" % dwThreadId
-##            raise KeyError(msg)
+        ##        if dwThreadId in self.__threadDict:
+        ##            msg = "Already have a Thread object with ID %d" % dwThreadId
+        ##            raise KeyError(msg)
         aThread.set_process(self)
         self.__threadDict[dwThreadId] = aThread
 
@@ -2038,7 +2019,7 @@ class _ThreadContainer (object):
             msg = "Unknown thread ID %d" % dwThreadId
             warnings.warn(msg, RuntimeWarning)
         if aThread:
-            aThread.clear()     # remove circular references
+            aThread.clear()  # remove circular references
 
     def _has_thread_id(self, dwThreadId):
         """
@@ -2061,16 +2042,16 @@ class _ThreadContainer (object):
         @type  event: L{Event}
         @param event: Event object.
         """
-        dwThreadId  = event.get_tid()
-        hThread     = event.get_thread_handle()
-##        if not self.has_thread(dwThreadId):   # XXX this would trigger a scan
+        dwThreadId = event.get_tid()
+        hThread = event.get_thread_handle()
+        ##        if not self.has_thread(dwThreadId):   # XXX this would trigger a scan
         if not self._has_thread_id(dwThreadId):
             aThread = Thread(dwThreadId, hThread, self)
-            teb_ptr = event.get_teb()   # remember the TEB pointer
+            teb_ptr = event.get_teb()  # remember the TEB pointer
             if teb_ptr:
                 aThread._teb_ptr = teb_ptr
             self._add_thread(aThread)
-        #else:
+        # else:
         #    aThread = self.get_thread(dwThreadId)
         #    if hThread != win32.INVALID_HANDLE_VALUE:
         #        aThread.hThread = hThread   # may have more privileges
@@ -2121,7 +2102,7 @@ class _ThreadContainer (object):
         @return: C{True} to call the user-defined handle, C{False} otherwise.
         """
         dwThreadId = event.get_tid()
-##        if self.has_thread(dwThreadId):   # XXX this would trigger a scan
+        ##        if self.has_thread(dwThreadId):   # XXX this would trigger a scan
         if self._has_thread_id(dwThreadId):
             self._del_thread(dwThreadId)
         return True