projects / p5sagit/p5-mst-13.2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
perl 5.003_01: lib/overload.pm
[p5sagit/p5-mst-13.2.git] / lib / perl5db.pl
CommitLineData
a687059c 1package DB;
2
54d04a52 3# Debugger for Perl 5.00x; perl5db.pl patch level:
d338d6fe 4
54d04a52 5$header = 'perl5db.pl patch level 0.94';
d338d6fe 6
7# Enhanced by ilya@math.ohio-state.edu (Ilya Zakharevich)
8# Latest version available: ftp://ftp.math.ohio-state.edu/pub/users/ilya/perl
9
10# modified Perl debugger, to be run from Emacs in perldb-mode
11# Ray Lischner (uunet!mntgfx!lisch) as of 5 Nov 1990
12# Johan Vromans -- upgrade to 4.0 pl 10
13# Ilya Zakharevich -- patches after 5.001 (and some before ;-)
14
15#
16# This file is automatically included if you do perl -d.
17# It's probably not useful to include this yourself.
18#
19# Perl supplies the values for @line and %sub. It effectively inserts
20# a &DB'DB(<linenum>); in front of every place that can have a
21# breakpoint. Instead of a subroutine call it calls &DB::sub with
22# $DB::sub being the called subroutine. It also inserts a BEGIN
23# {require 'perl5db.pl'} before the first line.
24#
25# Note that no subroutine call is possible until &DB::sub is defined
26# (for subroutines defined outside this file). In fact the same is
27# true if $deep is not defined.
28#
29# $Log: perldb.pl,v $
30
31#
32# At start reads $rcfile that may set important options. This file
33# may define a subroutine &afterinit that will be executed after the
34# debugger is initialized.
35#
36# After $rcfile is read reads environment variable PERLDB_OPTS and parses
37# it as a rest of `O ...' line in debugger prompt.
38#
39# The options that can be specified only at startup:
40# [To set in $rcfile, call &parse_options("optionName=new_value").]
41#
42# TTY - the TTY to use for debugging i/o.
43#
44# noTTY - if set, goes in NonStop mode. On interrupt if TTY is not set
45# uses the value of noTTY or "/tmp/perldbtty$$" to find TTY using
46# Term::Rendezvous. Current variant is to have the name of TTY in this
47# file.
48#
49# ReadLine - If false, dummy ReadLine is used, so you can debug
50# ReadLine applications.
51#
52# NonStop - if true, no i/o is performed until interrupt.
53#
54# LineInfo - file or pipe to print line number info to. If it is a
55# pipe, a short "emacs like" message is used.
56#
57# Example $rcfile: (delete leading hashes!)
58#
59# &parse_options("NonStop=1 LineInfo=db.out");
60# sub afterinit { $trace = 1; }
61#
62# The script will run without human intervention, putting trace
63# information into db.out. (If you interrupt it, you would better
64# reset LineInfo to something "interactive"!)
65#
66
54d04a52 67# Needed for the statement after exec():
d338d6fe 68
54d04a52 69BEGIN { $ini_warn = $^W; $^W = 0 } # Switch compilation warnings off until another BEGIN.
70local($^W) = 0; # Switch run-time warnings off during init.
d338d6fe 71warn ( # Do not ;-)
72 $dumpvar::hashDepth,
73 $dumpvar::arrayDepth,
74 $dumpvar::dumpDBFiles,
75 $dumpvar::dumpPackages,
76 $dumpvar::quoteHighBit,
77 $dumpvar::printUndef,
78 $dumpvar::globPrint,
79 $readline::Tk_toloop,
80 $dumpvar::usageOnly,
81 @ARGS,
82 $Carp::CarpLevel,
54d04a52 83 $panic,
84 $first_time,
d338d6fe 85 ) if 0;
86
54d04a52 87# Command-line + PERLLIB:
88@ini_INC = @INC;
89
d338d6fe 90# $prevwarn = $prevdie = $prevbus = $prevsegv = ''; # Does not help?!
91
92$trace = $signal = $single = 0; # Uninitialized warning suppression
93 # (local $^W cannot help - other packages!).
94@stack = (0);
95
96$option{PrintRet} = 1;
97
98@options = qw(hashDepth arrayDepth DumpDBFiles DumpPackages
99 compactDump veryCompact quote HighBit undefPrint
100 globPrint PrintRet UsageOnly frame
101 TTY noTTY ReadLine NonStop LineInfo
102 recallCommand ShellBang pager tkRunning
103 signalLevel warnLevel dieLevel);
104
105%optionVars = (
106 hashDepth => \$dumpvar::hashDepth,
107 arrayDepth => \$dumpvar::arrayDepth,
108 DumpDBFiles => \$dumpvar::dumpDBFiles,
109 DumpPackages => \$dumpvar::dumpPackages,
110 HighBit => \$dumpvar::quoteHighBit,
111 undefPrint => \$dumpvar::printUndef,
112 globPrint => \$dumpvar::globPrint,
113 tkRunning => \$readline::Tk_toloop,
114 UsageOnly => \$dumpvar::usageOnly,
115 frame => \$frame,
116);
117
118%optionAction = (
119 compactDump => \&dumpvar::compactDump,
120 veryCompact => \&dumpvar::veryCompact,
121 quote => \&dumpvar::quote,
122 TTY => \&TTY,
123 noTTY => \&noTTY,
124 ReadLine => \&ReadLine,
125 NonStop => \&NonStop,
126 LineInfo => \&LineInfo,
127 recallCommand => \&recallCommand,
128 ShellBang => \&shellBang,
129 pager => \&pager,
130 signalLevel => \&signalLevel,
131 warnLevel => \&warnLevel,
132 dieLevel => \&dieLevel,
133 );
134
135%optionRequire = (
136 compactDump => 'dumpvar.pl',
137 veryCompact => 'dumpvar.pl',
138 quote => 'dumpvar.pl',
139 );
140
141# These guys may be defined in $ENV{PERL5DB} :
142$rl = 1 unless defined $rl;
143warnLevel($warnLevel);
144dieLevel($dieLevel);
145signalLevel($signalLevel);
146&pager(defined($ENV{PAGER}) ? $ENV{PAGER} : "|more") unless defined $pager;
147&recallCommand("!") unless defined $prc;
148&shellBang("!") unless defined $psh;
149
150if (-e "/dev/tty") {
151 $rcfile=".perldb";
152} else {
153 $rcfile="perldb.ini";
154}
155
156if (-f $rcfile) {
157 do "./$rcfile";
158} elsif (defined $ENV{LOGDIR} and -f "$ENV{LOGDIR}/$rcfile") {
159 do "$ENV{LOGDIR}/$rcfile";
160} elsif (defined $ENV{HOME} and -f "$ENV{HOME}/$rcfile") {
161 do "$ENV{HOME}/$rcfile";
162}
163
164if (defined $ENV{PERLDB_OPTS}) {
165 parse_options($ENV{PERLDB_OPTS});
166}
167
54d04a52 168if (exists $ENV{PERLDB_RESTART}) {
169 delete $ENV{PERLDB_RESTART};
170 # $restart = 1;
171 @hist = get_list('PERLDB_HIST');
172 my @visited = get_list("PERLDB_VISITED");
173 for (0 .. $#visited) {
174 %{$postponed{$visited[$_]}} = get_list("PERLDB_FILE_$_");
175 }
176 my %opt = get_list("PERLDB_OPT");
177 my ($opt,$val);
178 while (($opt,$val) = each %opt) {
179 $val =~ s/[\\\']/\\$1/g;
180 parse_options("$opt'$val'");
181 }
182 @INC = get_list("PERLDB_INC");
183 @ini_INC = @INC;
184}
185
d338d6fe 186if ($notty) {
187 $runnonstop = 1;
188} else {
189 # Is Perl being run from Emacs?
190 $emacs = ((defined $main::ARGV[0]) and ($main::ARGV[0] eq '-emacs'));
191 $rl = 0, shift(@main::ARGV) if $emacs;
192
193 #require Term::ReadLine;
194
195 if (-e "/dev/tty") {
196 $console = "/dev/tty";
197 } elsif (-e "con") {
198 $console = "con";
199 } else {
200 $console = "sys\$command";
201 }
202
203 # Around a bug:
204 if (defined $ENV{OS2_SHELL} and $emacs) { # In OS/2
205 $console = undef;
206 }
207
208 $console = $tty if defined $tty;
209
210 if (defined $console) {
211 open(IN,"+<$console") || open(IN,"<$console") || open(IN,"<&STDIN");
212 open(OUT,"+>$console") || open(OUT,">$console") || open(OUT,">&STDERR")
213 || open(OUT,">&STDOUT"); # so we don't dongle stdout
214 } else {
215 open(IN,"<&STDIN");
216 open(OUT,">&STDERR") || open(OUT,">&STDOUT"); # so we don't dongle stdout
217 $console = 'STDIN/OUT';
218 }
219 # so open("|more") can read from STDOUT and so we don't dingle stdin
220 $IN = \*IN;
221
222 $OUT = \*OUT;
223 select($OUT);
224 $| = 1; # for DB::OUT
225 select(STDOUT);
226
227 $LINEINFO = $OUT unless defined $LINEINFO;
228 $lineinfo = $console unless defined $lineinfo;
229
230 $| = 1; # for real STDOUT
231
232 $header =~ s/.Header: ([^,]+),v(\s+\S+\s+\S+).*$/$1$2/;
233 unless ($runnonstop) {
234 print $OUT "\nLoading DB routines from $header\n";
235 print $OUT ("Emacs support ",
236 $emacs ? "enabled" : "available",
237 ".\n");
238 print $OUT "\nEnter h or `h h' for help.\n\n";
239 }
240}
241
242@ARGS = @ARGV;
243for (@args) {
244 s/\'/\\\'/g;
245 s/(.*)/'$1'/ unless /^-?[\d.]+$/;
246}
247
248if (defined &afterinit) { # May be defined in $rcfile
249 &afterinit();
250}
251
252############################################################ Subroutines
253
d338d6fe 254sub DB {
54d04a52 255 unless ($first_time++) { # Do when-running init
256 if ($runnonstop) { # Disable until signal
d338d6fe 257 for ($i=0; $i <= $#stack; ) {
258 $stack[$i++] &= ~1;
259 }
54d04a52 260 $single = 0;
d338d6fe 261 return;
54d04a52 262 }
263 # Define a subroutine in which we will stop
264# eval <<'EOE';
265# sub at_end::db {"Debuggee terminating";}
266# END {
267# $DB::step = 1;
268# print $OUT "Debuggee terminating.\n";
269# &at_end::db;}
270# EOE
d338d6fe 271 }
272 &save;
273 if ($doret) {
274 $doret = 0;
275 if ($option{PrintRet}) {
276 print $OUT "$retctx context return from $lastsub:",
277 ($retctx eq 'list') ? "\n" : " " ;
278 dumpit( ($retctx eq 'list') ? \@ret : $ret );
279 }
280 }
281 ($package, $filename, $line) = caller;
54d04a52 282 $filename_ini = $filename;
d338d6fe 283 $usercontext = '($@, $!, $,, $/, $\, $^W) = @saved;' .
284 "package $package;"; # this won't let them modify, alas
285 local(*dbline) = "::_<$filename";
54d04a52 286 install_breakpoints($filename) unless $visited{$filename}++;
d338d6fe 287 $max = $#dbline;
288 if (($stop,$action) = split(/\0/,$dbline{$line})) {
289 if ($stop eq '1') {
290 $signal |= 1;
54d04a52 291 } elsif ($stop) {
d338d6fe 292 $evalarg = "\$DB::signal |= do {$stop;}"; &eval;
293 $dbline{$line} =~ s/;9($|\0)/$1/;
294 }
295 }
296 if ($single || $trace || $signal) {
297 $term || &setterm;
298 if ($emacs) {
54d04a52 299 $position = "\032\032$filename:$line:0\n";
300 print $LINEINFO $position;
d338d6fe 301 } else {
302 $sub =~ s/\'/::/;
303 $prefix = $sub =~ /::/ ? "" : "${'package'}::";
304 $prefix .= "$sub($filename:";
305 $after = ($dbline[$line] =~ /\n$/ ? '' : "\n");
306 if (length($prefix) > 30) {
54d04a52 307 $position = "$prefix$line):\n$line:\t$dbline[$line]$after";
308 print $LINEINFO $position;
d338d6fe 309 $prefix = "";
310 $infix = ":\t";
311 } else {
312 $infix = "):\t";
54d04a52 313 $position = "$prefix$line$infix$dbline[$line]$after";
314 print $LINEINFO $position;
d338d6fe 315 }
316 for ($i = $line + 1; $i <= $max && $dbline[$i] == 0; ++$i) { #{ vi
317 last if $dbline[$i] =~ /^\s*[\;\}\#\n]/;
318 $after = ($dbline[$i] =~ /\n$/ ? '' : "\n");
54d04a52 319 $incr_pos = "$prefix$i$infix$dbline[$i]$after";
320 print $LINEINFO $incr_pos;
321 $position .= $incr_pos;
d338d6fe 322 }
323 }
324 }
325 $evalarg = $action, &eval if $action;
326 if ($single || $signal) {
327 local $level = $level + 1;
328 $evalarg = $pre, &eval if $pre;
329 print $OUT $#stack . " levels deep in subroutine calls!\n"
330 if $single & 4;
331 $start = $line;
332 CMD:
333 while (($term || &setterm),
54d04a52 334 defined ($cmd=&readline(" DB" . ('<' x $level) .
335 ($#hist+1) . ('>' x $level) .
336 " "))) {
337 #{ # <-- Do we know what this brace is for?
d338d6fe 338 $single = 0;
339 $signal = 0;
340 $cmd =~ s/\\$/\n/ && do {
54d04a52 341 $cmd .= &readline(" cont: ");
d338d6fe 342 redo CMD;
343 };
344 $cmd =~ /^q$/ && exit 0;
345 $cmd =~ /^$/ && ($cmd = $laststep);
346 push(@hist,$cmd) if length($cmd) > 1;
347 PIPE: {
348 ($i) = split(/\s+/,$cmd);
349 eval "\$cmd =~ $alias{$i}", print $OUT $@ if $alias{$i};
350 $cmd =~ /^h$/ && do {
351 print $OUT $help;
352 next CMD; };
353 $cmd =~ /^h\s+h$/ && do {
354 print $OUT $summary;
355 next CMD; };
356 $cmd =~ /^h\s+(\S)$/ && do {
357 my $asked = "\Q$1";
358 if ($help =~ /^($asked([\s\S]*?)\n)(\Z|[^\s$asked])/m) {
359 print $OUT $1;
360 } else {
361 print $OUT "`$asked' is not a debugger command.\n";
362 }
363 next CMD; };
364 $cmd =~ /^t$/ && do {
365 $trace = !$trace;
366 print $OUT "Trace = ".($trace?"on":"off")."\n";
367 next CMD; };
368 $cmd =~ /^S(\s+(!)?(.+))?$/ && do {
369 $Srev = defined $2; $Spatt = $3; $Snocheck = ! defined $1;
370 foreach $subname (sort(keys %sub)) {
371 if ($Snocheck or $Srev^($subname =~ /$Spatt/)) {
372 print $OUT $subname,"\n";
373 }
374 }
375 next CMD; };
376 $cmd =~ s/^X\b/V $package/;
377 $cmd =~ /^V$/ && do {
378 $cmd = "V $package"; };
379 $cmd =~ /^V\b\s*(\S+)\s*(.*)/ && do {
380 local ($savout) = select($OUT);
381 $packname = $1;
382 @vars = split(' ',$2);
383 do 'dumpvar.pl' unless defined &main::dumpvar;
384 if (defined &main::dumpvar) {
54d04a52 385 local $frame = 0;
d338d6fe 386 &main::dumpvar($packname,@vars);
387 } else {
388 print $OUT "dumpvar.pl not available.\n";
389 }
390 select ($savout);
391 next CMD; };
392 $cmd =~ s/^x\b/ / && do { # So that will be evaled
393 $onetimeDump = 1; };
394 $cmd =~ /^f\b\s*(.*)/ && do {
395 $file = $1;
396 if (!$file) {
397 print $OUT "The old f command is now the r command.\n";
398 print $OUT "The new f command switches filenames.\n";
399 next CMD;
400 }
401 if (!defined $main::{'_<' . $file}) {
402 if (($try) = grep(m#^_<.*$file#, keys %main::)) {{
403 $file = substr($try,2);
404 print "\n$file:\n";
405 }}
406 }
407 if (!defined $main::{'_<' . $file}) {
408 print $OUT "There's no code here matching $file.\n";
409 next CMD;
410 } elsif ($file ne $filename) {
411 *dbline = "::_<$file";
54d04a52 412 $visited{$file}++;
d338d6fe 413 $max = $#dbline;
414 $filename = $file;
415 $start = 1;
416 $cmd = "l";
417 } };
418 $cmd =~ /^l\b\s*([\':A-Za-z_][\':\w]*)/ && do {
419 $subname = $1;
420 $subname =~ s/\'/::/;
421 $subname = "main::".$subname unless $subname =~ /::/;
422 $subname = "main".$subname if substr($subname,0,2) eq "::";
423 @pieces = split(/:/,$sub{$subname});
424 $subrange = pop @pieces;
425 $file = join(':', @pieces);
426 if ($file ne $filename) {
427 *dbline = "::_<$file";
54d04a52 428 $visited{$file}++;
d338d6fe 429 $max = $#dbline;
430 $filename = $file;
431 }
432 if ($subrange) {
433 if (eval($subrange) < -$window) {
434 $subrange =~ s/-.*/+/;
435 }
436 $cmd = "l $subrange";
437 } else {
438 print $OUT "Subroutine $subname not found.\n";
439 next CMD;
440 } };
54d04a52 441 $cmd =~ /^\.$/ && do {
442 $start = $line;
443 $filename = $filename_ini;
444 *dbline = "::_<$filename";
445 $max = $#dbline;
446 print $LINEINFO $position;
447 next CMD };
d338d6fe 448 $cmd =~ /^w\b\s*(\d*)$/ && do {
449 $incr = $window - 1;
450 $start = $1 if $1;
451 $start -= $preview;
54d04a52 452 #print $OUT 'l ' . $start . '-' . ($start + $incr);
d338d6fe 453 $cmd = 'l ' . $start . '-' . ($start + $incr); };
454 $cmd =~ /^-$/ && do {
455 $incr = $window - 1;
456 $cmd = 'l ' . ($start-$window*2) . '+'; };
457 $cmd =~ /^l$/ && do {
458 $incr = $window - 1;
459 $cmd = 'l ' . $start . '-' . ($start + $incr); };
460 $cmd =~ /^l\b\s*(\d*)\+(\d*)$/ && do {
461 $start = $1 if $1;
462 $incr = $2;
463 $incr = $window - 1 unless $incr;
464 $cmd = 'l ' . $start . '-' . ($start + $incr); };
54d04a52 465 $cmd =~ /^l\b\s*((-?[\d\$\.]+)([-,]([\d\$\.]+))?)?/ && do {
466 $end = (!defined $2) ? $max : ($4 ? $4 : $2);
d338d6fe 467 $end = $max if $end > $max;
468 $i = $2;
469 $i = $line if $i eq '.';
470 $i = 1 if $i < 1;
471 if ($emacs) {
472 print $OUT "\032\032$filename:$i:0\n";
473 $i = $end;
474 } else {
475 for (; $i <= $end; $i++) {
54d04a52 476 ($stop,$action) = split(/\0/, $dbline{$i});
477 $arrow = ($i==$line
478 and $filename eq $filename_ini)
479 ? '==>'
480 : ':' ;
481 $arrow .= 'b' if $stop;
482 $arrow .= 'a' if $action;
483 print $OUT "$i$arrow\t", $dbline[$i];
d338d6fe 484 last if $signal;
485 }
486 }
487 $start = $i; # remember in case they want more
488 $start = $max if $start > $max;
489 next CMD; };
490 $cmd =~ /^D$/ && do {
491 print $OUT "Deleting all breakpoints...\n";
492 for ($i = 1; $i <= $max ; $i++) {
493 if (defined $dbline{$i}) {
494 $dbline{$i} =~ s/^[^\0]+//;
495 if ($dbline{$i} =~ s/^\0?$//) {
496 delete $dbline{$i};
497 }
498 }
499 }
500 next CMD; };
501 $cmd =~ /^L$/ && do {
502 for ($i = 1; $i <= $max; $i++) {
503 if (defined $dbline{$i}) {
504 print $OUT "$i:\t", $dbline[$i];
505 ($stop,$action) = split(/\0/, $dbline{$i});
506 print $OUT " break if (", $stop, ")\n"
507 if $stop;
508 print $OUT " action: ", $action, "\n"
509 if $action;
510 last if $signal;
511 }
512 }
513 next CMD; };
514 $cmd =~ /^b\b\s*([':A-Za-z_][':\w]*)\s*(.*)/ && do {
515 $subname = $1;
516 $cond = $2 || '1';
517 $subname =~ s/\'/::/;
518 $subname = "${'package'}::" . $subname
519 unless $subname =~ /::/;
520 $subname = "main".$subname if substr($subname,0,2) eq "::";
521 # Filename below can contain ':'
522 ($file,$i) = ($sub{$subname} =~ /^(.*):(.*)$/);
523 $i += 0;
524 if ($i) {
525 $filename = $file;
526 *dbline = "::_<$filename";
54d04a52 527 $visited{$filename}++;
d338d6fe 528 $max = $#dbline;
529 ++$i while $dbline[$i] == 0 && $i < $max;
530 $dbline{$i} =~ s/^[^\0]*/$cond/;
531 } else {
532 print $OUT "Subroutine $subname not found.\n";
533 }
534 next CMD; };
535 $cmd =~ /^b\b\s*(\d*)\s*(.*)/ && do {
536 $i = ($1?$1:$line);
537 $cond = $2 || '1';
538 if ($dbline[$i] == 0) {
539 print $OUT "Line $i not breakable.\n";
540 } else {
541 $dbline{$i} =~ s/^[^\0]*/$cond/;
542 }
543 next CMD; };
544 $cmd =~ /^d\b\s*(\d+)?/ && do {
545 $i = ($1?$1:$line);
546 $dbline{$i} =~ s/^[^\0]*//;
547 delete $dbline{$i} if $dbline{$i} eq '';
548 next CMD; };
549 $cmd =~ /^A$/ && do {
550 for ($i = 1; $i <= $max ; $i++) {
551 if (defined $dbline{$i}) {
552 $dbline{$i} =~ s/\0[^\0]*//;
553 delete $dbline{$i} if $dbline{$i} eq '';
554 }
555 }
556 next CMD; };
557 $cmd =~ /^O\s*$/ && do {
558 for (@options) {
559 &dump_option($_);
560 }
561 next CMD; };
562 $cmd =~ /^O\s*(\S.*)/ && do {
563 parse_options($1);
564 next CMD; };
565 $cmd =~ /^<\s*(.*)/ && do {
566 $pre = action($1);
567 next CMD; };
568 $cmd =~ /^>\s*(.*)/ && do {
569 $post = action($1);
570 next CMD; };
571 $cmd =~ /^a\b\s*(\d+)(\s+(.*))?/ && do {
572 $i = $1; $j = $3;
573 if ($dbline[$i] == 0) {
574 print $OUT "Line $i may not have an action.\n";
575 } else {
576 $dbline{$i} =~ s/\0[^\0]*//;
577 $dbline{$i} .= "\0" . action($j);
578 }
579 next CMD; };
580 $cmd =~ /^n$/ && do {
581 $single = 2;
582 $laststep = $cmd;
583 last CMD; };
584 $cmd =~ /^s$/ && do {
585 $single = 1;
586 $laststep = $cmd;
587 last CMD; };
54d04a52 588 $cmd =~ /^c\b\s*([\w:]*)\s*$/ && do {
d338d6fe 589 $i = $1;
54d04a52 590 if ($i =~ /\D/) { # subroutine name
591 ($file,$i) = ($sub{$i} =~ /^(.*):(.*)$/);
592 $i += 0;
593 if ($i) {
594 $filename = $file;
595 *dbline = "::_<$filename";
596 $visited{$filename}++;
597 $max = $#dbline;
598 ++$i while $dbline[$i] == 0 && $i < $max;
599 } else {
600 print $OUT "Subroutine $subname not found.\n";
601 next CMD;
602 }
603 }
d338d6fe 604 if ($i) {
605 if ($dbline[$i] == 0) {
606 print $OUT "Line $i not breakable.\n";
607 next CMD;
608 }
609 $dbline{$i} =~ s/($|\0)/;9$1/; # add one-time-only b.p.
610 }
611 for ($i=0; $i <= $#stack; ) {
612 $stack[$i++] &= ~1;
613 }
614 last CMD; };
615 $cmd =~ /^r$/ && do {
616 $stack[$#stack] |= 1;
617 $doret = 1;
618 last CMD; };
54d04a52 619 $cmd =~ /^R$/ && do {
620 print $OUT "Warning: a lot of settings and command-line options may be lost!\n";
621 my (@script, @flags, $cl);
622 push @flags, '-w' if $ini_warn;
623 # Put all the old includes at the start to get
624 # the same debugger.
625 for (@ini_INC) {
626 push @flags, '-I', $_;
627 }
628 # Arrange for setting the old INC:
629 set_list("PERLDB_INC", @ini_INC);
630 if ($0 eq '-e') {
631 for (1..$#{'::_<-e'}) { # The first line is PERL5DB
632 chomp ($cl = $ {'::_<-e'}[$_]);
633 push @script, '-e', $cl;
634 }
635 } else {
636 @script = $0;
637 }
638 set_list("PERLDB_HIST",
639 $term->Features->{getHistory}
640 ? $term->GetHistory : @hist);
641 my @visited = keys %visited;
642 set_list("PERLDB_VISITED", @visited);
643 set_list("PERLDB_OPT", %option);
644 for (0 .. $#visited) {
645 *dbline = "::_<$visited[$_]";
646 set_list("PERLDB_FILE_$_", %dbline);
647 }
648 $ENV{PERLDB_RESTART} = 1;
649 #print "$^X, '-d', @flags, @script, ($emacs ? '-emacs' : ()), @ARGS";
650 exec $^X, '-d', @flags, @script, ($emacs ? '-emacs' : ()), @ARGS;
651 print $OUT "exec failed: $!\n";
652 last CMD; };
d338d6fe 653 $cmd =~ /^T$/ && do {
654 local($p,$f,$l,$s,$h,$a,$e,$r,@a,@sub);
655 for ($i = 1;
656 ($p,$f,$l,$s,$h,$w,$e,$r) = caller($i);
657 $i++) {
658 @a = ();
659 for $arg (@args) {
660 $_ = "$arg";
661 s/([\'\\])/\\$1/g;
662 s/([^\0]*)/'$1'/
663 unless /^(?: -?[\d.]+ | \*[\w:]* )$/x;
664 s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
665 s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
666 push(@a, $_);
667 }
668 $w = $w ? '@ = ' : '$ = ';
669 $a = $h ? '(' . join(', ', @a) . ')' : '';
670 $e =~ s/\n\s*\;\s*\Z// if $e;
671 $e =~ s/[\\\']/\\$1/g if $e;
672 if ($r) {
673 $s = "require '$e'";
674 } elsif (defined $r) {
675 $s = "eval '$e'";
676 } elsif ($s eq '(eval)') {
677 $s = "eval {...}";
678 }
679 $f = "file `$f'" unless $f eq '-e';
680 push(@sub, "$w$s$a called from $f line $l\n");
681 last if $signal;
682 }
683 for ($i=0; $i <= $#sub; $i++) {
684 last if $signal;
685 print $OUT $sub[$i];
686 }
687 next CMD; };
688 $cmd =~ /^\/(.*)$/ && do {
689 $inpat = $1;
690 $inpat =~ s:([^\\])/$:$1:;
691 if ($inpat ne "") {
692 eval '$inpat =~ m'."\a$inpat\a";
693 if ($@ ne "") {
694 print $OUT "$@";
695 next CMD;
696 }
697 $pat = $inpat;
698 }
699 $end = $start;
700 eval '
701 for (;;) {
702 ++$start;
703 $start = 1 if ($start > $max);
704 last if ($start == $end);
705 if ($dbline[$start] =~ m' . "\a$pat\a" . 'i) {
706 if ($emacs) {
707 print $OUT "\032\032$filename:$start:0\n";
708 } else {
709 print $OUT "$start:\t", $dbline[$start], "\n";
710 }
711 last;
712 }
713 } ';
714 print $OUT "/$pat/: not found\n" if ($start == $end);
715 next CMD; };
716 $cmd =~ /^\?(.*)$/ && do {
717 $inpat = $1;
718 $inpat =~ s:([^\\])\?$:$1:;
719 if ($inpat ne "") {
720 eval '$inpat =~ m'."\a$inpat\a";
721 if ($@ ne "") {
722 print $OUT "$@";
723 next CMD;
724 }
725 $pat = $inpat;
726 }
727 $end = $start;
728 eval '
729 for (;;) {
730 --$start;
731 $start = $max if ($start <= 0);
732 last if ($start == $end);
733 if ($dbline[$start] =~ m' . "\a$pat\a" . 'i) {
734 if ($emacs) {
735 print $OUT "\032\032$filename:$start:0\n";
736 } else {
737 print $OUT "$start:\t", $dbline[$start], "\n";
738 }
739 last;
740 }
741 } ';
742 print $OUT "?$pat?: not found\n" if ($start == $end);
743 next CMD; };
744 $cmd =~ /^$rc+\s*(-)?(\d+)?$/ && do {
745 pop(@hist) if length($cmd) > 1;
746 $i = $1 ? ($#hist-($2?$2:1)) : ($2?$2:$#hist);
747 $cmd = $hist[$i] . "\n";
748 print $OUT $cmd;
749 redo CMD; };
750 $cmd =~ /^$sh$sh\s*/ && do {
751 &system($');
752 next CMD; };
753 $cmd =~ /^$rc([^$rc].*)$/ && do {
754 $pat = "^$1";
755 pop(@hist) if length($cmd) > 1;
756 for ($i = $#hist; $i; --$i) {
757 last if $hist[$i] =~ /$pat/;
758 }
759 if (!$i) {
760 print $OUT "No such command!\n\n";
761 next CMD;
762 }
763 $cmd = $hist[$i] . "\n";
764 print $OUT $cmd;
765 redo CMD; };
766 $cmd =~ /^$sh$/ && do {
767 &system($ENV{SHELL}||"/bin/sh");
768 next CMD; };
769 $cmd =~ /^$sh\s*/ && do {
770 &system($ENV{SHELL}||"/bin/sh","-c",$');
771 next CMD; };
772 $cmd =~ /^H\b\s*(-(\d+))?/ && do {
773 $end = $2?($#hist-$2):0;
774 $hist = 0 if $hist < 0;
775 for ($i=$#hist; $i>$end; $i--) {
776 print $OUT "$i: ",$hist[$i],"\n"
777 unless $hist[$i] =~ /^.?$/;
778 };
779 next CMD; };
780 $cmd =~ s/^p$/print \$DB::OUT \$_/;
781 $cmd =~ s/^p\b/print \$DB::OUT /;
782 $cmd =~ /^=/ && do {
783 if (local($k,$v) = ($cmd =~ /^=\s*(\S+)\s+(.*)/)) {
784 $alias{$k}="s~$k~$v~";
785 print $OUT "$k = $v\n";
786 } elsif ($cmd =~ /^=\s*$/) {
787 foreach $k (sort keys(%alias)) {
788 if (($v = $alias{$k}) =~ s~^s\~$k\~(.*)\~$~$1~) {
789 print $OUT "$k = $v\n";
790 } else {
791 print $OUT "$k\t$alias{$k}\n";
792 };
793 };
794 };
795 next CMD; };
796 $cmd =~ /^\|\|?\s*[^|]/ && do {
797 if ($pager =~ /^\|/) {
798 open(SAVEOUT,">&STDOUT") || &warn("Can't save STDOUT");
799 open(STDOUT,">&OUT") || &warn("Can't redirect STDOUT");
800 } else {
801 open(SAVEOUT,">&OUT") || &warn("Can't save DB::OUT");
802 }
803 unless ($piped=open(OUT,$pager)) {
804 &warn("Can't pipe output to `$pager'");
805 if ($pager =~ /^\|/) {
806 open(OUT,">&STDOUT") || &warn("Can't restore DB::OUT");
807 open(STDOUT,">&SAVEOUT")
808 || &warn("Can't restore STDOUT");
809 close(SAVEOUT);
810 } else {
811 open(OUT,">&STDOUT") || &warn("Can't restore DB::OUT");
812 }
813 next CMD;
814 }
815 $SIG{PIPE}= "DB::catch" if $pager =~ /^\|/
816 && "" eq $SIG{PIPE} || "DEFAULT" eq $SIG{PIPE};
817 $selected= select(OUT);
818 $|= 1;
819 select( $selected ), $selected= "" unless $cmd =~ /^\|\|/;
820 $cmd =~ s/^\|+\s*//;
821 redo PIPE; };
822 # XXX Local variants do not work!
823 $cmd =~ s/^t\s/\$DB::trace = 1;\n/;
824 $cmd =~ s/^s\s/\$DB::single = 1;\n/ && do {$laststep = 's'};
825 $cmd =~ s/^n\s/\$DB::single = 2;\n/ && do {$laststep = 'n'};
826 } # PIPE:
54d04a52 827 #} # <-- Do we know what this brace is for?
d338d6fe 828 $evalarg = "\$^D = \$^D | \$DB::db_stop;\n$cmd"; &eval;
829 if ($onetimeDump) {
830 $onetimeDump = undef;
831 } else {
832 print $OUT "\n";
833 }
834 } continue { # CMD:
835 if ($piped) {
836 if ($pager =~ /^\|/) {
837 $?= 0; close(OUT) || &warn("Can't close DB::OUT");
838 &warn( "Pager `$pager' failed: ",
839 ($?>>8) > 128 ? ($?>>8)-256 : ($?>>8),
840 ( $? & 128 ) ? " (core dumped)" : "",
841 ( $? & 127 ) ? " (SIG ".($?&127).")" : "", "\n" ) if $?;
842 open(OUT,">&STDOUT") || &warn("Can't restore DB::OUT");
843 open(STDOUT,">&SAVEOUT") || &warn("Can't restore STDOUT");
844 $SIG{PIPE}= "DEFAULT" if $SIG{PIPE} eq "DB::catch";
845 # Will stop ignoring SIGPIPE if done like nohup(1)
846 # does SIGINT but Perl doesn't give us a choice.
847 } else {
848 open(OUT,">&SAVEOUT") || &warn("Can't restore DB::OUT");
849 }
850 close(SAVEOUT);
851 select($selected), $selected= "" unless $selected eq "";
852 $piped= "";
853 }
854 } # CMD:
855 if ($post) {
856 $evalarg = $post; &eval;
857 }
858 } # if ($single || $signal)
859 ($@, $!, $,, $/, $\, $^W) = @saved;
860 ();
861}
862
863# The following code may be executed now:
864# BEGIN {warn 4}
865
866sub sub {
867 print $LINEINFO ' ' x $#stack, "entering $sub\n" if $frame;
868 push(@stack, $single);
869 $single &= 1;
870 $single |= 4 if $#stack == $deep;
871 if (wantarray) {
872 @ret = &$sub;
873 $single |= pop(@stack);
874 $retctx = "list";
875 $lastsub = $sub;
876print $LINEINFO ' ' x $#stack, "exited $sub\n" if $frame;
877 @ret;
878 } else {
879 $ret = &$sub;
880 $single |= pop(@stack);
881 $retctx = "scalar";
882 $lastsub = $sub;
883print $LINEINFO ' ' x $#stack, "exited $sub\n" if $frame;
884 $ret;
885 }
886}
887
888sub save {
889 @saved = ($@, $!, $,, $/, $\, $^W);
890 $, = ""; $/ = "\n"; $\ = ""; $^W = 0;
891}
892
893# The following takes its argument via $evalarg to preserve current @_
894
895sub eval {
896 my @res;
897 {
898 local (@stack) = @stack; # guard against recursive debugging
899 my $otrace = $trace;
900 my $osingle = $single;
901 my $od = $^D;
902 @res = eval "$usercontext $evalarg;\n"; # '\n' for nice recursive debug
903 $trace = $otrace;
904 $single = $osingle;
905 $^D = $od;
906 }
907 my $at = $@;
908 eval "&DB::save";
909 if ($at) {
910 print $OUT $at;
911 } elsif ($onetimeDump) {
912 dumpit(\@res);
913 }
914}
915
54d04a52 916sub install_breakpoints {
917 my $filename = shift;
918 return unless exists $postponed{$filename};
919 my %break = %{$postponed{$filename}};
920 for (keys %break) {
921 my $i = $_;
922 #if (/\D/) { # Subroutine name
923 #}
924 $dbline{$i} = $break{$_}; # Cannot be done before the file is around
925 }
926}
927
d338d6fe 928sub dumpit {
929 local ($savout) = select($OUT);
930 do 'dumpvar.pl' unless defined &main::dumpValue;
931 if (defined &main::dumpValue) {
54d04a52 932 local $frame = 0;
d338d6fe 933 &main::dumpValue(shift);
934 } else {
935 print $OUT "dumpvar.pl not available.\n";
936 }
937 select ($savout);
938}
939
940sub action {
941 my $action = shift;
942 while ($action =~ s/\\$//) {
943 #print $OUT "+ ";
944 #$action .= "\n";
945 $action .= &gets;
946 }
947 $action;
948}
949
950sub gets {
951 local($.);
952 #<IN>;
953 &readline("cont: ");
954}
955
956sub system {
957 # We save, change, then restore STDIN and STDOUT to avoid fork() since
958 # many non-Unix systems can do system() but have problems with fork().
959 open(SAVEIN,"<&STDIN") || &warn("Can't save STDIN");
960 open(SAVEOUT,">&OUT") || &warn("Can't save STDOUT");
961 open(STDIN,"<&IN") || &warn("Can't redirect STDIN");
962 open(STDOUT,">&OUT") || &warn("Can't redirect STDOUT");
963 system(@_);
964 open(STDIN,"<&SAVEIN") || &warn("Can't restore STDIN");
965 open(STDOUT,">&SAVEOUT") || &warn("Can't restore STDOUT");
966 close(SAVEIN); close(SAVEOUT);
967 &warn( "(Command returned ", ($?>>8) > 128 ? ($?>>8)-256 : ($?>>8), ")",
968 ( $? & 128 ) ? " (core dumped)" : "",
969 ( $? & 127 ) ? " (SIG ".($?&127).")" : "", "\n" ) if $?;
970 $?;
971}
972
973sub setterm {
54d04a52 974 local $frame = 0;
d338d6fe 975 eval "require Term::ReadLine;" or die $@;
976 if ($notty) {
977 if ($tty) {
978 open(IN,"<$tty") or die "Cannot open TTY `$TTY' for read: $!";
979 open(OUT,">$tty") or die "Cannot open TTY `$TTY' for write: $!";
980 $IN = \*IN;
981 $OUT = \*OUT;
982 my $sel = select($OUT);
983 $| = 1;
984 select($sel);
985 } else {
986 eval "require Term::Rendezvous;" or die $@;
987 my $rv = $ENV{PERLDB_NOTTY} || "/tmp/perldbtty$$";
988 my $term_rv = new Term::Rendezvous $rv;
989 $IN = $term_rv->IN;
990 $OUT = $term_rv->OUT;
991 }
992 }
993 if (!$rl) {
994 $term = new Term::ReadLine::Stub 'perldb', $IN, $OUT;
995 } else {
996 $term = new Term::ReadLine 'perldb', $IN, $OUT;
997
998 $readline::rl_basic_word_break_characters .= "[:"
999 if defined $readline::rl_basic_word_break_characters
1000 and index($readline::rl_basic_word_break_characters, ":") == -1;
1001 }
1002 $LINEINFO = $OUT unless defined $LINEINFO;
1003 $lineinfo = $console unless defined $lineinfo;
1004 $term->MinLine(2);
54d04a52 1005 if ($term->Features->{setHistory} and "@hist" ne "?") {
1006 $term->SetHistory(@hist);
1007 }
d338d6fe 1008}
1009
1010sub readline {
54d04a52 1011 if (@typeahead) {
1012 my $left = @typeahead;
1013 my $got = shift @typeahead;
1014 print $OUT "auto(-$left)", shift, $got, "\n";
1015 $term->AddHistory($got)
1016 if length($got) > 1 and defined $term->Features->{addHistory};
1017 return $got;
1018 }
d338d6fe 1019 local $frame = 0;
1020 $term->readline(@_);
1021}
1022
1023sub dump_option {
1024 my ($opt, $val)= @_;
1025 if (defined $optionVars{$opt}
1026 and defined $ {$optionVars{$opt}}) {
1027 $val = $ {$optionVars{$opt}};
1028 } elsif (defined $optionAction{$opt}
1029 and defined &{$optionAction{$opt}}) {
1030 $val = &{$optionAction{$opt}}();
1031 } elsif (defined $optionAction{$opt}
1032 and not defined $option{$opt}
1033 or defined $optionVars{$opt}
1034 and not defined $ {$optionVars{$opt}}) {
1035 $val = 'N/A';
1036 } else {
1037 $val = $option{$opt};
1038 }
1039 $val =~ s/[\\\']/\\$&/g;
1040 printf $OUT "%20s = '%s'\n", $opt, $val;
1041}
1042
1043sub parse_options {
1044 local($_)= @_;
1045 while ($_ ne "") {
1046 s/^(\w+)(\s*$|\W)// or print($OUT "Invalid option `$_'\n"), last;
1047 my ($opt,$sep) = ($1,$2);
1048 my $val;
1049 if ("?" eq $sep) {
1050 print($OUT "Option query `$opt?' followed by non-space `$_'\n"), last
1051 if /^\S/;
1052 #&dump_option($opt);
1053 } elsif ($sep !~ /\S/) {
1054 $val = "1";
1055 } elsif ($sep eq "=") {
1056 s/^(\S*)($|\s+)//;
1057 $val = $1;
1058 } else { #{ to "let some poor schmuck bounce on the % key in B<vi>."
1059 my ($end) = "\\" . substr( ")]>}$sep", index("([<{",$sep), 1 ); #}
1060 s/^(([^\\$end]|\\[\\$end])*)$end($|\s+)// or
1061 print($OUT "Unclosed option value `$opt$sep$_'\n"), last;
1062 $val = $1;
1063 $val =~ s/\\([\\$end])/$1/g;
1064 }
1065 my ($option);
1066 my $matches =
1067 grep( /^\Q$opt/ && ($option = $_), @options );
1068 $matches = grep( /^\Q$opt/i && ($option = $_), @options )
1069 unless $matches;
1070 print $OUT "Unknown option `$opt'\n" unless $matches;
1071 print $OUT "Ambiguous option `$opt'\n" if $matches > 1;
1072 $option{$option} = $val if $matches == 1 and defined $val;
54d04a52 1073 eval "local \$frame = 0; require '$optionRequire{$option}'"
d338d6fe 1074 if $matches == 1 and defined $optionRequire{$option} and defined $val;
1075 $ {$optionVars{$option}} = $val
1076 if $matches == 1
1077 and defined $optionVars{$option} and defined $val;
1078 & {$optionAction{$option}} ($val)
1079 if $matches == 1
1080 and defined $optionAction{$option}
1081 and defined &{$optionAction{$option}} and defined $val;
1082 &dump_option($option) if $matches == 1 && $OUT ne \*STDERR; # Not $rcfile
1083 s/^\s+//;
1084 }
1085}
1086
54d04a52 1087sub set_list {
1088 my ($stem,@list) = @_;
1089 my $val;
1090 $ENV{"$ {stem}_n"} = @list;
1091 for $i (0 .. $#list) {
1092 $val = $list[$i];
1093 $val =~ s/\\/\\\\/g;
1094 $val =~ s/[\0-\37\177\200-\377]/"\\0x" . unpack('H2',$&)/eg;
1095 $ENV{"$ {stem}_$i"} = $val;
1096 }
1097}
1098
1099sub get_list {
1100 my $stem = shift;
1101 my @list;
1102 my $n = delete $ENV{"$ {stem}_n"};
1103 my $val;
1104 for $i (0 .. $n - 1) {
1105 $val = delete $ENV{"$ {stem}_$i"};
1106 $val =~ s/\\((\\)|0x(..))/ $2 ? $2 : pack('H2', $3) /ge;
1107 push @list, $val;
1108 }
1109 @list;
1110}
1111
d338d6fe 1112sub catch {
1113 $signal = 1;
1114}
1115
1116sub warn {
1117 my($msg)= join("",@_);
1118 $msg .= ": $!\n" unless $msg =~ /\n$/;
1119 print $OUT $msg;
1120}
1121
1122sub TTY {
1123 if ($term) {
1124 &warn("Too late to set TTY!\n") if @_;
1125 } else {
1126 $tty = shift if @_;
1127 }
1128 $tty or $console;
1129}
1130
1131sub noTTY {
1132 if ($term) {
1133 &warn("Too late to set noTTY!\n") if @_;
1134 } else {
1135 $notty = shift if @_;
1136 }
1137 $notty;
1138}
1139
1140sub ReadLine {
1141 if ($term) {
1142 &warn("Too late to set ReadLine!\n") if @_;
1143 } else {
1144 $rl = shift if @_;
1145 }
1146 $rl;
1147}
1148
1149sub NonStop {
1150 if ($term) {
1151 &warn("Too late to set up NonStop mode!\n") if @_;
1152 } else {
1153 $runnonstop = shift if @_;
1154 }
1155 $runnonstop;
1156}
1157
1158sub pager {
1159 if (@_) {
1160 $pager = shift;
1161 $pager="|".$pager unless $pager =~ /^(\+?\>|\|)/;
1162 }
1163 $pager;
1164}
1165
1166sub shellBang {
1167 if (@_) {
1168 $sh = quotemeta shift;
1169 $sh .= "\\b" if $sh =~ /\w$/;
1170 }
1171 $psh = $sh;
1172 $psh =~ s/\\b$//;
1173 $psh =~ s/\\(.)/$1/g;
1174 &sethelp;
1175 $psh;
1176}
1177
1178sub recallCommand {
1179 if (@_) {
1180 $rc = quotemeta shift;
1181 $rc .= "\\b" if $rc =~ /\w$/;
1182 }
1183 $prc = $rc;
1184 $prc =~ s/\\b$//;
1185 $prc =~ s/\\(.)/$1/g;
1186 &sethelp;
1187 $prc;
1188}
1189
1190sub LineInfo {
1191 return $lineinfo unless @_;
1192 $lineinfo = shift;
1193 my $stream = ($lineinfo =~ /^(\+?\>|\|)/) ? $lineinfo : ">$lineinfo";
1194 $emacs = ($stream =~ /^\|/);
1195 open(LINEINFO, "$stream") || &warn("Cannot open `$stream' for write");
1196 $LINEINFO = \*LINEINFO;
1197 my $save = select($LINEINFO);
1198 $| = 1;
1199 select($save);
1200 $lineinfo;
1201}
1202
1203sub sethelp {
1204 $help = "
1205T Stack trace.
1206s [expr] Single step [in expr].
1207n [expr] Next, steps over subroutine calls [in expr].
1208<CR> Repeat last n or s command.
1209r Return from current subroutine.
1210c [line] Continue; optionally inserts a one-time-only breakpoint
1211 at the specified line.
1212l min+incr List incr+1 lines starting at min.
1213l min-max List lines min through max.
1214l line List single line.
1215l subname List first window of lines from subroutine.
1216l List next window of lines.
1217- List previous window of lines.
1218w [line] List window around line.
54d04a52 1219. Return to the executed line.
d338d6fe 1220f filename Switch to viewing filename.
1221/pattern/ Search forwards for pattern; final / is optional.
1222?pattern? Search backwards for pattern; final ? is optional.
54d04a52 1223L List all breakpoints and actions for the current file.
d338d6fe 1224S [[!]pattern] List subroutine names [not] matching pattern.
1225t Toggle trace mode.
1226t expr Trace through execution of expr.
1227b [line] [condition]
1228 Set breakpoint; line defaults to the current execution line;
1229 condition breaks if it evaluates to true, defaults to '1'.
1230b subname [condition]
1231 Set breakpoint at first line of subroutine.
1232d [line] Delete the breakpoint for line.
1233D Delete all breakpoints.
1234a [line] command
1235 Set an action to be done before the line is executed.
1236 Sequence is: check for breakpoint, print line if necessary,
1237 do action, prompt user if breakpoint or step, evaluate line.
1238A Delete all actions.
1239V [pkg [vars]] List some (default all) variables in package (default current).
1240 Use ~pattern and !pattern for positive and negative regexps.
1241X [vars] Same as \"V currentpackage [vars]\".
1242x expr Evals expression in array context, dumps the result.
1243O [opt[=val]] [opt\"val\"] [opt?]...
1244 Set or query values of options. val defaults to 1. opt can
1245 be abbreviated. Several options can be listed.
1246 recallCommand, ShellBang: chars used to recall command or spawn shell;
1247 pager: program for output of \"|cmd\";
1248 The following options affect what happens with V, X, and x commands:
1249 arrayDepth, hashDepth: print only first N elements ('' for all);
1250 compactDump, veryCompact: change style of array and hash dump;
1251 globPrint: whether to print contents of globs;
1252 DumpDBFiles: dump arrays holding debugged files;
1253 DumpPackages: dump symbol tables of packages;
1254 quote, HighBit, undefPrint: change style of string dump;
1255 tkRunning: run Tk while prompting (with ReadLine);
1256 signalLevel warnLevel dieLevel: level of verbosity;
1257 Option PrintRet affects printing of return value after r command,
1258 frame affects printing messages on entry and exit from subroutines.
1259 During startup options are initialized from \$ENV{PERLDB_OPTS}.
1260 You can put additional initialization options TTY, noTTY,
1261 ReadLine, and NonStop there.
1262< command Define command to run before each prompt.
1263> command Define command to run after each prompt.
1264$prc number Redo a previous command (default previous command).
1265$prc -number Redo number'th-to-last command.
1266$prc pattern Redo last command that started with pattern.
1267 See 'O recallCommand' too.
1268$psh$psh cmd Run cmd in a subprocess (reads from DB::IN, writes to DB::OUT)"
1269 . ( $rc eq $sh ? "" : "
1270$psh [cmd] Run cmd in subshell (forces \"\$SHELL -c 'cmd'\")." ) . "
1271 See 'O shellBang' too.
1272H -number Display last number commands (default all).
1273p expr Same as \"print DB::OUT expr\" in current package.
1274|dbcmd Run debugger command, piping DB::OUT to current pager.
1275||dbcmd Same as |dbcmd but DB::OUT is temporarilly select()ed as well.
1276\= [alias value] Define a command alias, or list current aliases.
1277command Execute as a perl statement in current package.
54d04a52 1278R Pure-man-restart of debugger, debugger state and command-line
1279 options are lost.
d338d6fe 1280h [db_command] Get help [on a specific debugger command], enter |h to page.
1281h h Summary of debugger commands.
1282q or ^D Quit.
1283
1284";
1285 $summary = <<"END_SUM";
1286List/search source lines: Control script execution:
1287 l [ln|sub] List source code T Stack trace
54d04a52 1288 - or . List previous/current line s [expr] Single step [in expr]
d338d6fe 1289 w [line] List around line n [expr] Next, steps over subs
1290 f filename View source in file <CR> Repeat last n or s
1291 /pattern/ Search forward r Return from subroutine
1292 ?pattern? Search backward c [line] Continue until line
1293Debugger controls: L List break pts & actions
1294 O [...] Set debugger options t [expr] Toggle trace [trace expr]
1295 < command Command for before prompt b [ln] [c] Set breakpoint
1296 > command Command for after prompt b sub [c] Set breakpoint for sub
1297 $prc [N|pat] Redo a previous command d [line] Delete a breakpoint
1298 H [-num] Display last num commands D Delete all breakpoints
1299 = [a val] Define/list an alias a [ln] cmd Do cmd before line
1300 h [db_cmd] Get help on command A Delete all actions
1301 |[|]dbcmd Send output to pager $psh\[$psh\] syscmd Run cmd in a subprocess
54d04a52 1302 q or ^D Quit R Attempt a restart
d338d6fe 1303Data Examination: expr Execute perl code, also see: s,n,t expr
1304 S [[!]pat] List subroutine names [not] matching pattern
1305 V [Pk [Vars]] List Variables in Package. Vars can be ~pattern or !pattern.
1306 X [Vars] Same as \"V current_package [Vars]\".
1307 x expr Evals expression in array context, dumps the result.
1308 p expr Print expression (uses script's current package).
1309END_SUM
1310 # '); # Fix balance of Emacs parsing
1311}
1312
d338d6fe 1313sub diesignal {
54d04a52 1314 local $frame = 0;
d338d6fe 1315 $SIG{'ABRT'} = DEFAULT;
1316 kill 'ABRT', $$ if $panic++;
1317 print $DB::OUT "Got $_[0]!\n"; # in the case cannot continue
1318 local $SIG{__WARN__} = '';
1319 require Carp;
1320 local $Carp::CarpLevel = 2; # mydie + confess
1321 &warn(Carp::longmess("Signal @_"));
1322 kill 'ABRT', $$;
1323}
1324
1325sub dbwarn {
54d04a52 1326 local $frame = 0;
d338d6fe 1327 local $SIG{__WARN__} = '';
1328 require Carp;
1329 #&warn("Entering dbwarn\n");
1330 my ($mysingle,$mytrace) = ($single,$trace);
1331 $single = 0; $trace = 0;
1332 my $mess = Carp::longmess(@_);
1333 ($single,$trace) = ($mysingle,$mytrace);
1334 #&warn("Warning in dbwarn\n");
1335 &warn($mess);
1336 #&warn("Exiting dbwarn\n");
1337}
1338
1339sub dbdie {
54d04a52 1340 local $frame = 0;
d338d6fe 1341 local $SIG{__DIE__} = '';
1342 local $SIG{__WARN__} = '';
1343 my $i = 0; my $ineval = 0; my $sub;
1344 #&warn("Entering dbdie\n");
1345 if ($dieLevel != 2) {
1346 while ((undef,undef,undef,$sub) = caller(++$i)) {
1347 $ineval = 1, last if $sub eq '(eval)';
1348 }
1349 {
1350 local $SIG{__WARN__} = \&dbwarn;
1351 &warn(@_) if $dieLevel > 2; # Ineval is false during destruction?
1352 }
1353 #&warn("dieing quietly in dbdie\n") if $ineval and $dieLevel < 2;
1354 die @_ if $ineval and $dieLevel < 2;
1355 }
1356 require Carp;
1357 # We do not want to debug this chunk (automatic disabling works
1358 # inside DB::DB, but not in Carp).
1359 my ($mysingle,$mytrace) = ($single,$trace);
1360 $single = 0; $trace = 0;
1361 my $mess = Carp::longmess(@_);
1362 ($single,$trace) = ($mysingle,$mytrace);
1363 #&warn("dieing loudly in dbdie\n");
1364 die $mess;
1365}
1366
d338d6fe 1367sub warnLevel {
1368 if (@_) {
1369 $prevwarn = $SIG{__WARN__} unless $warnLevel;
1370 $warnLevel = shift;
1371 if ($warnLevel) {
1372 $SIG{__WARN__} = 'DB::dbwarn';
1373 } else {
1374 $SIG{__WARN__} = $prevwarn;
1375 }
1376 }
1377 $warnLevel;
1378}
1379
1380sub dieLevel {
1381 if (@_) {
1382 $prevdie = $SIG{__DIE__} unless $dieLevel;
1383 $dieLevel = shift;
1384 if ($dieLevel) {
1385 $SIG{__DIE__} = 'DB::dbdie'; # if $dieLevel < 2;
1386 #$SIG{__DIE__} = 'DB::diehard' if $dieLevel >= 2;
1387 print $OUT "Stack dump during die enabled",
1388 ( $dieLevel == 1 ? " outside of evals" : ""), ".\n";
1389 print $OUT "Dump printed too.\n" if $dieLevel > 2;
1390 } else {
1391 $SIG{__DIE__} = $prevdie;
1392 print $OUT "Default die handler restored.\n";
1393 }
1394 }
1395 $dieLevel;
1396}
1397
1398sub signalLevel {
1399 if (@_) {
1400 $prevsegv = $SIG{SEGV} unless $signalLevel;
1401 $prevbus = $SIG{BUS} unless $signalLevel;
1402 $signalLevel = shift;
1403 if ($signalLevel) {
1404 $SIG{SEGV} = 'DB::diesignal';
1405 $SIG{BUS} = 'DB::diesignal';
1406 } else {
1407 $SIG{SEGV} = $prevsegv;
1408 $SIG{BUS} = $prevbus;
1409 }
1410 }
1411 $signalLevel;
1412}
1413
1414# The following BEGIN is very handy if debugger goes havoc, debugging debugger?
1415
1416BEGIN { # This does not compile, alas.
1417 $IN = \*STDIN; # For bugs before DB::OUT has been opened
1418 $OUT = \*STDERR; # For errors before DB::OUT has been opened
1419 $sh = '!';
1420 $rc = ',';
1421 @hist = ('?');
1422 $deep = 100; # warning if stack gets this deep
1423 $window = 10;
1424 $preview = 3;
1425 $sub = '';
1426 #$SIG{__WARN__} = "DB::dbwarn";
1427 #$SIG{__DIE__} = 'DB::dbdie';
1428 #$SIG{SEGV} = "DB::diesignal";
1429 #$SIG{BUS} = "DB::diesignal";
1430 $SIG{INT} = "DB::catch";
1431 #$SIG{FPE} = "DB::catch";
1432 #warn "SIGFPE installed";
1433 $warnLevel = 1 unless defined $warnLevel;
1434 $dieLevel = 1 unless defined $dieLevel;
1435 $signalLevel = 1 unless defined $signalLevel;
1436
1437 $db_stop = 0; # Compiler warning
1438 $db_stop = 1 << 30;
1439 $level = 0; # Level of recursive debugging
1440}
1441
54d04a52 1442BEGIN {$^W = $ini_warn;} # Switch warnings back
1443
d338d6fe 1444#use Carp; # This did break, left for debuggin
1445
14461;
Unnamed repository; edit this file to name it for gitweb.