This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: [ID 20020614.027] Bad Debugger mojo in RC1
[perl5.git] / pod / perldebtut.pod
CommitLineData
10862624
RF
1=head1 NAME
2
3perldebtut - Perl debugging tutorial
4
5=head1 DESCRIPTION
6
7A (very) lightweight introduction in the use of the perl debugger, and a
8pointer to existing, deeper sources of information on the subject of debugging
7218dffe 9perl programs.
10862624
RF
10
11There's an extraordinary number of people out there who don't appear to know
12anything about using the perl debugger, though they use the language every
13day.
14This is for them.
15
16
17=head1 use strict
18
7218dffe
JH
19First of all, there's a few things you can do to make your life a lot more
20straightforward when it comes to debugging perl programs, without using the
6a8e4891
EM
21debugger at all. To demonstrate, here's a simple script, named "hello", with
22a problem:
10862624
RF
23
24 #!/usr/bin/perl
cea6626f 25
10862624
RF
26 $var1 = 'Hello World'; # always wanted to do that :-)
27 $var2 = "$varl\n";
cea6626f 28
10862624
RF
29 print $var2;
30 exit;
31
32While this compiles and runs happily, it probably won't do what's expected,
33namely it doesn't print "Hello World\n" at all; It will on the other hand do
34exactly what it was told to do, computers being a bit that way inclined. That
35is, it will print out a newline character, and you'll get what looks like a
36blank line. It looks like there's 2 variables when (because of the typo)
37there's really 3:
38
6a8e4891
EM
39 $var1 = 'Hello World';
40 $varl = undef;
41 $var2 = "\n";
10862624
RF
42
43To catch this kind of problem, we can force each variable to be declared
44before use by pulling in the strict module, by putting 'use strict;' after the
45first line of the script.
46
47Now when you run it, perl complains about the 3 undeclared variables and we
48get four error messages because one variable is referenced twice:
cea6626f 49
10862624
RF
50 Global symbol "$var1" requires explicit package name at ./t1 line 4.
51 Global symbol "$var2" requires explicit package name at ./t1 line 5.
52 Global symbol "$varl" requires explicit package name at ./t1 line 5.
53 Global symbol "$var2" requires explicit package name at ./t1 line 7.
7218dffe 54 Execution of ./hello aborted due to compilation errors.
10862624
RF
55
56Luvverly! and to fix this we declare all variables explicitly and now our
57script looks like this:
58
59 #!/usr/bin/perl
60 use strict;
cea6626f 61
10862624 62 my $var1 = 'Hello World';
6a8e4891 63 my $varl = undef;
10862624 64 my $var2 = "$varl\n";
cea6626f 65
10862624
RF
66 print $var2;
67 exit;
68
69We then do (always a good idea) a syntax check before we try to run it again:
70
71 > perl -c hello
72 hello syntax OK
73
74And now when we run it, we get "\n" still, but at least we know why. Just
cb0b211a 75getting this script to compile has exposed the '$varl' (with the letter 'l')
10862624
RF
76variable, and simply changing $varl to $var1 solves the problem.
77
78
492652be 79=head1 Looking at data and -w and v
10862624
RF
80
81Ok, but how about when you want to really see your data, what's in that
82dynamic variable, just before using it?
83
84 #!/usr/bin/perl
85 use strict;
86
87 my $key = 'welcome';
88 my %data = (
89 'this' => qw(that),
90 'tom' => qw(and jerry),
91 'welcome' => q(Hello World),
92 'zip' => q(welcome),
93 );
94 my @data = keys %data;
95
96 print "$data{$key}\n";
97 exit;
98
99Looks OK, after it's been through the syntax check (perl -c scriptname), we
100run it and all we get is a blank line again! Hmmmm.
cea6626f 101
10862624
RF
102One common debugging approach here, would be to liberally sprinkle a few print
103statements, to add a check just before we print out our data, and another just
104after:
105
106 print "All OK\n" if grep($key, keys %data);
107 print "$data{$key}\n";
108 print "done: '$data{$key}'\n";
109
110And try again:
cea6626f 111
10862624
RF
112 > perl data
113 All OK
cea6626f 114
10862624
RF
115 done: ''
116
117After much staring at the same piece of code and not seeing the wood for the
118trees for some time, we get a cup of coffee and try another approach. That
7218dffe 119is, we bring in the cavalry by giving perl the 'B<-d>' switch on the command
10862624
RF
120line:
121
122 > perl -d data
123 Default die handler restored.
124
125 Loading DB routines from perl5db.pl version 1.07
126 Editor support available.
127
128 Enter h or `h h' for help, or `man perldebug' for more help.
129
130 main::(./data:4): my $key = 'welcome';
131
132Now, what we've done here is to launch the built-in perl debugger on our
133script. It's stopped at the first line of executable code and is waiting for
134input.
135
136Before we go any further, you'll want to know how to quit the debugger: use
7218dffe 137just the letter 'B<q>', not the words 'quit' or 'exit':
10862624
RF
138
139 DB<1> q
140 >
cea6626f 141
10862624
RF
142That's it, you're back on home turf again.
143
7218dffe
JH
144
145=head1 help
146
10862624 147Fire the debugger up again on your script and we'll look at the help menu.
492652be
RF
148There's a couple of ways of calling help: a simple 'B<h>' will get the summary
149help list, 'B<|h>' (pipe-h) will pipe the help through your pager (which is
150(probably 'more' or 'less'), and finally, 'B<h h>' (h-space-h) will give you
151the entire help screen. Here is the summary page:
152
153DB<1>h
6a8e4891
EM
154
155 List/search source lines: Control script execution:
492652be
RF
156 l [ln|sub] List source code T Stack trace
157 - or . List previous/current line s [expr] Single step [in expr]
158 v [line] View around line n [expr] Next, steps over subs
159 f filename View source in file <CR/Enter> Repeat last n or s
160 /pattern/ ?patt? Search forw/backw r Return from subroutine
161 M Show module versions c [ln|sub] Continue until position
947cb114 162 Debugger controls: L List break/watch/actions
492652be
RF
163 o [...] Set debugger options t [expr] Toggle trace [trace expr]
164 <[<]|{[{]|>[>] [cmd] Do pre/post-prompt b [ln|event|sub] [cnd] Set breakpoint
165 ! [N|pat] Redo a previous command B ln|* Delete a/all breakpoints
166 H [-num] Display last num commands a [ln] cmd Do cmd before line
167 = [a val] Define/list an alias A ln|* Delete a/all actions
168 h [db_cmd] Get help on command w expr Add a watch expression
947cb114 169 h h Complete help page W expr|* Delete a/all watch exprs
492652be
RF
170 |[|]db_cmd Send output to pager ![!] syscmd Run cmd in a subprocess
171 q or ^D Quit R Attempt a restart
6a8e4891 172 Data Examination: expr Execute perl code, also see: s,n,t expr
492652be
RF
173 x|m expr Evals expr in list context, dumps the result or lists methods.
174 p expr Print expression (uses script's current package).
175 S [[!]pat] List subroutine names [not] matching pattern
176 V [Pk [Vars]] List Variables in Package. Vars can be ~pattern or !pattern.
177 X [Vars] Same as "V current_package [Vars]".
947cb114 178 y [n [Vars]] List lexicals in higher scope <n>. Vars same as V.
6a8e4891 179 For more help, type h cmd_letter, or run man perldebug for all docs.
cea6626f 180
10862624
RF
181More confusing options than you can shake a big stick at! It's not as bad as
182it looks and it's very useful to know more about all of it, and fun too!
183
7218dffe 184There's a couple of useful ones to know about straight away. You wouldn't
492652be
RF
185think we're using any libraries at all at the moment, but 'B<M>' will show
186which modules are currently loaded, and their version number, while 'B<m>'
187will show the methods, and 'B<S>' shows all subroutines (by pattern) as
188shown below. 'B<V>' and 'B<X>' show variables in the program by package
189scope and can be constrained by pattern.
10862624
RF
190
191 DB<2>S str
192 dumpvar::stringify
193 strict::bits
194 strict::import
195 strict::unimport
7218dffe
JH
196
197Using 'X' and cousins requires you not to use the type identifiers ($@%), just
198the 'name':
199
200 DM<3>X ~err
201 FileHandle(stderr) => fileno(2)
cea6626f 202
7218dffe 203Remember we're in our tiny program with a problem, we should have a look at
492652be
RF
204where we are, and what our data looks like. First of all let's view some code
205at our present position (the first line of code in this case), via 'B<v>':
10862624 206
492652be 207 DB<4> v
10862624
RF
208 1 #!/usr/bin/perl
209 2: use strict;
210 3
211 4==> my $key = 'welcome';
212 5: my %data = (
213 6 'this' => qw(that),
214 7 'tom' => qw(and jerry),
215 8 'welcome' => q(Hello World),
216 9 'zip' => q(welcome),
217 10 );
218
219At line number 4 is a helpful pointer, that tells you where you are now. To
492652be 220see more code, type 'v' again:
cea6626f 221
492652be 222 DB<4> v
10862624
RF
223 8 'welcome' => q(Hello World),
224 9 'zip' => q(welcome),
225 10 );
226 11: my @data = keys %data;
227 12: print "All OK\n" if grep($key, keys %data);
228 13: print "$data{$key}\n";
229 14: print "done: '$data{$key}'\n";
230 15: exit;
231
7218dffe 232And if you wanted to list line 5 again, type 'l 5', (note the space):
10862624
RF
233
234 DB<4> l 5
235 5: my %data = (
cea6626f 236
10862624 237In this case, there's not much to see, but of course normally there's pages of
7218dffe
JH
238stuff to wade through, and 'l' can be very useful. To reset your view to the
239line we're about to execute, type a lone period '.':
10862624 240
7218dffe 241 DB<5> .
10862624 242 main::(./data_a:4): my $key = 'welcome';
cea6626f 243
10862624 244The line shown is the one that is about to be executed B<next>, it hasn't
7218dffe
JH
245happened yet. So while we can print a variable with the letter 'B<p>', at
246this point all we'd get is an empty (undefined) value back. What we need to
247do is to step through the next executable statement with an 'B<s>':
cea6626f 248
10862624
RF
249 DB<6> s
250 main::(./data_a:5): my %data = (
251 main::(./data_a:6): 'this' => qw(that),
252 main::(./data_a:7): 'tom' => qw(and jerry),
253 main::(./data_a:8): 'welcome' => q(Hello World),
254 main::(./data_a:9): 'zip' => q(welcome),
255 main::(./data_a:10): );
256
257Now we can have a look at that first ($key) variable:
258
259 DB<7> p $key
260 welcome
261
262line 13 is where the action is, so let's continue down to there via the letter
7218dffe
JH
263'B<c>', which by the way, inserts a 'one-time-only' breakpoint at the given
264line or sub routine:
10862624
RF
265
266 DB<8> c 13
267 All OK
268 main::(./data_a:13): print "$data{$key}\n";
cea6626f 269
10862624
RF
270We've gone past our check (where 'All OK' was printed) and have stopped just
271before the meat of our task. We could try to print out a couple of variables
272to see what is happening:
273
274 DB<9> p $data{$key}
cea6626f 275
7218dffe 276Not much in there, lets have a look at our hash:
cea6626f 277
10862624
RF
278 DB<10> p %data
279 Hello Worldziptomandwelcomejerrywelcomethisthat
280
281 DB<11> p keys %data
282 Hello Worldtomwelcomejerrythis
cea6626f 283
7218dffe
JH
284Well, this isn't very easy to read, and using the helpful manual (B<h h>), the
285'B<x>' command looks promising:
10862624
RF
286
287 DB<12> x %data
288 0 'Hello World'
289 1 'zip'
290 2 'tom'
291 3 'and'
292 4 'welcome'
293 5 undef
294 6 'jerry'
295 7 'welcome'
296 8 'this'
297 9 'that'
298
b1866b2d 299That's not much help, a couple of welcomes in there, but no indication of
7218dffe 300which are keys, and which are values, it's just a listed array dump and, in
10862624
RF
301this case, not particularly helpful. The trick here, is to use a B<reference>
302to the data structure:
303
304 DB<13> x \%data
305 0 HASH(0x8194bc4)
306 'Hello World' => 'zip'
307 'jerry' => 'welcome'
308 'this' => 'that'
309 'tom' => 'and'
310 'welcome' => undef
311
312The reference is truly dumped and we can finally see what we're dealing with.
313Our quoting was perfectly valid but wrong for our purposes, with 'and jerry'
314being treated as 2 separate words rather than a phrase, thus throwing the
315evenly paired hash structure out of alignment.
316
7218dffe 317The 'B<-w>' switch would have told us about this, had we used it at the start,
10862624
RF
318and saved us a lot of trouble:
319
320 > perl -w data
321 Odd number of elements in hash assignment at ./data line 5.
322
323We fix our quoting: 'tom' => q(and jerry), and run it again, this time we get
324our expected output:
325
326 > perl -w data
327 Hello World
328
329
7218dffe 330While we're here, take a closer look at the 'B<x>' command, it's really useful
10862624 331and will merrily dump out nested references, complete objects, partial objects
a31a806a 332- just about whatever you throw at it:
10862624 333
da75cd15 334Let's make a quick object and x-plode it, first we'll start the debugger:
10862624
RF
335it wants some form of input from STDIN, so we give it something non-commital,
336a zero:
337
338 > perl -de 0
339 Default die handler restored.
340
341 Loading DB routines from perl5db.pl version 1.07
342 Editor support available.
343
344 Enter h or `h h' for help, or `man perldebug' for more help.
345
346 main::(-e:1): 0
347
348Now build an on-the-fly object over a couple of lines (note the backslash):
349
350 DB<1> $obj = bless({'unique_id'=>'123', 'attr'=> \
351 cont: {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
352
353And let's have a look at it:
cea6626f 354
10862624
RF
355 DB<2> x $obj
356 0 MY_class=HASH(0x828ad98)
357 'attr' => HASH(0x828ad68)
358 'col' => 'black'
359 'things' => ARRAY(0x828abb8)
360 0 'this'
361 1 'that'
362 2 'etc'
363 'unique_id' => 123
364 DB<3>
365
366Useful, huh? You can eval nearly anything in there, and experiment with bits
367of code or regexes until the cows come home:
368
369 DB<3> @data = qw(this that the other atheism leather theory scythe)
cea6626f 370
10862624
RF
371 DB<4> p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
372 atheism
373 leather
374 other
375 scythe
376 the
377 theory
378 saw -> 6
379
7218dffe 380If you want to see the command History, type an 'B<H>':
10862624
RF
381
382 DB<5> H
383 4: p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
384 3: @data = qw(this that the other atheism leather theory scythe)
385 2: x $obj
386 1: $obj = bless({'unique_id'=>'123', 'attr'=>
387 {'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
388 DB<5>
cea6626f 389
7218dffe 390And if you want to repeat any previous command, use the exclamation: 'B<!>':
10862624
RF
391
392 DB<5> !4
393 p 'saw -> '.($cnt += map { print "$_\n" } grep(/the/, sort @data))
394 atheism
395 leather
396 other
397 scythe
398 the
399 theory
400 saw -> 12
401
7218dffe
JH
402For more on references see L<perlref> and L<perlreftut>
403
10862624
RF
404
405=head1 Stepping through code
406
d1f7ad93 407Here's a simple program which converts between Celsius and Fahrenheit, it too
10862624
RF
408has a problem:
409
410 #!/usr/bin/perl -w
411 use strict;
412
413 my $arg = $ARGV[0] || '-c20';
414
415 if ($arg =~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
416 my ($deg, $num) = ($1, $2);
417 my ($in, $out) = ($num, $num);
418 if ($deg eq 'c') {
419 $deg = 'f';
420 $out = &c2f($num);
421 } else {
422 $deg = 'c';
423 $out = &f2c($num);
424 }
425 $out = sprintf('%0.2f', $out);
426 $out =~ s/^((\-|\+)*\d+)\.0+$/$1/;
427 print "$out $deg\n";
428 } else {
429 print "Usage: $0 -[c|f] num\n";
430 }
431 exit;
432
433 sub f2c {
434 my $f = shift;
435 my $c = 5 * $f - 32 / 9;
436 return $c;
437 }
438
439 sub c2f {
440 my $c = shift;
441 my $f = 9 * $c / 5 + 32;
442 return $f;
443 }
444
445
d1f7ad93 446For some reason, the Fahrenheit to Celsius conversion fails to return the
10862624
RF
447expected output. This is what it does:
448
449 > temp -c0.72
450 33.30 f
cea6626f 451
10862624
RF
452 > temp -f33.3
453 162.94 c
cea6626f 454
10862624
RF
455Not very consistent! We'll set a breakpoint in the code manually and run it
456under the debugger to see what's going on. A breakpoint is a flag, to which
a31a806a 457the debugger will run without interruption, when it reaches the breakpoint, it
10862624
RF
458will stop execution and offer a prompt for further interaction. In normal
459use, these debugger commands are completely ignored, and they are safe - if a
460little messy, to leave in production code.
cea6626f 461
10862624
RF
462 my ($in, $out) = ($num, $num);
463 $DB::single=2; # insert at line 9!
464 if ($deg eq 'c')
465 ...
cea6626f 466
10862624
RF
467 > perl -d temp -f33.3
468 Default die handler restored.
469
470 Loading DB routines from perl5db.pl version 1.07
471 Editor support available.
472
473 Enter h or `h h' for help, or `man perldebug' for more help.
474
475 main::(temp:4): my $arg = $ARGV[0] || '-c100';
476
7218dffe 477We'll simply continue down to our pre-set breakpoint with a 'B<c>':
10862624
RF
478
479 DB<1> c
480 main::(temp:10): if ($deg eq 'c') {
481
492652be 482Followed by a view command to see where we are:
cea6626f 483
492652be 484 DB<1> v
10862624
RF
485 7: my ($deg, $num) = ($1, $2);
486 8: my ($in, $out) = ($num, $num);
487 9: $DB::single=2;
488 10==> if ($deg eq 'c') {
489 11: $deg = 'f';
490 12: $out = &c2f($num);
491 13 } else {
492 14: $deg = 'c';
493 15: $out = &f2c($num);
494 16 }
495
496And a print to show what values we're currently using:
497
7218dffe 498 DB<1> p $deg, $num
10862624 499 f33.3
13a2d996 500
10862624
RF
501We can put another break point on any line beginning with a colon, we'll use
502line 17 as that's just as we come out of the subroutine, and we'd like to
503pause there later on:
cea6626f 504
7218dffe 505 DB<2> b 17
cea6626f 506
10862624
RF
507There's no feedback from this, but you can see what breakpoints are set by
508using the list 'L' command:
509
7218dffe 510 DB<3> L
10862624
RF
511 temp:
512 17: print "$out $deg\n";
513 break if (1)
514
515Note that to delete a breakpoint you use 'd' or 'D'.
516
517Now we'll continue down into our subroutine, this time rather than by line
492652be 518number, we'll use the subroutine name, followed by the now familiar 'v':
10862624 519
7218dffe 520 DB<3> c f2c
10862624
RF
521 main::f2c(temp:30): my $f = shift;
522
492652be 523 DB<4> v
7218dffe
JH
524 24: exit;
525 25
526 26 sub f2c {
527 27==> my $f = shift;
528 28: my $c = 5 * $f - 32 / 9;
529 29: return $c;
530 30 }
531 31
532 32 sub c2f {
533 33: my $c = shift;
534
535
536Note that if there was a subroutine call between us and line 29, and we wanted
537to B<single-step> through it, we could use the 'B<s>' command, and to step
538over it we would use 'B<n>' which would execute the sub, but not descend into
539it for inspection. In this case though, we simply continue down to line 29:
540
541 DB<4> c 29
542 main::f2c(temp:29): return $c;
13a2d996 543
10862624
RF
544And have a look at the return value:
545
7218dffe 546 DB<5> p $c
10862624
RF
547 162.944444444444
548
549This is not the right answer at all, but the sum looks correct. I wonder if
550it's anything to do with operator precedence? We'll try a couple of other
551possibilities with our sum:
552
7218dffe 553 DB<6> p (5 * $f - 32 / 9)
10862624 554 162.944444444444
cea6626f 555
7218dffe 556 DB<7> p 5 * $f - (32 / 9)
10862624 557 162.944444444444
cea6626f 558
7218dffe 559 DB<8> p (5 * $f) - 32 / 9
10862624 560 162.944444444444
cea6626f 561
7218dffe 562 DB<9> p 5 * ($f - 32) / 9
10862624
RF
563 0.722222222222221
564
565:-) that's more like it! Ok, now we can set our return variable and we'll
566return out of the sub with an 'r':
567
7218dffe 568 DB<10> $c = 5 * ($f - 32) / 9
cea6626f 569
7218dffe 570 DB<11> r
10862624 571 scalar context return from main::f2c: 0.722222222222221
cea6626f 572
10862624
RF
573Looks good, let's just continue off the end of the script:
574
7218dffe 575 DB<12> c
10862624
RF
576 0.72 c
577 Debugged program terminated. Use q to quit or R to restart,
578 use O inhibit_exit to avoid stopping after program termination,
579 h q, h R or h O to get additional info.
580
581A quick fix to the offending line (insert the missing parentheses) in the
582actual program and we're finished.
583
584
585=head1 Placeholder for a, w, t, T
586
7218dffe 587Actions, watch variables, stack traces etc.: on the TODO list.
10862624
RF
588
589 a
cea6626f 590
492652be 591 w
cea6626f 592
10862624 593 t
cea6626f 594
10862624
RF
595 T
596
597
7218dffe 598=head1 REGULAR EXPRESSIONS
10862624
RF
599
600Ever wanted to know what a regex looked like? You'll need perl compiled with
601the DEBUGGING flag for this one:
cea6626f 602
10862624
RF
603 > perl -Dr -e '/^pe(a)*rl$/i'
604 Compiling REx `^pe(a)*rl$'
605 size 17 first at 2
606 rarest char
607 at 0
608 1: BOL(2)
609 2: EXACTF <pe>(4)
610 4: CURLYN[1] {0,32767}(14)
611 6: NOTHING(8)
612 8: EXACTF <a>(0)
613 12: WHILEM(0)
614 13: NOTHING(14)
615 14: EXACTF <rl>(16)
616 16: EOL(17)
617 17: END(0)
618 floating `'$ at 4..2147483647 (checking floating) stclass `EXACTF <pe>'
619anchored(BOL) minlen 4
620 Omitting $` $& $' support.
13a2d996 621
10862624
RF
622 EXECUTING...
623
624 Freeing REx: `^pe(a)*rl$'
625
626Did you really want to know? :-)
7218dffe
JH
627For more gory details on getting regular expressions to work, have a look at
628L<perlre>, L<perlretut>, and to decode the mysterious labels (BOL and CURLYN,
629etc. above), see L<perldebguts>.
10862624
RF
630
631
7218dffe 632=head1 OUTPUT TIPS
10862624
RF
633
634To get all the output from your error log, and not miss any messages via
635helpful operating system buffering, insert a line like this, at the start of
636your script:
637
638 $|=1;
639
640To watch the tail of a dynamically growing logfile, (from the command line):
641
642 tail -f $error_log
643
644Wrapping all die calls in a handler routine can be useful to see how, and from
645where, they're being called, L<perlvar> has more information:
646
7218dffe 647 BEGIN { $SIG{__DIE__} = sub { require Carp; Carp::confess(@_) } }
10862624
RF
648
649Various useful techniques for the redirection of STDOUT and STDERR filehandles
7218dffe 650are explained in L<perlopentut> and L<perlfaq8>.
10862624
RF
651
652
653=head1 CGI
654
7218dffe
JH
655Just a quick hint here for all those CGI programmers who can't figure out how
656on earth to get past that 'waiting for input' prompt, when running their CGI
657script from the command-line, try something like this:
10862624
RF
658
659 > perl -d my_cgi.pl -nodebug
660
13a2d996 661Of course L<CGI> and L<perlfaq9> will tell you more.
10862624
RF
662
663
664=head1 GUIs
665
666The command line interface is tightly integrated with an B<emacs> extension
667and there's a B<vi> interface too.
668
669You don't have to do this all on the command line, though, there are a few GUI
670options out there. The nice thing about these is you can wave a mouse over a
3958b146 671variable and a dump of its data will appear in an appropriate window, or in a
10862624
RF
672popup balloon, no more tiresome typing of 'x $varname' :-)
673
674In particular have a hunt around for the following:
675
676B<ptkdb> perlTK based wrapper for the built-in debugger
677
678B<ddd> data display debugger
cea6626f 679
10862624
RF
680B<PerlDevKit> and B<PerlBuilder> are NT specific
681
682NB. (more info on these and others would be appreciated).
683
684
7218dffe 685=head1 SUMMARY
10862624
RF
686
687We've seen how to encourage good coding practices with B<use strict> and
688B<-w>. We can run the perl debugger B<perl -d scriptname> to inspect your
689data from within the perl debugger with the B<p> and B<x> commands. You can
690walk through your code, set breakpoints with B<b> and step through that code
691with B<s> or B<n>, continue with B<c> and return from a sub with B<r>. Fairly
692intuitive stuff when you get down to it.
693
694There is of course lots more to find out about, this has just scratched the
695surface. The best way to learn more is to use perldoc to find out more about
696the language, to read the on-line help (L<perldebug> is probably the next
697place to go), and of course, experiment.
698
699
700=head1 SEE ALSO
701
702L<perldebug>,
703L<perldebguts>,
704L<perldiag>,
705L<dprofpp>,
706L<perlrun>
707
708
709=head1 AUTHOR
710
711Richard Foley <richard@rfi.net> Copyright (c) 2000
712
713
714=head1 CONTRIBUTORS
715
716Various people have made helpful suggestions and contributions, in particular:
717
718Ronald J Kimball <rjk@linguist.dartmouth.edu>
719
7218dffe
JH
720Hugo van der Sanden <hv@crypt0.demon.co.uk>
721
10c10266 722Peter Scott <Peter@PSDT.com>
10862624 723