@rtype: str @return: User-friendly name of the event.

@rtype: str @return: User-friendly name of the exception.

@rtype: str @return: Name of the exception as defined by the Win32 API.

@rtype: int @return: Access violation memory address. @note: This method is only meaningful for access violation exceptions

@rtype: L{FileHandle} or None @return: File handle to the newly loaded DLL received from the system. Returns C{None} if

Translates segment-relative addresses to linear addresses. Linear addresses can be used to access a process memory, calling

Retrieves the filenames for memory mapped files in the debugee. @type memoryMap: list( L{win32.MemoryBasicInformation} ) @p

Provides the parent pid (even for older versions of Python on Windows).

@see: L{iter_process_ids} @rtype: list( int ) @return: List of global process IDs in this snapshot.

@rtype: tuple( int, int ) @return: Stack beginning and end pointers, in memory addresses order. That is, the first point

:raises KeyError

Generates a KeyboardInterrupt in the main thread by sending a Ctrl+C or by calling thread.interrupt_main(). :param main_thread:

@rtype: bool @return: C{True} if the breakpoint has an action callback defined.

@rtype: bool @return: C{True} if the breakpoint doesn't have an action callback defined.

@rtype: bool @return: C{True} if all pages in this region are readable.

Determines if the thread is running under WOW64. @rtype: bool @return: C{True} if the thread is running under W

@rtype: bool @return: C{True} if all pages in this region are writeable.

Returns an iterator for the debugging symbols in all modules in this snapshot, in no particular order. The symbols are automa

@see: L{iter_threads} @rtype: dictionary-keyiterator @return: Iterator of global thread IDs in this snapshot.

Loads the debugging symbols for a module. Automatically called by L{get_symbols}.

:return tuple(str,str): Returns tuple(thread_suspended_str, thread_stack_str). i.e.: ( '

Marshalls a Crash key to be used in the database. @see: L{__init__} @type key: L{Crash} key. @param key: Key to co

if thread is not alive, cancel trace_dispatch processing

Tries to read the contents of the top of the stack. @type size: int @param size: Number of bytes to read. @type o

:param std: 'stdout' or 'stderr'

set_next_cmd_id may actually be one of: CMD_RUN_TO_LINE CMD_SET_NEXT_STATEMENT CMD_SMART_STEP_INTO -- note: request

Reset the input buffer.

Resolves a label for the given process. @type pid: int @param pid: Process global ID. @type label: str @p

Resolves a label for this module only. If the label refers to another module, an exception is raised. @type label: str

Executes the breakpoint action callback, if any was set. @type event: L{Event} @param event: Debug event triggered by the b

runs all tests

Populates the snapshot with loaded modules. Tipically you don't need to call this method directly, if unsure use L{scan} ins

Search for the given byte pattern within the process memory. @type bytes: str @param bytes: Bytes to search for. @

Sets a new action callback for the breakpoint. @type action: function @param action: (Optional) Action callback function.

When disabled, no thread notifications (for creation/removal) will be issued until it's re-enabled. Note that when it's re-e

Set the event handler. @warn: This is normally not needed. Use with care! @type eventHandler: L{EventHandler} @par

Manually set the parent process. Use with care! @type process: L{Process} @param process: (Optional) Process object. Use C{

Sets the tracing function with the pydev debug function and initializes needed facilities. :param host: the user may specify another host, if the

@type pathname: str @param pathname: Absolute path. @rtype: tuple( str, str ) @return: Tuple containin

Splits a label entered as user input. It's more flexible in it's syntax parsing than the L{split_label_strict} method, as it

Splits a label created with L{parse_label}. To parse labels with a less strict syntax, use the L{split_label_fuzzy} method i

connects to a host/port

Remotely creates a new thread in the process. @type lpStartAddress: int @param lpStartAddress: Start address for the new th

:param std: 'stdout' or 'stderr'

Suspends execution on all threads of the process. @raise WindowsError: On error an exception is raised.

Should we debug only what's inside project folders?

Waits for the process to finish executing. @raise WindowsError: On error an exception is raised.