devel::trace(3pm) [debian man page]

Trace(3pm)						User Contributed Perl Documentation						Trace(3pm)

NAME

       Devel::Trace - Print out each line before it is executed (like "sh -x")

SYNOPSIS

	 perl -d:Trace program

DESCRIPTION

       If you run your program with "perl -d:Trace program", this module will print a message to standard error just before each line is executed.
       For example, if your program looks like this:

	       #!/usr/bin/perl

	       print "Statement 1 at line 4
";
	       print "Statement 2 at line 5
";
	       print "Call to sub x returns ", &x(), " at line 6.
";

	       exit 0;

	       sub x {
		 print "In sub x at line 12.
";
		 return 13;
	       }

       Then  the "Trace" output will look like this:

	       >> ./test:4: print "Statement 1 at line 4
";
	       >> ./test:5: print "Statement 2 at line 5
";
	       >> ./test:6: print "Call to sub x returns ", &x(), " at line 6.
";
	       >> ./test:12:   print "In sub x at line 12.
";
	       >> ./test:13:   return 13;
	       >> ./test:8: exit 0;

       This is something like the shell's "-x" option.

DETAILS

       Inside your program, you can enable and disable tracing by doing

	   $Devel::Trace::TRACE = 1;   # Enable
	   $Devel::Trace::TRACE = 0;   # Disable

       or

	   Devel::Trace::trace('on');  # Enable
	   Devel::Trace::trace('off'); # Disable

       "Devel::Trace" exports the "trace" function if you ask it to:

	   import Devel::Trace 'trace';

       Then if you want you just say

	   trace 'on';		       # Enable
	   trace 'off'; 	       # Disable

TODO

       o   You should be able to  send the trace output to the filehandle of your choice.

       o   You should be able to specify the format of the output.

       o   You should be able to get the output into a string.

       We'll see.

LICENSE

       Devel::Trace 0.11 and its source code are hereby placed in the public domain.

Author
       Mark-Jason Dominus (C<mjd-perl-trace@plover.com>), Plover Systems co.  See the C<Devel::Trace.pm> Page at
       http://www.plover.com/~mjd/perl/Trace for news and upgrades.

perl v5.14.2							    2012-02-16								Trace(3pm)

Devel::Backtrace(3pm)					User Contributed Perl Documentation				     Devel::Backtrace(3pm)

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.10.0							    2009-01-27						     Devel::Backtrace(3pm)