First of all, there's a few things you can do to make your life a lot more
straightforward when it comes to debugging perl programs, without using the
-debugger at all. To demonstrate, here's a simple script with a problem:
+debugger at all. To demonstrate, here's a simple script, named "hello", with
+a problem:
#!/usr/bin/perl
blank line. It looks like there's 2 variables when (because of the typo)
there's really 3:
- $var1 = 'Hello World'
- $varl = undef
- $var2 = "\n"
+ $var1 = 'Hello World';
+ $varl = undef;
+ $var2 = "\n";
To catch this kind of problem, we can force each variable to be declared
before use by pulling in the strict module, by putting 'use strict;' after the
use strict;
my $var1 = 'Hello World';
- my $varl = '';
+ my $varl = undef;
my $var2 = "$varl\n";
print $var2;
hello syntax OK
And now when we run it, we get "\n" still, but at least we know why. Just
-getting this script to compile has exposed the '$varl' (with the letter 'l)
+getting this script to compile has exposed the '$varl' (with the letter 'l')
variable, and simply changing $varl to $var1 solves the problem.
-=head1 Looking at data and -w and w
+=head1 Looking at data and -w and v
Ok, but how about when you want to really see your data, what's in that
dynamic variable, just before using it?
=head1 help
Fire the debugger up again on your script and we'll look at the help menu.
-There's a couple of ways of calling help: a simple 'B<h>' will get you a long
-scrolled list of help, 'B<|h>' (pipe-h) will pipe the help through your pager
-('more' or 'less' probably), and finally, 'B<h h>' (h-space-h) will give you a
-helpful mini-screen snapshot:
+There's a couple of ways of calling help: a simple 'B<h>' will get the summary
+help list, 'B<|h>' (pipe-h) will pipe the help through your pager (which is
+(probably 'more' or 'less'), and finally, 'B<h h>' (h-space-h) will give you
+the entire help screen. Here is the summary page:
+
+DB<1>h
- DB<1> h h
List/search source lines: Control script execution:
- l [ln|sub] List source code T Stack trace
- - or . List previous/current line s [expr] Single step [in expr]
- w [line] List around line n [expr] Next, steps over subs
- f filename View source in file <CR/Enter> Repeat last n or s
- /pattern/ ?patt? Search forw/backw r Return from subroutine
- v Show versions of modules c [ln|sub] Continue until position
- Debugger controls: L List
-break/watch/actions
- O [...] Set debugger options t [expr] Toggle trace [trace expr]
- <[<]|{[{]|>[>] [cmd] Do pre/post-prompt b [ln|event|sub] [cnd] Set breakpoint
- ! [N|pat] Redo a previous command d [ln] or D Delete a/all breakpoints
- H [-num] Display last num commands a [ln] cmd Do cmd before line
- = [a val] Define/list an alias W expr Add a watch expression
- h [db_cmd] Get help on command A or W Delete all actions/watch
- |[|]db_cmd Send output to pager ![!] syscmd Run cmd in a subprocess
- q or ^D Quit R Attempt a restart
- Data Examination: expr Execute perl code, also see: s,n,t expr
- x|m expr Evals expr in list context, dumps the result or lists methods.
- p expr Print expression (uses script's current package).
- S [[!]pat] List subroutine names [not] matching pattern
- V [Pk [Vars]] List Variables in Package. Vars can be ~pattern or !pattern.
- X [Vars] Same as "V current_package [Vars]".
- For more help, type h cmd_letter, or run man perldebug for all docs.
+ l [ln|sub] List source code T Stack trace
+ - or . List previous/current line s [expr] Single step
+ [in expr]
+ v [line] View around line n [expr] Next, steps over
+ subs
+ f filename View source in file <CR/Enter> Repeat last n or s
+ /pattern/ ?patt? Search forw/backw r Return from
+ subroutine
+ M Show module versions c [ln|sub] Continue until
+ position
+ Debugger controls: L List break/watch/
+ actions
+ o [...] Set debugger options t [expr] Toggle trace
+ [trace expr]
+ <[<]|{[{]|>[>] [cmd] Do pre/post-prompt b [ln|event|sub] [cnd] Set
+ breakpoint
+ ! [N|pat] Redo a previous command B ln|* Delete a/all
+ breakpoints
+ H [-num] Display last num commands a [ln] cmd Do cmd before line
+ = [a val] Define/list an alias A ln|* Delete a/all
+ actions
+ h [db_cmd] Get help on command w expr Add a watch
+ expression
+ h h Complete help page W expr|* Delete a/all watch
+ exprs
+ |[|]db_cmd Send output to pager ![!] syscmd Run cmd in a
+ subprocess
+ q or ^D Quit R Attempt a restart
+ Data Examination: expr Execute perl code, also see: s,n,t expr
+ x|m expr Evals expr in list context, dumps the result or lists
+ methods.
+ p expr Print expression (uses script's current package).
+ S [[!]pat] List subroutine names [not] matching pattern
+ V [Pk [Vars]] List Variables in Package. Vars can be ~pattern or
+ !pattern.
+ X [Vars] Same as "V current_package [Vars]".
+ y [n [Vars]] List lexicals in higher scope <n>. Vars same as V.
+ For more help, type h cmd_letter, or run man perldebug for all docs.
More confusing options than you can shake a big stick at! It's not as bad as
it looks and it's very useful to know more about all of it, and fun too!
There's a couple of useful ones to know about straight away. You wouldn't
-think we're using any libraries at all at the moment, but 'B<v>' will show
-which modules are currently loaded, by the debugger as well your script.
-'B<V>' and 'B<X>' show variables in the program by package scope and can be
-constrained by pattern. 'B<m>' shows methods and 'B<S>' shows all subroutines
-(by pattern):
+think we're using any libraries at all at the moment, but 'B<M>' will show
+which modules are currently loaded, and their version number, while 'B<m>'
+will show the methods, and 'B<S>' shows all subroutines (by pattern) as
+shown below. 'B<V>' and 'B<X>' show variables in the program by package
+scope and can be constrained by pattern.
DB<2>S str
dumpvar::stringify
FileHandle(stderr) => fileno(2)
Remember we're in our tiny program with a problem, we should have a look at
-where we are, and what our data looks like. First of all let's have a window
-on our present position (the first line of code in this case), via the letter
-'B<w>':
+where we are, and what our data looks like. First of all let's view some code
+at our present position (the first line of code in this case), via 'B<v>':
- DB<4> w
+ DB<4> v
1 #!/usr/bin/perl
2: use strict;
3
10 );
At line number 4 is a helpful pointer, that tells you where you are now. To
-see more code, type 'w' again:
+see more code, type 'v' again:
- DB<4> w
+ DB<4> v
8 'welcome' => q(Hello World),
9 'zip' => q(welcome),
10 );
and will merrily dump out nested references, complete objects, partial objects
- just about whatever you throw at it:
-Let's make a quick object and x-plode it, first we'll start the the debugger:
-it wants some form of input from STDIN, so we give it something non-commital,
+Let's make a quick object and x-plode it, first we'll start the debugger:
+it wants some form of input from STDIN, so we give it something non-committal,
a zero:
- > perl -de 0
- Default die handler restored.
+ > perl -de 0
+ Default die handler restored.
- Loading DB routines from perl5db.pl version 1.07
- Editor support available.
+ Loading DB routines from perl5db.pl version 1.07
+ Editor support available.
- Enter h or `h h' for help, or `man perldebug' for more help.
+ Enter h or `h h' for help, or `man perldebug' for more help.
- main::(-e:1): 0
+ main::(-e:1): 0
Now build an on-the-fly object over a couple of lines (note the backslash):
- DB<1> $obj = bless({'unique_id'=>'123', 'attr'=> \
- cont: {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
+ DB<1> $obj = bless({'unique_id'=>'123', 'attr'=> \
+ cont: {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
And let's have a look at it:
DB<2> x $obj
- 0 MY_class=HASH(0x828ad98)
+ 0 MY_class=HASH(0x828ad98)
'attr' => HASH(0x828ad68)
'col' => 'black'
'things' => ARRAY(0x828abb8)
Useful, huh? You can eval nearly anything in there, and experiment with bits
of code or regexes until the cows come home:
- DB<3> @data = qw(this that the other atheism leather theory scythe)
+ DB<3> @data = qw(this that the other atheism leather theory scythe)
- DB<4> p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
- atheism
- leather
- other
- scythe
- the
- theory
- saw -> 6
+ DB<4> p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
+ atheism
+ leather
+ other
+ scythe
+ the
+ theory
+ saw -> 6
If you want to see the command History, type an 'B<H>':
- DB<5> H
- 4: p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
- 3: @data = qw(this that the other atheism leather theory scythe)
- 2: x $obj
- 1: $obj = bless({'unique_id'=>'123', 'attr'=>
- {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
- DB<5>
+ DB<5> H
+ 4: p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
+ 3: @data = qw(this that the other atheism leather theory scythe)
+ 2: x $obj
+ 1: $obj = bless({'unique_id'=>'123', 'attr'=>
+ {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
+ DB<5>
And if you want to repeat any previous command, use the exclamation: 'B<!>':
- DB<5> !4
- p 'saw -> '.($cnt += map { print "$_\n" } grep(/the/, sort @data))
- atheism
- leather
- other
- scythe
- the
- theory
- saw -> 12
+ DB<5> !4
+ p 'saw -> '.($cnt += map { print "$_\n" } grep(/the/, sort @data))
+ atheism
+ leather
+ other
+ scythe
+ the
+ theory
+ saw -> 12
For more on references see L<perlref> and L<perlreftut>
Here's a simple program which converts between Celsius and Fahrenheit, it too
has a problem:
- #!/usr/bin/perl -w
- use strict;
+ #!/usr/bin/perl -w
+ use strict;
- my $arg = $ARGV[0] || '-c20';
-
- if ($arg =~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
- my ($deg, $num) = ($1, $2);
- my ($in, $out) = ($num, $num);
- if ($deg eq 'c') {
- $deg = 'f';
- $out = &c2f($num);
- } else {
- $deg = 'c';
- $out = &f2c($num);
- }
- $out = sprintf('%0.2f', $out);
- $out =~ s/^((\-|\+)*\d+)\.0+$/$1/;
- print "$out $deg\n";
- } else {
- print "Usage: $0 -[c|f] num\n";
- }
- exit;
-
- sub f2c {
- my $f = shift;
- my $c = 5 * $f - 32 / 9;
- return $c;
- }
+ my $arg = $ARGV[0] || '-c20';
- sub c2f {
- my $c = shift;
- my $f = 9 * $c / 5 + 32;
- return $f;
+ if ($arg =~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
+ my ($deg, $num) = ($1, $2);
+ my ($in, $out) = ($num, $num);
+ if ($deg eq 'c') {
+ $deg = 'f';
+ $out = &c2f($num);
+ } else {
+ $deg = 'c';
+ $out = &f2c($num);
}
+ $out = sprintf('%0.2f', $out);
+ $out =~ s/^((\-|\+)*\d+)\.0+$/$1/;
+ print "$out $deg\n";
+ } else {
+ print "Usage: $0 -[c|f] num\n";
+ }
+ exit;
+
+ sub f2c {
+ my $f = shift;
+ my $c = 5 * $f - 32 / 9;
+ return $c;
+ }
+
+ sub c2f {
+ my $c = shift;
+ my $f = 9 * $c / 5 + 32;
+ return $f;
+ }
For some reason, the Fahrenheit to Celsius conversion fails to return the
expected output. This is what it does:
- > temp -c0.72
- 33.30 f
+ > temp -c0.72
+ 33.30 f
- > temp -f33.3
- 162.94 c
+ > temp -f33.3
+ 162.94 c
Not very consistent! We'll set a breakpoint in the code manually and run it
under the debugger to see what's going on. A breakpoint is a flag, to which
DB<1> c
main::(temp:10): if ($deg eq 'c') {
-Followed by a window command to see where we are:
+Followed by a view command to see where we are:
- DB<1> w
+ DB<1> v
7: my ($deg, $num) = ($1, $2);
8: my ($in, $out) = ($num, $num);
9: $DB::single=2;
17: print "$out $deg\n";
break if (1)
-Note that to delete a breakpoint you use 'd' or 'D'.
+Note that to delete a breakpoint you use 'B'.
Now we'll continue down into our subroutine, this time rather than by line
-number, we'll use the subroutine name, followed by the now familiar 'w':
+number, we'll use the subroutine name, followed by the now familiar 'v':
DB<3> c f2c
main::f2c(temp:30): my $f = shift;
- DB<4> w
+ DB<4> v
24: exit;
25
26 sub f2c {
a
- W
+ w
t
Ever wanted to know what a regex looked like? You'll need perl compiled with
the DEBUGGING flag for this one:
- > perl -Dr -e '/^pe(a)*rl$/i'
- Compiling REx `^pe(a)*rl$'
- size 17 first at 2
- rarest char
- at 0
- 1: BOL(2)
- 4: CURLYN[1] {0,32767}(14)
- 6: NOTHING(8)
- 12: WHILEM(0)
- 13: NOTHING(14)
- 14: EXACTF <rl>(16)
- 16: EOL(17)
- 17: END(0)
- floating `'$ at 4..2147483647 (checking floating) stclass `EXACTF <pe>'
-anchored(BOL) minlen 4
- Omitting $` $& $' support.
-
- EXECUTING...
-
- Freeing REx: `^pe(a)*rl$'
+ > perl -Dr -e '/^pe(a)*rl$/i'
+ Compiling REx `^pe(a)*rl$'
+ size 17 first at 2
+ rarest char
+ at 0
+ 1: BOL(2)
+ 2: EXACTF <pe>(4)
+ 4: CURLYN[1] {0,32767}(14)
+ 6: NOTHING(8)
+ 8: EXACTF <a>(0)
+ 12: WHILEM(0)
+ 13: NOTHING(14)
+ 14: EXACTF <rl>(16)
+ 16: EOL(17)
+ 17: END(0)
+ floating `'$ at 4..2147483647 (checking floating) stclass
+ `EXACTF <pe>' anchored(BOL) minlen 4
+ Omitting $` $& $' support.
+
+ EXECUTING...
+
+ Freeing REx: `^pe(a)*rl$'
Did you really want to know? :-)
For more gory details on getting regular expressions to work, have a look at
Wrapping all die calls in a handler routine can be useful to see how, and from
where, they're being called, L<perlvar> has more information:
- BEGIN { $SIG{__DIE__} = sub { require Carp; Carp::confess(@_) } }
+ BEGIN { $SIG{__DIE__} = sub { require Carp; Carp::confess(@_) } }
Various useful techniques for the redirection of STDOUT and STDERR filehandles
are explained in L<perlopentut> and L<perlfaq8>.
You don't have to do this all on the command line, though, there are a few GUI
options out there. The nice thing about these is you can wave a mouse over a
-variable and a dump of it's data will appear in an appropriate window, or in a
+variable and a dump of its data will appear in an appropriate window, or in a
popup balloon, no more tiresome typing of 'x $varname' :-)
In particular have a hunt around for the following:
L<perldebug>,
L<perldebguts>,
L<perldiag>,
-L<dprofpp>,
L<perlrun>
=head1 AUTHOR
-Richard Foley <richard@rfi.net> Copyright (c) 2000
+Richard Foley <richard.foley@rfi.net> Copyright (c) 2000
=head1 CONTRIBUTORS
https://perl5.git.perl.org / perl5.git / blobdiff