From b15a8df51919ae428023df79fd078263d4d23c88 Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Sun, 2 Dec 2007 14:37:29 +0000 Subject: Convert bdb.rst line endings to Unix style. --- Doc/library/bdb.rst | 674 ++++++++++++++++++++++++++-------------------------- 1 file changed, 337 insertions(+), 337 deletions(-) diff --git a/Doc/library/bdb.rst b/Doc/library/bdb.rst index 0e42be6..c44f9e3 100644 --- a/Doc/library/bdb.rst +++ b/Doc/library/bdb.rst @@ -1,337 +1,337 @@ -:mod:`bdb` --- Debugger framework -================================= - -.. module:: bdb - :synopsis: Debugger framework. - -The :mod:`bdb` module handles basic debugger functions, like setting breakpoints -or managing execution via the debugger. - -The following exception is defined: - -.. exception:: BdbQuit - - Exception raised by the :class:`Bdb` class for quitting the debugger. - - -The :mod:`bdb` module also defines two classes: - -.. class:: Breakpoint(self, file, line[, temporary=0[, cond=None [, funcname=None]]]) - - This class implements temporary breakpoints, ignore counts, disabling and - (re-)enabling, and conditionals. - - Breakpoints are indexed by number through a list called :attr:`bpbynumber` - and by ``(file, line)`` pairs through :attr:`bplist`. The former points to a - single instance of class :class:`Breakpoint`. The latter points to a list of - such instances since there may be more than one breakpoint per line. - - When creating a breakpoint, its associated filename should be in canonical - form. If a *funcname* is defined, a breakpoint hit will be counted when the - first line of that function is executed. A conditional breakpoint always - counts a hit. - -:class:`Breakpoint` instances have the following methods: - -.. method:: Breakpoint.deleteMe() - - Delete the breakpoint from the list associated to a file/line. If it is the - last breakpoint in that position, it also deletes the entry for the - file/line. - -.. method:: Breakpoint.enable() - - Mark the breakpoint as enabled. - -.. method:: Breakpoint.disable() - - Mark the breakpoint as disabled. - -.. method:: Breakpoint.bpprint([out]) - - Print all the information about the breakpoint: - - * The breakpoint number. - * If it is temporary or not. - * Its file,line position. - * The condition that causes a break. - * If it must be ignored the next N times. - * The breakpoint hit count. - - -.. class:: Bdb() - - The :class:`Bdb` acts as a generic Python debugger base class. - - This class takes care of the details of the trace facility; a derived class - should implement user interaction. The standard debugger class - (:class:`pdb.Pdb`) is an example. - - -The following methods of :class:`Bdb` normally don't need to be overridden. - -.. method:: Bdb.canonic(filename) - - Auxiliary method for getting a filename in a canonical form, that is, as a - case-normalized (on case-insensitive filesystems) absolute path, stripped - of surrounding angle brackets. - -.. method:: Bdb.reset() - - Set the :attr:`botframe`, :attr:`stopframe`, :attr:`returnframe` and - :attr:`quitting` attributes with values ready to start debugging. - - -.. method:: Bdb.trace_dispatch(frame, event, arg) - - This function is installed as the trace function of debugged frames. Its - return value is the new trace function (in most cases, that is, itself). - - The default implementation decides how to dispatch a frame, depending on the - type of event (passed as a string) that is about to be executed. *event* can - be one of the following: - - * ``"line"``: A new line of code is going to be executed. - * ``"call"``: A function is about to be called, or another code block - entered. - * ``"return"``: A function or other code block is about to return. - * ``"exception"``: An exception has occurred. - * ``"c_call"``: A C function is about to be called. - * ``"c_return"``: A C function has returned. - * ``"c_exception"``: A C function has thrown an exception. - - For the Python events, specialized functions (see below) are called. For the - C events, no action is taken. - - The *arg* parameter depends on the previous event. - - For more information on trace functions, see :ref:`debugger-hooks`. For more - information on code and frame objects, refer to :ref:`types`. - -.. method:: Bdb.dispatch_line(frame) - - If the debugger should stop on the current line, invoke the :meth:`user_line` - method (which should be overridden in subclasses). Raise a :exc:`BdbQuit` - exception if the :attr:`Bdb.quitting` flag is set (which can be set from - :meth:`user_line`). Return a reference to the :meth:`trace_dispatch` method - for further tracing in that scope. - -.. method:: Bdb.dispatch_call(frame, arg) - - If the debugger should stop on this function call, invoke the - :meth:`user_call` method (which should be overridden in subclasses). Raise a - :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set (which can - be set from :meth:`user_call`). Return a reference to the - :meth:`trace_dispatch` method for further tracing in that scope. - -.. method:: Bdb.dispatch_return(frame, arg) - - If the debugger should stop on this function return, invoke the - :meth:`user_return` method (which should be overridden in subclasses). Raise - a :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set (which can - be set from :meth:`user_return`). Return a reference to the - :meth:`trace_dispatch` method for further tracing in that scope. - -.. method:: Bdb.dispatch_exception(frame, arg) - - If the debugger should stop at this exception, invokes the - :meth:`user_exception` method (which should be overridden in subclasses). - Raise a :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set - (which can be set from :meth:`user_exception`). Return a reference to the - :meth:`trace_dispatch` method for further tracing in that scope. - -Normally derived classes don't override the following methods, but they may if -they want to redefine the definition of stopping and breakpoints. - -.. method:: Bdb.stop_here(frame) - - This method checks if the *frame* is somewhere below :attr:`botframe` in the - call stack. :attr:`botframe` is the frame in which debugging started. - -.. method:: Bdb.break_here(frame) - - This method checks if there is a breakpoint in the filename and line - belonging to *frame* or, at least, in the current function. If the - breakpoint is a temporary one, this method deletes it. - -.. method:: Bdb.break_anywhere(frame) - - This method checks if there is a breakpoint in the filename of the current - frame. - -Derived classes should override these methods to gain control over debugger -operation. - -.. method:: Bdb.user_call(frame, argument_list) - - This method is called from :meth:`dispatch_call` when there is the - possibility that a break might be necessary anywhere inside the called - function. - -.. method:: Bdb.user_line(frame) - - This method is called from :meth:`dispatch_line` when either - :meth:`stop_here` or :meth:`break_here` yields True. - -.. method:: Bdb.user_return(frame, return_value) - - This method is called from :meth:`dispatch_return` when :meth:`stop_here` - yields True. - -.. method:: Bdb.user_exception(frame, exc_info) - - This method is called from :meth:`dispatch_exception` when :meth:`stop_here` - yields True. - -.. method:: Bdb.do_clear(arg) - - Handle how a breakpoint must be removed when it is a temporary one. - - This method must be implemented by derived classes. - - -Derived classes and clients can call the following methods to affect the -stepping state. - -.. method:: Bdb.set_step() - - Stop after one line of code. - -.. method:: Bdb.set_next(frame) - - Stop on the next line in or below the given frame. - -.. method:: Bdb.set_return(frame) - - Stop when returning from the given frame. - -.. method:: Bdb.set_trace([frame]) - - Start debugging from *frame*. If *frame* is not specified, debugging starts - from caller's frame. - -.. method:: Bdb.set_continue() - - Stop only at breakpoints or when finished. If there are no breakpoints, set - the system trace function to None. - -.. method:: Bdb.set_quit() - - Set the :attr:`quitting` attribute to True. This raises :exc:`BdbQuit` in - the next call to one of the :meth:`dispatch_\*` methods. - - -Derived classes and clients can call the following methods to manipulate -breakpoints. These methods return a string containing an error message if -something went wrong, or ``None`` if all is well. - -.. method:: Bdb.set_break(filename, lineno[, temporary=0[, cond[, funcname]]]) - - Set a new breakpoint. If the *lineno* line doesn't exist for the *filename* - passed as argument, return an error message. The *filename* should be in - canonical form, as described in the :meth:`canonic` method. - -.. method:: Bdb.clear_break(filename, lineno) - - Delete the breakpoints in *filename* and *lineno*. If none were set, an - error message is returned. - -.. method:: Bdb.clear_bpbynumber(arg) - - Delete the breakpoint which has the index *arg* in the - :attr:`Breakpoint.bpbynumber`. If `arg` is not numeric or out of range, - return an error message. - -.. method:: Bdb.clear_all_file_breaks(filename) - - Delete all breakpoints in *filename*. If none were set, an error message is - returned. - -.. method:: Bdb.clear_all_breaks() - - Delete all existing breakpoints. - -.. method:: Bdb.get_break(filename, lineno) - - Check if there is a breakpoint for *lineno* of *filename*. - -.. method:: Bdb.get_breaks(filename, lineno) - - Return all breakpoints for *lineno* in *filename*, or an empty list if none - are set. - -.. method:: Bdb.get_file_breaks(filename) - - Return all breakpoints in *filename*, or an empty list if none are set. - -.. method:: Bdb.get_all_breaks() - - Return all breakpoints that are set. - - -Derived classes and clients can call the following methods to get a data -structure representing a stack trace. - -.. method:: Bdb.get_stack(f, t) - - Get a list of records for a frame and all higher (calling) and lower frames, - and the size of the higher part. - -.. method:: Bdb.format_stack_entry(frame_lineno, [lprefix=': ']) - - Return a string with information about a stack entry, identified by a - ``(frame, lineno)`` tuple: - - * The canonical form of the filename which contains the frame. - * The function name, or ``""``. - * The input arguments. - * The return value. - * The line of code (if it exists). - - -The following two methods can be called by clients to use a debugger to debug a -statement, given as a string. - -.. method:: Bdb.run(cmd, [globals, [locals]]) - - Debug a statement executed via the :keyword:`exec` statement. *globals* - defaults to :attr:`__main__.__dict__`, *locals* defaults to *globals*. - -.. method:: Bdb.runeval(expr, [globals, [locals]]) - - Debug an expression executed via the :func:`eval` function. *globals* and - *locals* have the same meaning as in :meth:`run`. - -.. method:: Bdb.runctx(cmd, globals, locals) - - For backwards compatibility. Calls the :meth:`run` method. - -.. method:: Bdb.runcall(func, *args, **kwds) - - Debug a single function call, and return its result. - - -Finally, the module defines the following functions: - -.. function:: checkfuncname(b, frame) - - Check whether we should break here, depending on the way the breakpoint *b* - was set. - - If it was set via line number, it checks if ``b.line`` is the same as the one - in the frame also passed as argument. If the breakpoint was set via function - name, we have to check we are in the right frame (the right function) and if - we are in its first executable line. - -.. function:: effective(file, line, frame) - - Determine if there is an effective (active) breakpoint at this line of code. - Return breakpoint number or 0 if none. - - Called only if we know there is a breakpoint at this location. Returns the - breakpoint that was triggered and a flag that indicates if it is ok to delete - a temporary breakpoint. - -.. function:: set_trace() - - Starts debugging with a :class:`Bdb` instance from caller's frame. +:mod:`bdb` --- Debugger framework +================================= + +.. module:: bdb + :synopsis: Debugger framework. + +The :mod:`bdb` module handles basic debugger functions, like setting breakpoints +or managing execution via the debugger. + +The following exception is defined: + +.. exception:: BdbQuit + + Exception raised by the :class:`Bdb` class for quitting the debugger. + + +The :mod:`bdb` module also defines two classes: + +.. class:: Breakpoint(self, file, line[, temporary=0[, cond=None [, funcname=None]]]) + + This class implements temporary breakpoints, ignore counts, disabling and + (re-)enabling, and conditionals. + + Breakpoints are indexed by number through a list called :attr:`bpbynumber` + and by ``(file, line)`` pairs through :attr:`bplist`. The former points to a + single instance of class :class:`Breakpoint`. The latter points to a list of + such instances since there may be more than one breakpoint per line. + + When creating a breakpoint, its associated filename should be in canonical + form. If a *funcname* is defined, a breakpoint hit will be counted when the + first line of that function is executed. A conditional breakpoint always + counts a hit. + +:class:`Breakpoint` instances have the following methods: + +.. method:: Breakpoint.deleteMe() + + Delete the breakpoint from the list associated to a file/line. If it is the + last breakpoint in that position, it also deletes the entry for the + file/line. + +.. method:: Breakpoint.enable() + + Mark the breakpoint as enabled. + +.. method:: Breakpoint.disable() + + Mark the breakpoint as disabled. + +.. method:: Breakpoint.bpprint([out]) + + Print all the information about the breakpoint: + + * The breakpoint number. + * If it is temporary or not. + * Its file,line position. + * The condition that causes a break. + * If it must be ignored the next N times. + * The breakpoint hit count. + + +.. class:: Bdb() + + The :class:`Bdb` acts as a generic Python debugger base class. + + This class takes care of the details of the trace facility; a derived class + should implement user interaction. The standard debugger class + (:class:`pdb.Pdb`) is an example. + + +The following methods of :class:`Bdb` normally don't need to be overridden. + +.. method:: Bdb.canonic(filename) + + Auxiliary method for getting a filename in a canonical form, that is, as a + case-normalized (on case-insensitive filesystems) absolute path, stripped + of surrounding angle brackets. + +.. method:: Bdb.reset() + + Set the :attr:`botframe`, :attr:`stopframe`, :attr:`returnframe` and + :attr:`quitting` attributes with values ready to start debugging. + + +.. method:: Bdb.trace_dispatch(frame, event, arg) + + This function is installed as the trace function of debugged frames. Its + return value is the new trace function (in most cases, that is, itself). + + The default implementation decides how to dispatch a frame, depending on the + type of event (passed as a string) that is about to be executed. *event* can + be one of the following: + + * ``"line"``: A new line of code is going to be executed. + * ``"call"``: A function is about to be called, or another code block + entered. + * ``"return"``: A function or other code block is about to return. + * ``"exception"``: An exception has occurred. + * ``"c_call"``: A C function is about to be called. + * ``"c_return"``: A C function has returned. + * ``"c_exception"``: A C function has thrown an exception. + + For the Python events, specialized functions (see below) are called. For the + C events, no action is taken. + + The *arg* parameter depends on the previous event. + + For more information on trace functions, see :ref:`debugger-hooks`. For more + information on code and frame objects, refer to :ref:`types`. + +.. method:: Bdb.dispatch_line(frame) + + If the debugger should stop on the current line, invoke the :meth:`user_line` + method (which should be overridden in subclasses). Raise a :exc:`BdbQuit` + exception if the :attr:`Bdb.quitting` flag is set (which can be set from + :meth:`user_line`). Return a reference to the :meth:`trace_dispatch` method + for further tracing in that scope. + +.. method:: Bdb.dispatch_call(frame, arg) + + If the debugger should stop on this function call, invoke the + :meth:`user_call` method (which should be overridden in subclasses). Raise a + :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set (which can + be set from :meth:`user_call`). Return a reference to the + :meth:`trace_dispatch` method for further tracing in that scope. + +.. method:: Bdb.dispatch_return(frame, arg) + + If the debugger should stop on this function return, invoke the + :meth:`user_return` method (which should be overridden in subclasses). Raise + a :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set (which can + be set from :meth:`user_return`). Return a reference to the + :meth:`trace_dispatch` method for further tracing in that scope. + +.. method:: Bdb.dispatch_exception(frame, arg) + + If the debugger should stop at this exception, invokes the + :meth:`user_exception` method (which should be overridden in subclasses). + Raise a :exc:`BdbQuit` exception if the :attr:`Bdb.quitting` flag is set + (which can be set from :meth:`user_exception`). Return a reference to the + :meth:`trace_dispatch` method for further tracing in that scope. + +Normally derived classes don't override the following methods, but they may if +they want to redefine the definition of stopping and breakpoints. + +.. method:: Bdb.stop_here(frame) + + This method checks if the *frame* is somewhere below :attr:`botframe` in the + call stack. :attr:`botframe` is the frame in which debugging started. + +.. method:: Bdb.break_here(frame) + + This method checks if there is a breakpoint in the filename and line + belonging to *frame* or, at least, in the current function. If the + breakpoint is a temporary one, this method deletes it. + +.. method:: Bdb.break_anywhere(frame) + + This method checks if there is a breakpoint in the filename of the current + frame. + +Derived classes should override these methods to gain control over debugger +operation. + +.. method:: Bdb.user_call(frame, argument_list) + + This method is called from :meth:`dispatch_call` when there is the + possibility that a break might be necessary anywhere inside the called + function. + +.. method:: Bdb.user_line(frame) + + This method is called from :meth:`dispatch_line` when either + :meth:`stop_here` or :meth:`break_here` yields True. + +.. method:: Bdb.user_return(frame, return_value) + + This method is called from :meth:`dispatch_return` when :meth:`stop_here` + yields True. + +.. method:: Bdb.user_exception(frame, exc_info) + + This method is called from :meth:`dispatch_exception` when :meth:`stop_here` + yields True. + +.. method:: Bdb.do_clear(arg) + + Handle how a breakpoint must be removed when it is a temporary one. + + This method must be implemented by derived classes. + + +Derived classes and clients can call the following methods to affect the +stepping state. + +.. method:: Bdb.set_step() + + Stop after one line of code. + +.. method:: Bdb.set_next(frame) + + Stop on the next line in or below the given frame. + +.. method:: Bdb.set_return(frame) + + Stop when returning from the given frame. + +.. method:: Bdb.set_trace([frame]) + + Start debugging from *frame*. If *frame* is not specified, debugging starts + from caller's frame. + +.. method:: Bdb.set_continue() + + Stop only at breakpoints or when finished. If there are no breakpoints, set + the system trace function to None. + +.. method:: Bdb.set_quit() + + Set the :attr:`quitting` attribute to True. This raises :exc:`BdbQuit` in + the next call to one of the :meth:`dispatch_\*` methods. + + +Derived classes and clients can call the following methods to manipulate +breakpoints. These methods return a string containing an error message if +something went wrong, or ``None`` if all is well. + +.. method:: Bdb.set_break(filename, lineno[, temporary=0[, cond[, funcname]]]) + + Set a new breakpoint. If the *lineno* line doesn't exist for the *filename* + passed as argument, return an error message. The *filename* should be in + canonical form, as described in the :meth:`canonic` method. + +.. method:: Bdb.clear_break(filename, lineno) + + Delete the breakpoints in *filename* and *lineno*. If none were set, an + error message is returned. + +.. method:: Bdb.clear_bpbynumber(arg) + + Delete the breakpoint which has the index *arg* in the + :attr:`Breakpoint.bpbynumber`. If `arg` is not numeric or out of range, + return an error message. + +.. method:: Bdb.clear_all_file_breaks(filename) + + Delete all breakpoints in *filename*. If none were set, an error message is + returned. + +.. method:: Bdb.clear_all_breaks() + + Delete all existing breakpoints. + +.. method:: Bdb.get_break(filename, lineno) + + Check if there is a breakpoint for *lineno* of *filename*. + +.. method:: Bdb.get_breaks(filename, lineno) + + Return all breakpoints for *lineno* in *filename*, or an empty list if none + are set. + +.. method:: Bdb.get_file_breaks(filename) + + Return all breakpoints in *filename*, or an empty list if none are set. + +.. method:: Bdb.get_all_breaks() + + Return all breakpoints that are set. + + +Derived classes and clients can call the following methods to get a data +structure representing a stack trace. + +.. method:: Bdb.get_stack(f, t) + + Get a list of records for a frame and all higher (calling) and lower frames, + and the size of the higher part. + +.. method:: Bdb.format_stack_entry(frame_lineno, [lprefix=': ']) + + Return a string with information about a stack entry, identified by a + ``(frame, lineno)`` tuple: + + * The canonical form of the filename which contains the frame. + * The function name, or ``""``. + * The input arguments. + * The return value. + * The line of code (if it exists). + + +The following two methods can be called by clients to use a debugger to debug a +statement, given as a string. + +.. method:: Bdb.run(cmd, [globals, [locals]]) + + Debug a statement executed via the :keyword:`exec` statement. *globals* + defaults to :attr:`__main__.__dict__`, *locals* defaults to *globals*. + +.. method:: Bdb.runeval(expr, [globals, [locals]]) + + Debug an expression executed via the :func:`eval` function. *globals* and + *locals* have the same meaning as in :meth:`run`. + +.. method:: Bdb.runctx(cmd, globals, locals) + + For backwards compatibility. Calls the :meth:`run` method. + +.. method:: Bdb.runcall(func, *args, **kwds) + + Debug a single function call, and return its result. + + +Finally, the module defines the following functions: + +.. function:: checkfuncname(b, frame) + + Check whether we should break here, depending on the way the breakpoint *b* + was set. + + If it was set via line number, it checks if ``b.line`` is the same as the one + in the frame also passed as argument. If the breakpoint was set via function + name, we have to check we are in the right frame (the right function) and if + we are in its first executable line. + +.. function:: effective(file, line, frame) + + Determine if there is an effective (active) breakpoint at this line of code. + Return breakpoint number or 0 if none. + + Called only if we know there is a breakpoint at this location. Returns the + breakpoint that was triggered and a flag that indicates if it is ok to delete + a temporary breakpoint. + +.. function:: set_trace() + + Starts debugging with a :class:`Bdb` instance from caller's frame. -- cgit v0.12