Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Devel::Backtrace(3)   User Contributed Perl Documentation  Devel::Backtrace(3)

NAME
       Devel::Backtrace	- Object-oriented backtrace

VERSION
       This is version 0.12.

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()
       Optional	parameters: -start => $start, -format => $format

       If only one parameter is	given, it will be used as $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.	 See also "EXAMPLES".

   $backtrace->skipmysubs([$package])
       This method is like "skipme" except that	it deletes calls to the
       package rather than calls from the package.

       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.

       This means that skipmysubs usually deletes more lines than skipme
       would.

       "skipmysubs" was	added in Devel::Backtrace version 0.06.

       See also	"EXAMPLES" and 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 MyPackage (foo.pl:30)
	   MyPackage::test2 called from	MyPackage (foo.pl:28)
	   MyPackage::test1 called from	main (foo.pl:18)
	   main::bar called from main (foo.pl:6)
	   main::foo called from main (foo.pl:13)

       If MyPackage called skipme, the first two lines would be	removed.  If
       it called skipmysubs, the first three lines would be removed.

       If you don't like the format, you can change it:

	   my $backtrace = Devel::Backtrace->new(-format => '%I. %s');

       This would produce a stringification of the following form:

	   0. Devel::Backtrace::new
	   1. MyPackage::test2
	   2. MyPackage::test1
	   3. main::bar
	   4. main::foo

SEE ALSO
       Devel::StackTrace does mostly the same as this module.  I'm afraid I
       hadn'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.

LICENSE
       This module is in the public domain.

       If your country's law does not allow this module	being in the public
       domain or does not include the concept of public	domain,	you may	use
       the module under	the same terms as perl itself.

perl v5.32.0			  2009-01-27		   Devel::Backtrace(3)

NAME | VERSION | SYNOPSIS | METHODS | EXAMPLES | SEE ALSO | AUTHOR | LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Devel::Backtrace&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help