Lines Matching refs:in
25 in creative ways.
28 interesting and still-useful idioms are noted in this section, along with notes
49 temporary copy of a variable in the current scope. When the scope ends, the
50 old copy is restored. This is often used in the debugger to handle the
113 There is a certain C programming legacy in the debugger. Some variables,
116 of state to be stored independently in a single scalar.
123 "addressed" independently in this way, C<$scalar> is acting sort of like
136 just about the fastest thing you can do in Perl: C<use constant> actually
144 =item * Second, it's very easy to serialize a scalar number. This is done in
145 the restart code; the debugger state variables are saved in C<%ENV> and then
150 smack in the middle of the interpreter's execution loop. It's much faster for
151 a C program (like the interpreter) to check a bit in a scalar than to access
163 Send in a patch if you can clear up, fill out, or clarify an C<XXX>.
179 Values are magical in numeric context: 1 if the line is breakable, 0 if not.
188 that will be executed (in the debugger's context) after the debugger has
197 To set them in your rcfile, add a call to
208 if set, goes in NonStop mode. On interrupt, if TTY is not set,
210 Term::Rendezvous. Current variant is to have the name of TTY in this
247 a C<&DB'DB();> in front of each place that can have a
296 =item * 4 - Extended messages: C<in|out> I<context>=I<fully-qualified sub name> from I<file>:I<line>>. If no other flag is on, acts like 1+4.
343 Controls behavior during single-stepping. Stacked in C<@stack> on entry to
369 =item * 4 - user defined a C<watchfunction()> in C<afterinit()>
401 Manipulated by the C<c> command to turn off tracing in all subs above the
424 Keys are line numbers, values are "condition\0action". If used in numeric
426 in the actual hash entry.
434 =item * 1 - file has a breakpoint in it.
436 =item * 2 - file has an action in it.
504 the process of evaluating code in the user's context.
516 Next we need to handle C<$@> without getting confused. We save C<$@> in a
529 and unwinding restores the former version of C<$@> in C<@saved> as well
534 C<DB::eval> isn't parameterized in the standard way; this is to keep the
580 in this routine compromises and uses C<my>.
582 After this routine is over, we don't have user code executing in the debugger's
589 # 'my' variables used here could leak into (that is, be visible in)
590 # the context that the code being evaluated is executing in. This means that
606 # package globals (and any 'my' variables in this containing scope)
615 # $usercontext built in DB::DB near the comment
627 # Save the current value of $@, and preserve it in the debugger's copy
632 # that it will be stored in.
660 # The code being debugged will be executing in its own context, and
676 # comments in this code try to address this problem.)
686 # modified Perl debugger, to be run from Emacs in perldb-mode
691 # (We have made efforts to clarify the comments in the change log
692 # in other places; some of them may seem somewhat obscure as they
694 # in question seems conterproductive.. -JM)
720 # `]' in a regexp is caught).
722 # + Breakpoints in `require'd code are possible (used in `R').
731 # Changes: 0.97: NonStop will not stop in at_exit().
738 # + Cosmetic bugs in printing stack trace.
739 # + `frame' & 8 to print "expanded args" in stack trace.
740 # + Can list/break in imported subs.
758 # They are not used in print_help if they will hurt. Strip pod
764 # in many places.
779 # + Fixed bug in help command trying to call perl method code.
789 # + Added a semi-built-in doc viewer command that calls man with the
799 # summary (h h) screen in the debugger. Mostly columnar alignment
829 # The cmd_*() API returns FALSE on failure; in this case it outputs
835 # # First breakable line in the
845 # # breakable line in range
846 # break_on_line($lineno [, $cond]) # As above, in the current file
867 # + Clean up after itself on VMS (Charles Lane in 12385)
868 # + Adding "@ file" syntax (Peter Scott in 12014)
869 # + Debug reloading selfloaded stuff (Ilya Zakharevich in 11457)
870 # + $^S and other debugger fixes (Ilya Zakharevich in 11120)
871 # + Forgot a my() declaration (Ilya Zakharevich in 11085)
904 # + Fix a side-effect of bug #24674 in the perl debugger ("odd taint bug")
908 # + Fixed minor newline in history bug.
915 The debugger starts up in phases.
919 First, it initializes the environment it wants to run in: turning off
957 # used to control die() reporting in diesignal()
1081 # not in the table. A subsequent patch will correct this problem; for
1093 by putting code to set them in a BEGIN block in the C<PERL5DB> environment
1120 # These guys may be defined in $ENV{PERL5DB} :
1144 environment first. if it's not defined there, we try to find it in
1152 # If PAGER is defined in the environment, use it.
1170 neither works in the debugger at the moment.
1177 # these currently don't work in linemode debugging).
1209 Child debuggers make a label out of the current PID structure recorded in
1221 # recorded in PERLDB_PIDS plus our (new) PID. Mark us as not having
1228 # We're the parent PID. Initialize PERLDB_PID in case we end up with a
1239 *emacs = $slave_editor if $slave_editor; # May be used in afterinit()...
1298 # Assumes that the file's existence is not in doubt.
1323 # If the PERLDB_OPTS variable has options in it, parse those out next.
1382 We chug through all these variables and plug the values saved in them
1383 back into the appropriate spots in the debugger.
1550 If C<RemotePort> was defined in the options, the debugger assumes that it
1558 # If RemotePort was defined in the options, connect input and output
1593 # read/write on in, or just read, or read on STDIN.
1672 # executed in our scope, so it can fiddle with debugger globals.
1673 if (defined &afterinit) { # May be defined in $rcfile
1676 # Inform us about "Stack dump during die enabled ..." in dieLevel().
1690 Note that the order in which the commands are processed is very important;
1691 some commands earlier in the loop will actually alter the C<$cmd> variable
1694 see what's happening in any given command.
1705 # If there's any call stack in place, turn off single
1710 # And we are now no longer in single-step mode.
1726 # If we're in single-step mode, or an interrupt (real or fake)
1742 # code on behalf of the user. We add the package in so that the
1743 # code is eval'ed in the proper package (not in the debugger!).
1753 # not attached to a filename, but instead stored in Dev:Pseudo)
1759 # Last line in the program.
1768 # It's a conditional stop; eval it in the user's context and
1813 The watchfunction can do anything it likes; it is executing in the
1829 =item * Turning off the '4' bit in C<$trace> (this also disables the
1839 # current package, filename, and line. The function executes in
1850 # Pick up any alteration to $signal in the watchfunction, and
1876 Special check: if we're in package C<DB::fake>, we've gone through the
1878 to enter commands and have a valid context to be in.
1907 # Still somewhere in the midst of execution. Set up the
1949 # in eval'ed text, for instance.
1978 # that had a breakpoint in it at the debugger prompt)?
1989 print $OUT $stack_depth . " levels deep in subroutine calls!\n"
2006 in the file. This is done via the C<$incr>, C<$start>, and C<$max> variables.
2021 in two parts:
2080 in the command history and fall through to allow the command parsing to pick
2101 The debugger can create aliases for commands (these are stored in the
2103 in the alias hash and substitutes the contents of the alias for the command,
2115 # This is a command, so we eval it in the DEBUGGER's
2148 Turn tracing on or off. Inverts the appropriate bit in C<$trace> (q.v.).
2188 =head4 C<X> - list variables in current package
2210 # V - show variables in package.
2305 # if not in magic file list, try a close match.
2334 print $OUT "Already in $file.\n";
2342 and then we look up the line in the magical C<%dbline> hash.
2366 C<$start>) in C<$cmd> to be executed later.
2385 the user's work in setting watchpoints, actions, etc. We wanted, however, to
2388 deal with them instead of processing them in-line.
2392 # All of these commands were remapped in perl 5.8.0;
2399 =head4 C<y> - List lexicals in higher scope
2401 Uses C<PadWalker> to find the lexicals supplied as arguments in a scope
2457 when entered (see X<DB::sub>). We also save the C<n> command in C<$laststep>,
2495 the appropriate one-time-break in C<@dbline> and then turn off single-stepping
2496 in this and all call levels above this one.
2527 # break up the return value, and assign it in one
2540 # Mark that there's a breakpoint in this file.
2563 # involved, this will be a request to break in the current
2598 single-stepping to be on in the call level above the current one. If
2617 Restarting the debugger is a complex operation that occurs in several phases.
2643 # Save the current @init_INC in the environment.
2668 the debugger's status in environment variables. The C<DB::set_list> routine
2675 # save that in the environment.
2682 # corresponding to them) and stick them in the environment.
2695 can live in an awful lot of places, and we have to go through all of them,
2696 find the breakpoints, and then save them in the appropriate environment
2705 # We were in this file.
2712 # is in a postponed file (we'll do postponed ones
2732 # Get over to the eval in question.
2741 "No subroutines in $_, ignoring breakpoints.\n";
2770 "Breakpoint in $_:$line ignored: after all the subroutines.\n";
2839 =head4 C</> - search forward for a string in the source
2881 # Done in eval so nothing breaks if the pattern
2900 # Handle proper escaping in the slave.
2916 =head4 C<?> - search backward for a string in the source
2987 Manages the commands in C<@hist> (which is created if C<Term::ReadLine> reports
3009 # with that command in the buffer.
3022 # Can't run shell commands with Unicode in the debugger, hmm.
3032 If a command is found, it is placed in C<$cmd> and executed via <redo>.
3036 # $rc pattern $rc - find a command in the history.
3056 # Found it. Put it in the buffer, print it, and process it.
3076 =head4 C<$sh I<command>> - Force execution of a command in a shell
3083 # $sh command - start a shell and run a command in it.
3093 =head4 C<H> - display commands in history
3108 # Stay in while we're still above the ending value.
3133 Builds a C<print EXPR> expression in the C<$cmd>; this will get executed at
3168 # as separators (which is why we escaped them in
3196 # likely to appear in the alias.
3223 # Opened OK; stick it in the list of file handles.
3249 print "commands saved in $file\n";
3251 &warn("Can't save debugger commands in '$1': $!\n");
3265 C<PIPE> label, causing us to evaluate the command in C<$cmd> without
3270 # || - run command in the pager, with output to DB::OUT.
3326 Anything left in C<$cmd> at this point is a Perl expression that we want to
3327 evaluate. We'll always evaluate in the user's context, and fully qualify
3328 any variables we might want to address in the C<DB> package.
3348 # Run *our* eval that executes in the caller's context.
3458 C<sub> is called whenever a subroutine call happens in the program being
3462 The core function of this subroutine is to actually call the sub in the proper
3473 the 16 bit is set in C<$frame>).
3476 C<$single> in the C<@stack> package global; if this exceeds the value in
3478 setting the 4 bit in C<$single>. In any case, it keeps the current setting
3484 additional data, in the following order:
3490 The package name the sub was in
3494 The filename it was defined in
3539 # sub's return value in (if needed), and an array to put the sub's
3540 # return value in (if needed).
3572 print_lineinfo(' ' x ($stack_depth - 1), "in "),
3576 # dump_trace; this results in our skipping -1+1 = 0 stack frames
3577 # in dump_trace.
3587 # Called in array context. call sub and capture output.
3687 Support functions in this section which have multiple modes of failure C<die>
3699 Note that trying to set the CommandSet to 'foobar' simply results in the
3737 It tries to look up the command in the X<C<%set>> package-level I<lexical>
3739 the sub to call based on the value found in the hash (if it's there). I<All>
3740 of the commands to be handled in a set have to be added to C<%set>; if they
3753 # command set and command name in %set. If we can't find it,
3766 particular line, so they're stored in C<%dbline>. We default to the current
3812 Delete actions. Similar to above, except the delete code is in a separate
3827 # if delete_action blows up for some reason, in which case
3887 Set breakpoints. Since breakpoints can be set in so many places, in so many
3890 subroutine to actually do the work of setting the breakpoint in the right
3917 # necessary condition in the %postponed hash.
3967 We want to break when this file is loaded. Mark this file in the
3968 C<%break_on_load> hash, and note that it has a breakpoint in
3982 only files with break-on-load are in here, so simply showing the keys
3993 We take the file passed in and try to find it in C<%INC> (which maps modules
4010 # Tack on .pm and do it again unless there was a '.' in the name
4029 Several of the functions we need to implement in the API need to work both
4034 We can now build functions in pairs: the basic function works on the current
4050 and prints C<$filename_error> in the error message (the name of the other file)
4051 if it needs to. When the functions return, C<*dbline> is restored to point to the actual current file (the one we're executing in) and C<$filename_error> is
4055 See the comments in C<breakable_line> and C<breakable_line_in_file> for more
4066 The subroutine decides whether or not a line in the current file is breakable.
4126 # We move through @dbline in the appropriate direction (determined
4128 # We stay in as long as we haven't hit an executable line
4138 # Format the message and print it: no breakable lines in range.
4142 # If there's a filename in filename_error, we'll see it.
4149 Like C<breakable_line>, but look in another file.
4160 # If there's an error, it's in this other file.
4188 # if it was in a different file.
4191 # Mark this file as having breakpoints in it.
4281 Places a break on the first line possible in the specified subroutine. Uses
4297 # Put a break the first place possible in the range of lines
4310 =item 2. Try putting it in the current package.
4312 =item 3. If it's not there, try putting it in CORE::GLOBAL if it exists there.
4314 =item 4. If it starts with '::', put it in 'main::'.
4336 # Put it in this package unless it's already qualified.
4341 # package resulted in its not being defined, but only do so
4342 # if it really is in CORE::GLOBAL.
4348 # Put it in package 'main' if it has a leading ::.
4408 For a single line, we look for it in C<@dbline>. If it's nonbreakable, we
4412 line in C<%dbline> to signal that no action needs to be taken for this line.
4416 at each line in each of these files, temporarily switching the C<%dbline>
4417 and C<@dbline> structures to point to the files in question, and do what
4418 we did in the single line case: delete the condition in C<@dbline>, and
4419 delete the key in C<%dbline> if nothing's left.
4449 # breakpoint in it.
4457 # For all lines in this file ...
4470 # If, after we turn off the "there were breakpoints in this file"
4471 # bit, the entry in %had_breakpoints for this file is zero,
4489 anywhere else in the debugger. XXX It is probably meant for use in development
4600 We save the last line listed in the C<$start> global for further listing
4618 # Set up for DB::eval() - evaluate in *user* context.
4641 # Put it in this package unless it starts with ::.
4644 # Put it in CORE::GLOBAL if t doesn't start with :: and
4645 # it doesn't live in this package and it lives in CORE::GLOBAL.
4665 # If we're not in that file, switch over to it.
4740 # - the current line in execution
4751 # ==> if this is the current line in execution,
4774 # Save the point we last listed to in case another relative 'l'
4792 Watchpoints are simpler: we just list the entries in C<@to_watch>.
4809 # Breaks and actions are found together, so we look in the same place
4812 # Look in all the files with breakpoints...
4820 # in this file?
4822 # For each line in the file ...
4852 # Look for breaks in not-yet-compiled subs:
4854 print $OUT "Postponed breakpoints in subroutines:\n";
4869 print $OUT "Postponed breakpoints in files:\n";
4943 =head3 C<cmd_O> - nonexistent in 5.8.x (command)
4957 Uses the C<$preview> variable set in the second C<BEGIN> block (q.v.) to
4958 move back a few lines to list the selected line in context. Uses C<cmd_l>
4970 # argument results in no action at all)).
4994 We extract the expression, save it, evaluate it in the user's context, and
5013 # in the user's context. This version can handle expressions which
5066 # Where we are in the list.
5100 These are general support routines that are used in a number of places
5105 save() saves the user's versions of globals that would mess us up in C<@saved>,
5141 Handles setting postponed breakpoints in subroutines once they're compiled.
5162 # possible that the filename might have colons in it too.
5169 # Switch to the file this sub is in, temporarily.
5175 # This file's got a breakpoint in it.
5178 # Last line in file.
5185 # Copy the breakpoint in and delete it from %postponed.
5237 # Do we have any breakpoints to put in this file?
5244 # breakpoints saved in %postponed_file into %dbline by assigning
5271 values of the package globals C<$single> and C<$trace> are backed up in
5280 installed version in @INC, yours will be used instead. Possible security
5303 # passed in as the first parameter.
5368 correct if this routine is called in a tied method.
5412 # Put in a filename header if short is off.
5456 =item * C<file> - the file in which this item was defined (if any)
5495 # still returning something, stay in the loop. (If we pass the requested
5825 Only works if C<xterm> is in your path and C<$ENV{DISPLAY}>, etc. are
5840 $pidprompt = ''; # Shown anyway in titlebar
5858 # Having -d in PERL5OPT would lead to a disaster...
5874 # in the same session with a "dependent" asynchronous child session.
5886 my ($rl, $in) = (shift, shift); # Read from $in and pass through
5889 open IN, '<&=$in' or die "open <&=$in: \$!";
5906 $pidprompt = ''; # Shown anyway in titlebar
5935 # If we know how to get a new TTY, do it! $in will have
5937 my $in = &get_fork_TTY if defined &get_fork_TTY;
5940 $in = $fork_TTY if defined $fork_TTY; # Backward compatibility
5942 if (not defined $in) {
5962 I know how to switch the output to a different window in xterms
5964 in B<\$DB::fork_TTY>, or define a function B<DB::get_fork_TTY()> returning this.
5970 } ## end if (not defined $in)
5971 elsif ($in ne '') {
5972 TTY($in);
5986 in the prompt has I<two> dashes instead of one.
5991 two dashed) in between them.
6002 my $in = shift;
6004 # resetterm(2): got in here because of a system() starting a debugger.
6006 my $systemed = $in > 1 ? '-' : '';
6025 return unless $CreateTTY & $in;
6028 create_IN_OUT($in);
6033 First, we handle stuff in the typeahead buffer. If there is any, we shift off
6037 If there's nothing in the typeahead buffer, check the command filehandle stack.
6050 # Localize to prevent it from being smashed in the program being debugged.
6079 # Read from the last one in the stack.
6132 You must supply a default value to be used in case the option isn't set.
6141 # If so, retrieve the value via the value in %optionVars.
6148 # If so, call the subroutine via the ref in %optionAction
6186 it just gets stuck in a variable, we do that; if there's a subroutine to
6189 Finally, if we're running in interactive mode, we display the effect of the
6260 else { #{ to "let some poor schmuck bounce on the % key in B<vi>."
6289 # Stick it in the proper variable if it goes in a variable.
6307 These routines are used to store (and restore) lists of items in environment
6312 Set_list packages up items to be stored in a set of environment variables
6326 # Grab each item in the list, escape the backslashes, encode the non-ASCII
6327 # as hex, and then save in the appropriate VAR_0, VAR_1, etc.
6362 avoids allocating any memory possibly in the middle of something that will
6438 there's already a terminal in place, we save the information to take effect
6452 my ($in, $out) = shift;
6453 if ($in =~ /,/) {
6455 ($in, $out) = split /,/, $in, 2;
6459 $out = $in;
6463 open IN, $in or die "cannot open `$in' for read: $!";
6470 return $tty = $in;
6487 get a terminal to read from. If called after a terminal is already in place,
6504 use C<Term::ReadLine>. Can't be changed after a terminal's in place; we save
6505 the value in case a restart is done so we can change it then.
6521 setting in case the user does a restart.
6554 debugger remembers the setting in case you restart, though.
6585 in the help.
6592 # ends in a word character.
6623 # Use what was passed in if we can't determine it ourselves.
6631 Sets the recall command, and builds a printable version which will appear in
6691 Essentially just runs through the keys in %INC, picks up the
6736 and IE<gt>E<lt>), followed by a tab, and then the descriptive text, ending in a newline. The descriptive text can also be marked up in the same way. If you
6758 B<s> [I<expr>] Single step [in I<expr>].
6759 B<n> [I<expr>] Next, steps over subroutine calls [in I<expr>].
6779 (in the order of execution).
6814 B<V> [I<pkg> [I<vars>]] List some (default all) variables in package (default current).
6817 B<x> I<expr> Evals expression in list context, dumps the result.
6818 B<m> I<expr> Evals expression in list context, prints methods callable
6823 B<y> [I<n> [I<Vars>]] List lexicals in higher scope <n>. Vars same as B<V>.
6841 B<$psh$psh> I<cmd> Run cmd in a subprocess (reads from DB::IN, writes to DB::OUT)"
6846 B<$psh> [I<cmd>] Run I<cmd> in subshell (forces \"\$SHELL -c 'cmd'\")."
6853 B<p> I<expr> Same as \"I<print {DB::OUT} expr>\" in current package.
6857 I<command> Execute as a perl statement in current package.
6867 Set options. Use quotes in spaces in value.
6888 I<maxTraceLen> gives max length of evals/args listed in stack trace.
6910 # note: tabs in the following section are not-so-helpful
6914 B<-> or B<.> List previous/current line B<s> [I<expr>] Single step [in expr]
6916 B<f> I<filename> View source in file <B<CR>/B<Enter>> Repeat last B<n> or B<s>
6927 B<|>[B<|>]I<db_cmd> Send output to pager B<$psh>\[B<$psh>\] I<syscmd> Run cmd in a subprocess
6930 B<x>|B<m> I<expr> Evals expr in list context, dumps the result or lists methods.
6933 B<V> [I<Pk> [I<Vars>]] List Variables in Package. Vars can be ~pattern or !pattern.
6935 B<y> [I<n> [I<Vars>]] List lexicals in higher scope <n>. Vars same as B<V>.
6944 B<s> [I<expr>] Single step [in I<expr>].
6945 B<n> [I<expr>] Next, steps over subroutine calls [in I<expr>].
6965 (in the order of execution).
6996 B<V> [I<pkg> [I<vars>]] List some (default all) variables in package (default current).
6999 B<x> I<expr> Evals expression in list context, dumps the result.
7000 B<m> I<expr> Evals expression in list context, prints methods callable
7017 B<$psh$psh> I<cmd> Run cmd in a subprocess (reads from DB::IN, writes to DB::OUT)"
7022 B<$psh> [I<cmd>] Run I<cmd> in subshell (forces \"\$SHELL -c 'cmd'\")."
7028 B<p> I<expr> Same as \"I<print {DB::OUT} expr>\" in current package.
7032 I<command> Execute as a perl statement in current package.
7043 Set options. Use quotes in spaces in value.
7064 I<maxTraceLen> gives max length of evals/args listed in stack trace.
7085 # note: tabs in the following section are not-so-helpful
7089 B<-> or B<.> List previous/current line B<s> [I<expr>] Single step [in expr]
7091 B<f> I<filename> View source in file <B<CR>/B<Enter>> Repeat last B<n> or B<s>
7101 B<|>[B<|>]I<db_cmd> Send output to pager B<$psh>\[B<$psh>\] I<syscmd> Run cmd in a subprocess
7104 B<x>|B<m> I<expr> Evals expr in list context, dumps the result or lists methods.
7107 B<V> [I<Pk> [I<Vars>]] List Variables in Package. Vars can be ~pattern or !pattern.
7109 B<y> [I<n> [I<Vars>]] List lexicals in higher scope <n>. Vars same as B<V>.
7179 It checks for C<less> masquerading as C<more> and records the result in
7333 die @_ if $^S; # in eval propagate
7345 # inside DB::DB, but not in Carp). Save $single and $trace, turn them off,
7354 package Carp; # Do not include us in the list
7365 results in the debugger taking over all warning handlers. Setting
7367 being debugged in place.
7387 Similar to C<warnLevel>. Non-zero values for C<dieLevel> result in the
7407 # in an eval().
7427 Number three in a series: set C<signalLevel> to zero to keep your own
7454 L<Devel::Peek> to try to find the glob in which this code reference lives
7467 my $in = shift;
7468 my $name = CvGV_name_or_bust($in);
7469 defined $name ? $name : $in;
7474 Calls L<Devel::Peek> to try to find the glob the ref lives in; returns
7478 Returns "I<package>::I<glob name>" if the code ref is found in a glob.
7483 my $in = shift;
7485 return unless ref $in;
7486 $in = \&$in; # Hard reference...
7488 my $gv = Devel::Peek::CvGV($in) or return;
7494 A utility routine used in various places; finds the file where a subroutine
7526 methods in the class corresponding to the current reference and in
7554 higher in the C<@ISA> tree, 0 if we should stop.
7569 # Keep if this is a defined subroutine in this class.
7571 # Extract from all the symbols in this class.
7691 any subroutines can be called. These are defined in the second C<BEGIN> block.
7707 =item * The before-this-line context to be printed in a C<v> (view a window around this line) command.
7709 =item * The fact that we're not in a sub at all right now.
7713 =item * The appropriate value of the flag in C<$^D> that says the debugger is running
7741 # Number of lines around the current one that are shown in the
7746 # use in calculating the start of the window it will display.
7749 # We're not in any sub yet, but we need this to be a defined value.
7765 # execute anything in the user's context, because we always want to
7768 $db_stop = 1 << 30; # ... because this is only used in an eval() later.
7770 # This variable records how many levels we're nested in debugging. Used
7771 # Used in the debugger prompt, and in determining whether it's all over or
7775 # "Triggers bug (?) in perl if we postpone this until runtime."
7803 If there is only a single possible completion, C<readline> will use it in full.
7806 completion. Think LISP in this section.
7815 # $start is the start of the text to be completed in the incoming line.
7828 =item * Find all the subroutines that might match in this package
7916 (C<eval>s are C<_E<lt>(eval NNN)>) keys in C<%main::>. We pull all of these
7951 if ($text =~ /^[\$@%](.*)::(.*)/) { # symbols in a package
7957 =item * Determine the package that the symbol is in. Put it in C<::> (effectively C<main::>) if no package is specified.
7974 =item * Look through all the symbols in the package. C<grep> out all the possible hashes/arrays/scalars, and then C<grep> the possible matches out of those. C<map> the prefix onto all the possibilities.
8005 if ($text =~ /^[\$@%]/) { # symbols (in $package + packages in main)
8028 =item * If the package is C<::> (C<main>), create an empty list; if it's something else, create a list of all the packages known. Append whichever list to a list of all the possible symbols in the current package. C<grep> out the matches to the text entered so far, then C<map> the prefix back onto the symbols.
8053 only a single value, we complete the command in such a way that it is a
8054 complete command for setting the option in question. If there are multiple
8062 # We look for the text to be matched in the list of possible options,
8082 # If we didn't find this quote character in the value,
8131 If we have $ini_pids, save it in the environment; else remove it from the
8154 We then figure out whether we're truly done (as in the user entered a C<q>
8171 # Do not stop in at_exit() and destructors on exit:
8178 Some of the commands changed function quite a bit in the 5.8 command
8224 # Mark that there's an action in this file.
8265 # necessary condition in the %postponed hash.
8316 # breakpoint in it.
8325 # For all lines in this file ...
8338 # If, after we turn off the "there were breakpoints in this file"
8339 # bit, the entry in %had_breakpoints for this file is zero,
8473 Since the lists of actions are all held in arrays that are pointed to by
8484 # Figure out what to put in the prompt.
8532 # List the actions in the selected list.
8544 # It's a delete. Get rid of the old actions in the