*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> perldebug (1)              
Title
Content
Arch
Section
 

Contents


PERLDEBUG(1)							  PERLDEBUG(1)


NAME    [Toc]    [Back]

     perldebug - Perl debugging

DESCRIPTION    [Toc]    [Back]

     First of all, have	you tried using	the -w switch?

The Perl Debugger    [Toc]    [Back]

     "As soon as we started programming, we found to our surprise that it
     wasn't as easy to get programs right as we	had thought.  Debugging	had to
     be	discovered.  I can remember the	exact instant when I realized that a
     large part	of my life from	then on	was going to be	spent in finding
     mistakes in my own	programs."

       --Maurice Wilkes, 1949

     If	you invoke Perl	with the -d switch, your script	runs under the Perl
     source debugger.  This works like an interactive Perl environment,
     prompting for debugger commands that let you examine source code, set
     breakpoints, get stack backtraces,	change the values of variables,	etc.
     This is so	convenient that	you often fire up the debugger all by itself
     just to test out Perl constructs interactively to see what	they do.  For
     example:

	 perl -d -e 42

     In	Perl, the debugger is not a separate program as	it usually is in the
     typical compiled environment.  Instead, the -d flag tells the compiler to
     insert source information into the	parse trees it's about to hand off to
     the interpreter.  That means your code must first compile correctly for
     the debugger to work on it.  Then when the	interpreter starts up, it
     preloads a	Perl library file containing the debugger itself.

     The program will halt right before	the first run-time executable
     statement (but see	below regarding	compile-time statements) and ask you
     to	enter a	debugger command.  Contrary to popular expectations, whenever
     the debugger halts	and shows you a	line of	code, it always	displays the
     line it's about to	execute, rather	than the one it	has just executed.

     Any command not recognized	by the debugger	is directly executed (eval'd)
     as	Perl code in the current package.  (The	debugger uses the DB package
     for its own state information.)

     Leading white space before	a command would	cause the debugger to think
     it's NOT a	debugger command but for Perl, so be careful not to do that.

     Debugger Commands    [Toc]    [Back]

     The debugger understands the following commands:

     h [command] Prints	out a help message.

		 If you	supply another debugger	command	as an argument to the



									Page 1






PERLDEBUG(1)							  PERLDEBUG(1)



		 h command, it prints out the description for just that
		 command.  The special argument	of h h produces	a more compact
		 help listing, designed	to fit together	on one screen.

		 If the	output the h command (or any command, for that matter)
		 scrolls past your screen, either precede the command with a
		 leading pipe symbol so	it's run through your pager, as	in

		     DB> |h

		 You may change	the pager which	is used	via O pager=...
		 command.

     p expr	 Same as print {$DB::OUT} expr in the current package.	In
		 particular, because this is just Perl's own print function,
		 this means that nested	data structures	and objects are	not
		 dumped, unlike	with the x command.

		 The DB::OUT filehandle	is opened to /dev/tty, regardless of
		 where STDOUT may be redirected	to.

     x expr	 Evaluates its expression in list context and dumps out	the
		 result	in a pretty-printed fashion.  Nested data structures
		 are printed out recursively, unlike the print function.

		 The details of	printout are governed by multiple Options.

     V [pkg [vars]]
		 Display all (or some) variables in package (defaulting	to the
		 main package) using a data pretty-printer (hashes show	their
		 keys and values so you	see what's what, control characters
		 are made printable, etc.).  Make sure you don't put the type
		 specifier (like $) there, just	the symbol names, like this:

		     V DB filename line

		 Use ~pattern and !pattern for positive	and negative regexps.

		 Nested	data structures	are printed out	in a legible fashion,
		 unlike	the print function.

		 The details of	printout are governed by multiple Options.

     X [vars]	 Same as V currentpackage [vars].

     T		 Produce a stack backtrace.  See below for details on its
		 output.

     s [expr]	 Single	step.  Executes	until it reaches the beginning of
		 another statement, descending into subroutine calls.  If an
		 expression is supplied	that includes function calls, it too
		 will be single-stepped.



									Page 2






PERLDEBUG(1)							  PERLDEBUG(1)



     n [expr]	 Next.	Executes over subroutine calls,	until it reaches the
		 beginning of the next statement.  If an expression is
		 supplied that includes	function calls,	those functions	will
		 be executed with stops	before each statement.

     <CR>	 Repeat	last n or s command.

     c [line|sub]
		 Continue, optionally inserting	a one-time-only	breakpoint at
		 the specified line or subroutine.

     l		 List next window of lines.

     l min+incr	 List incr+1 lines starting at min.

     l min-max	 List lines min	through	max.  l	- is synonymous	to -.

     l line	 List a	single line.

     l subname	 List first window of lines from subroutine.

     -		 List previous window of lines.

     w [line]	 List window (a	few lines) around the current line.

     .		 Return	debugger pointer to the	last-executed line and print
		 it out.

     f filename	 Switch	to viewing a different file or eval statement.	If
		 filename is not a full	filename as found in values of %INC,
		 it is considered as a regexp.

     /pattern/	 Search	forwards for pattern; final / is optional.

     ?pattern?	 Search	backwards for pattern; final ? is optional.

     L		 List all breakpoints and actions.

     S [[!]pattern]
		 List subroutine names [not] matching pattern.

     t		 Toggle	trace mode (see	also AutoTrace Option).

     t expr	 Trace through execution of expr.  For example:

		  $ perl -de 42
		  Stack	dump during die	enabled	outside	of evals.

		  Loading DB routines from perl5db.pl patch level 0.94
		  Emacs	support	available.

		  Enter	h or `h	h' for help.



									Page 3






PERLDEBUG(1)							  PERLDEBUG(1)



		  main::(-e:1):	  0
		    DB<1> sub foo { 14 }

		    DB<2> sub bar { 3 }

		    DB<3> t print foo()	* bar()
		  main::((eval 172):3):	  print	foo() +	bar();
		  main::foo((eval 168):2):
		  main::bar((eval 170):2):
		  42

		 or, with the Option frame=2 set,

		    DB<4> O f=2
				 frame = '2'
		    DB<5> t print foo()	* bar()
		  3:	  foo()	* bar()
		  entering main::foo
		   2:	  sub foo { 14 };
		  exited main::foo
		  entering main::bar
		   2:	  sub bar { 3 };
		  exited main::bar
		  42


     b [line] [condition]
		 Set a breakpoint.  If line is omitted,	sets a breakpoint on
		 the line that is about	to be executed.	 If a condition	is
		 specified, it's evaluated each	time the statement is reached
		 and a breakpoint is taken only	if the condition is true.
		 Breakpoints may be set	on only	lines that begin an executable
		 statement.  Conditions	don't use if:

		     b 237 $x >	30
		     b 237 ++$count237 < 11
		     b 33 /pattern/i


     b subname [condition]
		 Set a breakpoint at the first line of the named subroutine.

     b postpone	subname	[condition]
		 Set breakpoint	at first line of subroutine after it is
		 compiled.

     b load filename
		 Set breakpoint	at the first executed line of the file.
		 Filename should be a full name	as found in values of %INC.






									Page 4






PERLDEBUG(1)							  PERLDEBUG(1)



     b compile subname
		 Sets breakpoint at the	first statement	executed after the
		 subroutine is compiled.

     d [line]	 Delete	a breakpoint at	the specified line.  If	line is
		 omitted, deletes the breakpoint on the	line that is about to
		 be executed.

     D		 Delete	all installed breakpoints.

     a [line] command
		 Set an	action to be done before the line is executed.	The
		 sequence of steps taken by the	debugger is

		   1. check for	a breakpoint at	this line
		   2. print the	line if	necessary (tracing)
		   3. do any actions associated	with that line
		   4. prompt user if at	a breakpoint or	in single-step
		   5. evaluate line

		 For example, this will	print out $foo every time line 53 is
		 passed:

		     a 53 print	"DB FOUND $foo\n"


     A		 Delete	all installed actions.

     O [opt[=val]] [op'val' [opt?]...
		 Set or	query values of	options.  val defaults to 1.  opt can
		 be abbreviated.  Several options can be listed.

     recallCommand, ShellBang
			     The characters used to recall command or spawn
			     shell.  By	default, these are both	set to !.

     pager		     Program to	use for	output of pager-piped commands
			     (those beginning with a | character.)  By
			     default, $ENV{PAGER} will be used.

     tkRunning		     Run Tk while prompting (with ReadLine).

     signalLevel, warnLevel, dieLevel
			     Level of verbosity.  By default the debugger is
			     in	a sane verbose mode, thus it will print
			     backtraces	on all the warnings and	die-messages
			     which are going to	be printed out,	and will print
			     a message when interesting	uncaught signals
			     arrive.

			     To	disable	this behaviour,	set these values to 0.
			     If	dieLevel is 2, then the	messages which will be



									Page 5






PERLDEBUG(1)							  PERLDEBUG(1)



			     caught by surrounding eval	are also printed.

     AutoTrace		     Trace mode	(similar to t command, but can be put
			     into PERLDB_OPTS).

     LineInfo		     File or pipe to print line	number info to.	 If it
			     is	a pipe (say, |visual_perl_db), then a short,
			     "emacs like" message is used.

     inhibit_exit	     If	0, allows stepping off the end of the script.

     PrintRet		     affects printing of return	value after r command.

     ornaments		     affects screen appearance of the command line
			     (see the Term::ReadLine manpage).

     frame		     affects printing messages on entry	and exit from
			     subroutines.  If frame & 2	is false, messages are
			     printed on	entry only. (Printing on exit may be
			     useful if inter(di)spersed	with other messages.)

			     If	frame &	4, arguments to	functions are printed
			     as	well as	the context and	caller info.  If frame
			     & 8, overloaded stringify and tied	FETCH are
			     enabled on	the printed arguments. If frame	& 16,
			     the return	value from the subroutine is printed
			     as	well.

			     The length	at which the argument list is
			     truncated is governed by the next option:

     maxTraceLen	     length at which the argument list is truncated
			     when frame	option's bit 4 is set.

			     The following options affect what happens with V,
			     X,	and x commands:

     arrayDepth, hashDepth   Print only	first N	elements ('' for all).

     compactDump, veryCompact
			     Change style of array and hash dump.  If
			     compactDump, short	array may be printed on	one
			     line.

     globPrint		     Whether to	print contents of globs.

     DumpDBFiles	     Dump arrays holding debugged files.

     DumpPackages	     Dump symbol tables	of packages.






									Page 6






PERLDEBUG(1)							  PERLDEBUG(1)



     quote, HighBit, undefPrint
			     Change style of string dump.  Default value of
			     quote is auto, one	can enable either doublequotish
 dump, or single-quotish by	setting	it to
			     " or '.  By default, characters with high bit set
			     are printed as is.

     UsageOnly		     very rudimentally per-package memory usage	dump.
			     Calculates	total size of strings in variables in
			     the package.

			     During startup options are	initialized from
			     $ENV{PERLDB_OPTS}.	 You can put additional
			     initialization options TTY, noTTY,	ReadLine, and
			     NonStop there.

			     Example rc	file:

			       &parse_options("NonStop=1 LineInfo=db.out AutoTrace");

			     The script	will run without human intervention,
			     putting trace information into the	file db.out.
			     (If you interrupt it, you would better reset
			     LineInfo to something "interactive"!)

     TTY		     The TTY to	use for	debugging I/O.

     noTTY		     If	set, goes in NonStop mode, and would not
			     connect to	a TTY.	If interrupt (or if control
			     goes to debugger via explicit setting of
			     $DB::signal or $DB::single	from the Perl script),
			     connects to a TTY specified by the	TTY option at
			     startup, or to a TTY found	at runtime using
			     Term::Rendezvous module of	your choice.

			     This module should	implement a method new which
			     returns an	object with two	methods: IN and	OUT,
			     returning two filehandles to use for debugging
			     input and output correspondingly.	Method new may
			     inspect an	argument which is a value of
			     $ENV{PERLDB_NOTTY}	at startup, or is
			     "/tmp/perldbtty$$"	otherwise.

     ReadLine		     If	false, readline	support	in debugger is
			     disabled, so you can debug	ReadLine applications.

     NonStop		     If	set, debugger goes into	noninteractive mode
			     until interrupted,	or programmatically by setting
			     $DB::signal or $DB::single.

			     Here's an example of using	the $ENV{PERLDB_OPTS}
			     variable:



									Page 7






PERLDEBUG(1)							  PERLDEBUG(1)



			       $ PERLDB_OPTS="N	f=2" perl -d myprogram

			     will run the script myprogram without human
			     intervention, printing out	the call tree with
			     entry and exit points.  Note that N f=2 is
			     equivalent	to NonStop=1 frame=2.  Note also that
			     at	the moment when	this documentation was written
			     all the options to	the debugger could be uniquely
			     abbreviated by the	first letter (with exception
			     of	Dump* options).

			     Other examples may	include

			       $ PERLDB_OPTS="N	f A L=listing" perl -d myprogram

			     - runs script noninteractively, printing info on
			     each entry	into a subroutine and each executed
			     line into the file	listing. (If you interrupt it,
			     you would better reset LineInfo to	something
			     "interactive"!)

			       $ env "PERLDB_OPTS=R=0 TTY=/dev/ttyc" perl -d myprogram

			     may be useful for debugging a program which uses
			     Term::ReadLine itself.  Do	not forget detach
			     shell from	the TTY	in the window which
			     corresponds to /dev/ttyc, say, by issuing a
			     command like

			       $ sleep 1000000

			     See the section on	Debugger Internals below for
			     more details.

     < [ command ]
		 Set an	action (Perl command) to happen	before every debugger
		 prompt.  A multi-line command may be entered by backslashing
		 the newlines.	If command is missing, resets the list of
		 actions.

     <<	command	 Add an	action (Perl command) to happen	before every debugger
		 prompt.  A multi-line command may be entered by backslashing
		 the newlines.

     > command	 Set an	action (Perl command) to happen	after the prompt when
		 you've	just given a command to	return to executing the
		 script.  A multi-line command may be entered by backslashing
		 the newlines.	If command is missing, resets the list of
		 actions.






									Page 8






PERLDEBUG(1)							  PERLDEBUG(1)



     >>	command	 Adds an action	(Perl command) to happen after the prompt when
		 you've	just given a command to	return to executing the
		 script.  A multi-line command may be entered by backslashing
		 the newlines.

     { [ command ]
		 Set an	action (debugger command) to happen before every
		 debugger prompt.  A multi-line	command	may be entered by
		 backslashing the newlines.  If	command	is missing, resets the
		 list of actions.

     {{	command	 Add an	action (debugger command) to happen before every
		 debugger prompt.  A multi-line	command	may be entered by
		 backslashing the newlines.

     ! number	 Redo a	previous command (default previous command).

     ! -number	 Redo number'th-to-last	command.

     ! pattern	 Redo last command that	started	with pattern.  See O
		 recallCommand,	too.

     !!	cmd	 Run cmd in a subprocess (reads	from DB::IN, writes to
		 DB::OUT) See O	shellBang too.

     H -number	 Display last n	commands.  Only	commands longer	than one
		 character are listed.	If number is omitted, lists them all.

     q or ^D	 Quit.	("quit"	doesn't	work for this.)	 This is the only
		 supported way to exit the debugger, though typing exit	twice
		 may do	it too.

		 Set an	Option inhibit_exit to 0 if you	want to	be able	to
		 step off the end the script.  You may also need to set
		 $finished to 0	at some	moment if you want to step through
		 global	destruction.

     R		 Restart the debugger by execing a new session.	 It tries to
		 maintain your history across this, but	internal settings and
		 command line options may be lost.

		 Currently the following setting are preserved:	history,
		 breakpoints, actions, debugger	Options, and the following
		 command line options: -w, -I, and -e.

     |dbcmd	 Run debugger command, piping DB::OUT to current pager.

     ||dbcmd	 Same as |dbcmd	but DB::OUT is temporarily selected as well.
		 Often used with commands that would otherwise produce long
		 output, such as

		     |V	main



									Page 9






PERLDEBUG(1)							  PERLDEBUG(1)



     = [alias value]
		 Define	a command alias, like

		     = quit q

		 or list current aliases.

     command	 Execute command as a Perl statement.  A missing semicolon
		 will be supplied.

     m expr	 The expression	is evaluated, and the methods which may	be
		 applied to the	result are listed.

     m package	 The methods which may be applied to objects in	the package
		 are listed.

     Debugger input/output

     Prompt  The debugger prompt is something like

		 DB<8>

	     or	even

		 DB<<17>>

	     where that	number is the command number, which you'd use to
	     access with the builtin csh-like history mechanism, e.g., !17
	     would repeat command number 17.  The number of angle brackets
	     indicates the depth of the	debugger.  You could get more than one
	     set of brackets, for example, if you'd already at a breakpoint
	     and then printed out the result of	a function call	that itself
	     also has a	breakpoint, or you step	into an	expression via s/n/t
	     expression	command.

     Multiline commands
	     If	you want to enter a multi-line command,	such as	a subroutine
	     definition	with several statements, or a format, you may escape
	     the newline that would normally end the debugger command with a
	     backslash.	 Here's	an example:

		   DB<1> for (1..4) {	      \
		   cont:     print "ok\n";   \
		   cont: }
		   ok
		   ok
		   ok
		   ok

	     Note that this business of	escaping a newline is specific to
	     interactive commands typed	into the debugger.




								       Page 10






PERLDEBUG(1)							  PERLDEBUG(1)



     Stack backtrace
	     Here's an example of what a stack backtrace via T command might
	     look like:

		 $ = main::infested called from	file `Ambulation.pm' line 10
		 @ = Ambulation::legs(1, 2, 3, 4) called from file `camel_flea'	line 7
		 $ = main::pests('bactrian', 4)	called from file `camel_flea' line 4

	     The left-hand character up	there tells whether the	function was
	     called in a scalar	or list	context	(we bet	you can	tell which is
	     which).  What that	says is	that you were in the function
	     main::infested when you ran the stack dump, and that it was
	     called in a scalar	context	from line 10 of	the file
	     Ambulation.pm, but	without	any arguments at all, meaning it was
	     called as &infested.  The next stack frame	shows that the
	     function Ambulation::legs was called in a list context from the
	     camel_flea	file with four arguments.  The last stack frame	shows
	     that main::pests was called in a scalar context, also from
	     camel_flea, but from line 4.

	     Note that if you execute T	command	from inside an active use
	     statement,	the backtrace will contain both	the require entry in
	     the perlfunc manpage frame	and an the section on eval EXPR	in the
	     perlfunc manpage) frame.

     Listing Listing given via different flavors of l command looks like this:

		 DB<<13>> l
	       101:		   @i{@i} = ();
	       102:b		   @isa{@i,$pack} = ()
	       103		       if(exists $i{$prevpack} || exists $isa{$pack});
	       104	       }
	       105
	       106	       next
	       107==>		   if(exists $isa{$pack});
	       108
	       109:a	       if ($extra-- > 0) {
	       110:		   %isa	= ($pack,1);

	     Note that the breakable lines are marked with :, lines with
	     breakpoints are marked by b, with actions by a, and the next
	     executed line is marked by	==>.

     Frame listing
	     When frame	option is set, debugger	would print entered (and
	     optionally	exited)	subroutines in different styles.

	     What follows is the start of the listing of

	       env "PERLDB_OPTS=f=n N" perl -d -V

	     for different values of n:



								       Page 11






PERLDEBUG(1)							  PERLDEBUG(1)



     1

		   entering main::BEGIN
		    entering Config::BEGIN
		     Package lib/Exporter.pm.
		     Package lib/Carp.pm.
		    Package lib/Config.pm.
		    entering Config::TIEHASH
		    entering Exporter::import
		     entering Exporter::export
		   entering Config::myconfig
		    entering Config::FETCH
		    entering Config::FETCH
		    entering Config::FETCH
		    entering Config::FETCH


     2

		   entering main::BEGIN
		    entering Config::BEGIN
		     Package lib/Exporter.pm.
		     Package lib/Carp.pm.
		    exited Config::BEGIN
		    Package lib/Config.pm.
		    entering Config::TIEHASH
		    exited Config::TIEHASH
		    entering Exporter::import
		     entering Exporter::export
		     exited Exporter::export
		    exited Exporter::import
		   exited main::BEGIN
		   entering Config::myconfig
		    entering Config::FETCH
		    exited Config::FETCH
		    entering Config::FETCH
		    exited Config::FETCH
		    entering Config::FETCH


     4














								       Page 12






PERLDEBUG(1)							  PERLDEBUG(1)



		   in  $=main::BEGIN() from /dev/nul:0
		    in	$=Config::BEGIN() from lib/Config.pm:2
		     Package lib/Exporter.pm.
		     Package lib/Carp.pm.
		    Package lib/Config.pm.
		    in	$=Config::TIEHASH('Config') from lib/Config.pm:644
		    in	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/nul:0
		     in	 $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from li
		   in  @=Config::myconfig() from /dev/nul:0
		    in	$=Config::FETCH(ref(Config), 'package')	from lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'baserev')	from lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'PATCHLEVEL') from	lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'SUBVERSION') from	lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'osname') from lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'osvers') from lib/Config.pm:574


     6

		   in  $=main::BEGIN() from /dev/nul:0
		    in	$=Config::BEGIN() from lib/Config.pm:2
		     Package lib/Exporter.pm.
		     Package lib/Carp.pm.
		    out	$=Config::BEGIN() from lib/Config.pm:0
		    Package lib/Config.pm.
		    in	$=Config::TIEHASH('Config') from lib/Config.pm:644
		    out	$=Config::TIEHASH('Config') from lib/Config.pm:644
		    in	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/nul:0
		     in	 $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/
		     out $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/
		    out	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/nul:0
		   out $=main::BEGIN() from /dev/nul:0
		   in  @=Config::myconfig() from /dev/nul:0
		    in	$=Config::FETCH(ref(Config), 'package')	from lib/Config.pm:574
		    out	$=Config::FETCH(ref(Config), 'package')	from lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'baserev')	from lib/Config.pm:574
		    out	$=Config::FETCH(ref(Config), 'baserev')	from lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'PATCHLEVEL') from	lib/Config.pm:574
		    out	$=Config::FETCH(ref(Config), 'PATCHLEVEL') from	lib/Config.pm:574
		    in	$=Config::FETCH(ref(Config), 'SUBVERSION') from	lib/Config.pm:574


     14












								       Page 13






PERLDEBUG(1)							  PERLDEBUG(1)



		   in  $=main::BEGIN() from /dev/nul:0
		    in	$=Config::BEGIN() from lib/Config.pm:2
		     Package lib/Exporter.pm.
		     Package lib/Carp.pm.
		    out	$=Config::BEGIN() from lib/Config.pm:0
		    Package lib/Config.pm.
		    in	$=Config::TIEHASH('Config') from lib/Config.pm:644
		    out	$=Config::TIEHASH('Config') from lib/Config.pm:644
		    in	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/nul:0
		     in	 $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/E
		     out $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/E
		    out	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/nul:0
		   out $=main::BEGIN() from /dev/nul:0
		   in  @=Config::myconfig() from /dev/nul:0
		    in	$=Config::FETCH('Config=HASH(0x1aa444)', 'package') from lib/Config.pm:574
		    out	$=Config::FETCH('Config=HASH(0x1aa444)', 'package') from lib/Config.pm:574
		    in	$=Config::FETCH('Config=HASH(0x1aa444)', 'baserev') from lib/Config.pm:574
		    out	$=Config::FETCH('Config=HASH(0x1aa444)', 'baserev') from lib/Config.pm:574


     30

		   in  $=CODE(0x15eca4)() from /dev/null:0
		    in	$=CODE(0x182528)() from	lib/Config.pm:2
		     Package lib/Exporter.pm.
		    out	$=CODE(0x182528)() from	lib/Config.pm:0
		    scalar context return from CODE(0x182528): undef
		    Package lib/Config.pm.
		    in	$=Config::TIEHASH('Config') from lib/Config.pm:628
		    out	$=Config::TIEHASH('Config') from lib/Config.pm:628
		    scalar context return from Config::TIEHASH:	  empty	hash
		    in	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/null:0
		     in	 $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/Exporter.pm:171
		     out $=Exporter::export('Config', 'main', 'myconfig', 'config_vars') from lib/Exporter.pm:171
		     scalar context return from	Exporter::export: ''
		    out	$=Exporter::import('Config', 'myconfig', 'config_vars')	from /dev/null:0
		    scalar context return from Exporter::import: ''


		 In all	the cases indentation of lines shows the call tree, if
		 bit 2 of frame	is set,	then a line is printed on exit from a
		 subroutine as well, if	bit 4 is set, then the arguments are
		 printed as well as the	caller info, if	bit 8 is set, the
		 arguments are printed even if they are	tied or	references, if
		 bit 16	is set,	the return value is printed as well.

		 When a	package	is compiled, a line like this

		     Package lib/Carp.pm.

		 is printed with proper	indentation.




								       Page 14






PERLDEBUG(1)							  PERLDEBUG(1)



     Debugging compile-time statements    [Toc]    [Back]

     If	you have any compile-time executable statements	(code within a BEGIN
     block or a	use statement),	these will NOT be stopped by debugger,
     although requires will (and compile-time statements can be	traced with
     AutoTrace option set in PERLDB_OPTS).  From your own Perl code, however,
     you can transfer control back to the debugger using the following
     statement,	which is harmless if the debugger is not running:

	 $DB::single = 1;

     If	you set	$DB::single to the value 2, it's equivalent to having just
     typed the n command, whereas a value of 1 means the s command.  The
     $DB::trace	 variable should be set	to 1 to	simulate having	typed the t
     command.

     Another way to debug compile-time code is to start	debugger, set a
     breakpoint	on load	of some	module thusly

	 DB<7> b load f:/perllib/lib/Carp.pm
       Will stop on load of `f:/perllib/lib/Carp.pm'.

     and restart debugger by R command (if possible).  One can use b compile
     subname for the same purpose.

     Debugger Customization    [Toc]    [Back]

     Most probably you not want	to modify the debugger,	it contains enough
     hooks to satisfy most needs.  You may change the behaviour	of debugger
     from the debugger itself, using Options, from the command line via
     PERLDB_OPTS environment variable, and from	customization files.

     You can do	some customization by setting up a .perldb file	which contains
     initialization code.  For instance, you could make	aliases	like these
     (the last one is one people expect	to be there):

	 $DB::alias{'len'}  = 's/^len(.*)/p length($1)/';
	 $DB::alias{'stop'} = 's/^stop (at|in)/b/';
	 $DB::alias{'ps'}   = 's/^ps\b/p scalar	/';
	 $DB::alias{'quit'} = 's/^quit(\s*)/exit\$/';

     One changes options from .perldb file via calls like this one;

	 parse_options("NonStop=1 LineInfo=db.out AutoTrace=1 frame=2");

     (the code is executed in the package DB).	Note that .perldb is processed
     before processing PERLDB_OPTS.  If	.perldb	defines	the subroutine
     afterinit,	it is called after all the debugger initialization ends.
     .perldb may be contained in the current directory,	or in the LOGDIR/HOME
     directory.





								       Page 15






PERLDEBUG(1)							  PERLDEBUG(1)



     If	you want to modify the debugger, copy perl5db.pl from the Perl library
     to	another	name and modify	it as necessary.  You'll also want to set your
     PERL5DB environment variable to say something like	this:

	 BEGIN { require "myperl5db.pl"	}

     As	the last resort, one can use PERL5DB to	customize debugger by directly
     setting internal variables	or calling debugger functions.

     Readline Support    [Toc]    [Back]

     As	shipped, the only command line history supplied	is a simplistic	one
     that checks for leading exclamation points.  However, if you install the
     Term::ReadKey and Term::ReadLine modules from CPAN, you will have full
     editing capabilities much like GNU	readline(3) provides.  Look for	these
     in	the modules/by-module/Term directory on	CPAN.

     A rudimentary command line	completion is also available.  Unfortunately,
     the names of lexical variables are	not available for completion.

     Editor Support for	Debugging

     If	you have GNU emacs installed on	your system, it	can interact with the
     Perl debugger to provide an integrated software development environment
     reminiscent of its	interactions with C debuggers.

     Perl is also delivered with a start file for making emacs act like	a
     syntax-directed editor that understands (some of) Perl's syntax.  Look in
     the emacs directory of the	Perl source distribution.

     (Historically, a similar setup for	interacting with vi and	the X11	window
     system had	also been available, but at the	time of	this writing, no
     debugger support for vi currently exists.)

     The Perl Profiler    [Toc]    [Back]

     If	you wish to supply an alternative debugger for Perl to run, just
     invoke your script	with a colon and a package argument given to the -d
     flag.  One	of the most popular alternative	debuggers for Perl is DProf,
     the Perl profiler.	  As of	this writing, DProf is not included with the
     standard Perl distribution, but it	is expected to be included soon, for
     certain values of "soon".

     Meanwhile,	you can	fetch the Devel::Dprof module from CPAN.  Assuming
     it's properly installed on	your system, to	profile	your Perl program in
     the file mycode.pl, just type:

	 perl -d:DProf mycode.pl

     When the script terminates	the profiler will dump the profile information
     to	a file called tmon.out.	 A tool	like dprofpp (also supplied with the
     Devel::DProf package) can be used to interpret the	information which is



								       Page 16






PERLDEBUG(1)							  PERLDEBUG(1)



     in	that profile.

     Debugger support in perl    [Toc]    [Back]

     When you call the caller function (see the	caller entry in	the perlfunc
     manpage) from the package DB, Perl	sets the array @DB::args to contain
     the arguments the corresponding stack frame was called with.

     If	perl is	run with -d option, the	following additional features are
     enabled (cf. the section on $^P in	the perlvar manpage):

     o	  Perl inserts the contents of $ENV{PERL5DB} (or BEGIN {require
	  'perl5db.pl'}	if not present)	before the first line of the
	  application.

     o	  The array C<@{"_<$filename"}>	is the line-by-line contents of
	  $filename for	all the	compiled files.	 Same for evaled strings which
	  contain subroutines, or which	are currently executed.	 The $filename
	  for evaled strings looks like	(eval 34).

     o	  The hash C<%{"_<$filename"}> contains	breakpoints and	action (it is
	  keyed	by line	number), and individual	entries	are settable (as
	  opposed to the whole hash).  Only true/false is important to Perl,
	  though the values used by perl5db.pl have the	form
	  "$break_condition\0$action".	Values are magical in numeric context:
	  they are zeros if the	line is	not breakable.

	  Same for evaluated strings which contain subroutines,	or which are
	  currently executed.  The $filename for evaled	strings	looks like
	  (eval	34).

     o	  The scalar C<${"_<$filename"}> contains C<"_<$filename">.  Same for
	  evaluated strings which contain subroutines, or which	are currently
	  executed.  The $filename for evaled strings looks like (eval 34).

     o	  After	each required file is compiled,	but before it is executed,
	  C<DB::postponed(*{"_<$filename"})> is	called (if subroutine
	  DB::postponed	exists).  Here the $filename is	the expanded name of
	  the required file (as	found in values	of %INC).

     o	  After	each subroutine	subname	is compiled existence of
	  $DB::postponed{subname} is checked.  If this key exists,
	  DB::postponed(subname) is called (if subroutine DB::postponed
	  exists).

     o	  A hash %DB::sub is maintained, with keys being subroutine names,
	  values having	the form filename:startline-endline.  filename has the
	  form (eval 31) for subroutines defined inside	evals.

     o	  When execution of the	application reaches a place that can have a
	  breakpoint, a	call to	DB::DB() is performed if any one of variables
	  $DB::trace, $DB::single, or $DB::signal is true. (Note that these



								       Page 17






PERLDEBUG(1)							  PERLDEBUG(1)



	  variables are	not localizable.) This feature is disabled when	the
	  control is inside DB::DB() or	functions called from it (unless $^D &
	  (1<<30)).

     o	  When execution of the	application reaches a subroutine call, a call
	  to &DB::sub(args) is performed instead, with $DB::sub	being the name
	  of the called	subroutine. (Unless the	subroutine is compiled in the
	  package DB.)

     Note that if &DB::sub needs some external data to be setup	for it to
     work, no subroutine call is possible until	this is	done.  For the
     standard debugger $DB::deep (how many levels of recursion deep into the
     debugger you can go before	a mandatory break) gives an example of such a
     dependency.

     The minimal working debugger consists of one line

       sub DB::DB {}

     which is quite handy as contents of PERL5DB environment variable:

       env "PERL5DB=sub	DB::DB {}" perl	-d your-script

     Another (a	little bit more	useful)	minimal	debugger can be	created	with
     the only line being

       sub DB::DB {print ++$i; scalar <STDIN>}

     This debugger would print the sequential number of	encountered statement,
     and would wait for	your CR	to continue.

     The following debugger is quite functional:

       {
	 package DB;
	 sub DB	 {}
	 sub sub {print	++$i, "	$sub\n"; &$sub}
       }

     It	prints the sequential number of	subroutine call	and the	name of	the
     called subroutine.	 Note that &DB::sub should be compiled into the
     package DB.

     Debugger Internals    [Toc]    [Back]

     At	the start, the debugger	reads your rc file (./.perldb or ~/.perldb
     under Unix), which	can set	important options.  This file may define a
     subroutine	&afterinit to be executed after	the debugger is	initialized.

     After the rc file is read,	the debugger reads environment variable
     PERLDB_OPTS and parses it as a rest of O ... line in debugger prompt.




								       Page 18






PERLDEBUG(1)							  PERLDEBUG(1)



     It	also maintains magical internal	variables, such	as @DB::dbline,
     %DB::dbline, which	are aliases for	C<@{"::_<current_file"}>
     C<%{"::_<current_file"}>.	Here current_file is the currently selected
     (with the debugger's f command, or	by flow	of execution) file.

     Some functions are	provided to simplify customization.  See the section
     on	Debugger Customization for description of DB::parse_options(string).
     The function DB::dump_trace(skip[,	count])	skips the specified number of
     frames, and returns an array containing info about	the caller frames (all
     if	count is missing).  Each entry is a hash with keys context ($ or @),
     sub (subroutine name, or info about eval),	args (undef or a reference to
     an	array),	file, and line.

     The function DB::print_trace(FH, skip[, count[, short]]) prints formatted
     info about	caller frames.	The last two functions may be convenient as
     arguments to <, <<	commands.

     Other resources    [Toc]    [Back]

     You did try the -w	switch,	didn't you?

BUGS    [Toc]    [Back]

     You cannot	get the	stack frame information	or otherwise debug functions
     that were not compiled by Perl, such as C or C++ extensions.

     If	you alter your @_ arguments in a subroutine (such as with shift	or
     pop, the stack backtrace will not show the	original values.




























								       Page 19






PERLDEBUG(1)							  PERLDEBUG(1)


								       PPPPaaaaggggeeee 22220000
[ Back ]
 Similar pages
Name OS Title
perldebguts OpenBSD Guts of Perl debugging
perldebtut OpenBSD Perl debugging tutorial
perljp OpenBSD AEuEU,i Perl Y~YxYE `A^a`I`A Perl xIAx3|xOxex|x3x1/2! Perl 5.8.0 xexeicUni- _ codeYuYYi1/4YEx~AcEyxE...
fsdb FreeBSD FFS debugging/editing tool
rip6query FreeBSD RIPng debugging tool
VOP_PRINT FreeBSD print debugging information
ptrace NetBSD process tracing and debugging
rip6query OpenBSD RIPng debugging tool
curs_trace FreeBSD curses debugging routines
ptrace FreeBSD process tracing and debugging
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service