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