NAME
    Devel::Backtrace - Object-oriented backtrace

VERSION
    This is version 0.07.

SYNOPSIS
        my $backtrace = Devel::Backtrace->new;

        print $backtrace; # use automatic stringification
                          # See EXAMPLES to see what the output might look like

        print $backtrace->point(0)->line;

METHODS
  Devel::Backtrace->new([$start])
    Constructs a new "Devel::Backtrace" which is filled with all the
    information "caller($i)" provides, where $i starts from $start. If no
    argument is given, $start defaults to 0.

    If $start is 1 (or higher), the backtrace won't contain the information
    that (and where) Devel::Backtrace::new() was called.

  $backtrace->point($i)
    Returns the i'th tracepoint as a Devel::Backtrace::Point object (see its
    documentation for how to access every bit of information).

    Note that the following code snippet will print the information of
    "caller($start+$i)":

        print Devel::Backtrace->new($start)->point($i)

  $backtrace->points()
    Returns a list of all tracepoints. In scalar context, the number of
    tracepoints is returned.

  $backtrace->skipme([$package])
    This method deletes all leading tracepoints that contain information
    about calls within $package. Afterwards the $backtrace will look as
    though it had been created with a higher value of $start.

    If the optional parameter $package is not given, it defaults to the
    calling package.

    The effect is similar to what the Carp module does.

    This module ships with an example "skipme.pl" that demonstrates how to
    use this method.

  $backtrace->skipmysubs([$package])
    This method is like "skipme" except that it deletes calls *to* the
    package rather than calls *from* the package. Usually this means that it
    deletes exactly one more tracepoint than "skipme".

    Before discarding those calls, "skipme" is called. This is because
    usually the topmost call in the stack is to Devel::Backtrace->new, which
    would not be catched by "skipmysubs" otherwise.

    See also the example "skipme.pl".

  $backtrace->to_string()
    Returns a string that contains one line for each tracepoint. It will
    contain the information from "Devel::Backtrace::Point"'s to_string()
    method. To get more information, use the to_long_string() method.

    Note that you don't have to call to_string() if you print a
    "Devel::Backtrace" object or otherwise treat it as a string, as the
    stringification operator is overloaded.

    See "EXAMPLES".

  $backtrace->to_long_string()
    Returns a very long string that contains several lines for each trace
    point. The result will contain every available bit of information. See
    "to_long_string" in Devel::Backtrace::Point for an example of what the
    result looks like.

EXAMPLES
    A sample stringification might look like this:

        Devel::Backtrace::new called from main (foo.pl:10)
        main::bar called from main (foo.pl:6)
        main::foo called from main (foo.pl:13)

SEE ALSO
    Devel::StackTrace does mostly the same as this module. I'm afraid I
    haven't noticed it until I uploaded this module.

    Carp::Trace is a simpler module which gives you a backtrace in string
    form.

    Devel::DollarAt comes with this distribution and is a nice application
    of this module. You can use it for debugging to get a backtrace out of
    $@.

AUTHOR
    Christoph Bussenius <pepe@cpan.org>

    If you use this module, I'll be glad if you drop me a note. You should
    mention this module's name in the subject of your mails, in order to
    make sure they won't get lost in all the spam.

COPYRIGHT
    This module is in the public domain.