perldebug.pod

MSYS在windows下模拟了一个类unix的终端

possible.

=item C<ReadLine>

If false, readline support in the debugger is disabled in order
to debug applications that themselves use ReadLine.

=item C<NonStop>

If set, the debugger goes into non-interactive mode until interrupted, or
programmatically by setting $DB::signal or $DB::single.

=back

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

    $ PERLDB_OPTS="NonStop frame=2" perl -d myprogram

That will run the script B<myprogram> without human intervention,
printing out the call tree with entry and exit points.  Note that
C<NonStop=1 frame=2> is equivalent to C<N f=2>, and that originally,
options could be uniquely abbreviated by the first letter (modulo
the C<Dump*> options).  It is nevertheless recommended that you
always spell them out in full for legibility and future compatibility.

Other examples include

    $ PERLDB_OPTS="NonStop frame=2" perl -d myprogram

which runs script non-interactively, printing info on each entry
into a subroutine and each executed line into the file named F<listing>.
(If you interrupt it, you would better reset C<LineInfo> to something
"interactive"!)

Other examples include (using standard shell syntax to show environment
variable settings):

  $ ( PERLDB_OPTS="NonStop frame=1 AutoTrace LineInfo=tperl.out"
      perl -d myprogram )

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

  $ sleep 1000000

See L<perldebguts/"Debugger Internals"> for details.

=head2 Debugger input/output

=over 8

=item Prompt

The debugger prompt is something like

    DB<8>

or even

    DB<<17>>

where that number is the command number, and which you'd use to
access with the built-in B<csh>-like history mechanism.  For example,
C<!17> would repeat command number 17.  The depth of the angle
brackets indicates the nesting 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 the result of a function call that
itself has a breakpoint, or you step into an expression via C<s/n/t
expression> command.

=item Multiline commands

If you want to enter a multi-line command, such as a subroutine
definition with several statements or a format, 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.

=item Stack backtrace

Here's an example of what a stack backtrace via C<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 indicates the context in which the
function was called, with C<$> and C<@> meaning scalar or list
contexts respectively, and C<.> meaning void context (which is
actually a sort of scalar context).  The display above says
that you were in the function C<main::infested> when you ran the
stack dump, and that it was called in scalar context from line
10 of the file I<Ambulation.pm>, but without any arguments at all,
meaning it was called as C<&infested>.  The next stack frame shows
that the function C<Ambulation::legs> was called in list context
from the I<camel_flea> file with four arguments.  The last stack
frame shows that C<main::pests> was called in scalar context,
also from I<camel_flea>, but from line 4.

If you execute the C<T> command from inside an active C<use>
statement, the backtrace will contain both a C<require> frame and
an C<eval>) frame.

=item Line Listing Format

This shows the sorts of output the C<l> command can produce:

    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);

Breakable lines are marked with C<:>.  Lines with breakpoints are
marked by C<b> and those with actions by C<a>.  The line that's
about to be executed is marked by C<< ==> >>.

Please be aware that code in debugger listings may not look the same
as your original source code.  Line directives and external source
filters can alter the code before Perl sees it, causing code to move
from its original positions or take on entirely different forms.

=item Frame listing

When the C<frame> option is set, the debugger would print entered (and
optionally exited) subroutines in different styles.  See L<perldebguts>
for incredibly long examples of these.

=back

=head2 Debugging compile-time statements

If you have compile-time executable statements (such as code within
BEGIN and CHECK blocks or C<use> statements), these will I<not> be
stopped by debugger, although C<require>s and INIT blocks will, and
compile-time statements can be traced with C<AutoTrace> option set
in C<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 C<$DB::single> to 2, it's equivalent to having
just typed the C<n> command, whereas a value of 1 means the C<s>
command.  The C<$DB::trace>  variable should be set to 1 to simulate
having typed the C<t> command.

Another way to debug compile-time code is to start the debugger, set a
breakpoint on the I<load> of some module:

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

and then restart the debugger using the C<R> command (if possible).  One can use C<b
compile subname> for the same purpose.

=head2 Debugger Customization

The debugger probably contains enough configuration hooks that you
won't ever have to modify it yourself.  You may change the behaviour
of debugger from within the debugger using its C<O> command, from
the command line via the C<PERLDB_OPTS> environment variable, and
from customization files.

You can do some customization by setting up a F<.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/';

You can change options from F<.perldb> by using calls like this one;

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

The code is executed in the package C<DB>.  Note that F<.perldb> is
processed before processing C<PERLDB_OPTS>.  If F<.perldb> defines the
subroutine C<afterinit>, that function is called after debugger
initialization ends.  F<.perldb> may be contained in the current
directory, or in the home directory.  Because this file is sourced
in by Perl and may contain arbitrary commands, for security reasons,
it must be owned by the superuser or the current user, and writable
by no one but its owner.

If you want to modify the debugger, copy F<perl5db.pl> from the
Perl library to another name and hack it to your heart's content.
You'll then want to set your C<PERL5DB> environment variable to say
something like this:

    BEGIN { require "myperl5db.pl" }

As a last resort, you could also use C<PERL5DB> to customize the debugger
by directly setting internal variables or calling debugger functions.

Note that any variables and functions that are not documented in
this document (or in L<perldebguts>) are considered for internal
use only, and as such are subject to change without notice.

=head2 Readline Support

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 I<readline>(3) provides.
Look for these in the F<modules/by-module/Term> directory on CPAN.
These do not support normal B<vi> command-line editing, however.

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

=head2 Editor Support for Debugging

If you have the FSF's version of B<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 comes with a start file for making B<emacs> act like a
syntax-directed editor that understands (some of) Perl's syntax.
Look in the I<emacs> directory of the Perl source distribution.

A similar setup by Tom Christiansen for interacting with any
vendor-shipped B<vi> and the X11 window system is also available.
This works similarly to the integrated multiwindow support that
B<emacs> provides, where the debugger drives the editor.  At the
time of this writing, however, that tool's eventual location in the
Perl distribution was uncertain.

Users of B<vi> should also look into B<vim> and B<gvim>, the mousey
and windy version, for coloring of Perl keywords.  

Note that only perl can truly parse Perl, so all such CASE tools
fall somewhat short of the mark, especially if you don't program
your Perl as a C programmer might.

=head2 The Perl Profiler

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
B<-d> flag.  The most popular alternative debuggers for Perl is the
Perl profiler.  Devel::DProf is now included with the standard Perl
distribution.  To profile your Perl program in the file F<mycode.pl>,
just type:

    $ perl -d:DProf mycode.pl

When the script terminates the profiler will dump the profile
information to a file called F<tmon.out>.  A tool like B<dprofpp>,
also supplied with the standard Perl distribution, can be used to
interpret the information in that profile.

=head1 Debugging regular expressions

C<use re 'debug'> enables you to see the gory details of how the
Perl regular expression engine works.  In order to understand this
typically voluminous output, one must not only have some idea about
about how regular expression matching works in general, but also
know how Perl's regular expressions are internally compiled into
an automaton.  These matters are explored in some detail in
L<perldebguts/"Debugging regular expressions">.

=head1 Debugging memory usage

Perl contains internal support for reporting its own memory usage,
but this is a fairly advanced concept that requires some understanding
of how memory allocation works.
See L<perldebguts/"Debugging Perl memory usage"> for the details.

=head1 SEE ALSO

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

L<perldebguts>,
L<re>,
L<DB>,
L<Devel::Dprof>,
L<dprofpp>,
L<Dumpvalue>,
and
L<perlrun>.

=head1 BUGS

You cannot get stack frame information or in any fashion debug functions
that were not compiled by Perl, such as those from C or C++ extensions.

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

The debugger does not currently work in conjunction with the B<-W>
command-line switch, because it itself is not free of warnings.

If you're in a slow syscall (like C<wait>ing, C<accept>ing, or C<read>ing
from your keyboard or a socket) and haven't set up your own C<$SIG{INT}>
handler, then you won't be able to CTRL-C your way back to the debugger,
because the debugger's own C<$SIG{INT}> handler doesn't understand that
it needs to raise an exception to longjmp(3) out of slow syscalls.