@c This is part of the Emacs manual.
-@c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000 Free Software Foundation, Inc.
+@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
-@node Building, Abbrevs, Programs, Top
+@node Building, Maintaining, Programs, Top
@chapter Compiling and Testing Programs
@cindex building programs
@cindex program building
* Compilation Mode:: The mode for visiting compiler errors.
* Compilation Shell:: Customizing your shell properly
for use in the compilation buffer.
-* Debuggers:: Running symbolic debuggers for non-Lisp programs.
-* Executing Lisp:: Various modes for editing Lisp programs,
+* Debuggers:: Running symbolic debuggers for non-Lisp programs.
+* Executing Lisp:: Various modes for editing Lisp programs,
with different facilities for running
- the Lisp programs.
+ the Lisp programs.
* Libraries: Lisp Libraries. Creating Lisp programs to run in Emacs.
-* Interaction: Lisp Interaction. Executing Lisp in an Emacs buffer.
* Eval: Lisp Eval. Executing a single Lisp expression in Emacs.
-* External Lisp:: Communicating through Emacs with a separate Lisp.
+* Interaction: Lisp Interaction. Executing Lisp in an Emacs buffer.
+* External Lisp:: Communicating through Emacs with a separate Lisp.
@end menu
@node Compilation
@table @kbd
@item M-x compile
-Run a compiler asynchronously under Emacs, with error messages to
-@samp{*compilation*} buffer.
+Run a compiler asynchronously under Emacs, with error messages going to
+the @samp{*compilation*} buffer.
+@item M-x recompile
+Invoke a compiler with the same command as in the last invocation of
+@kbd{M-x compile}.
@item M-x grep
Run @code{grep} asynchronously under Emacs, with matching lines
listed in the buffer named @samp{*grep*}.
@item M-x grep-find
+@item M-x find-grep
Run @code{grep} via @code{find}, with user-specified arguments, and
collect output in the buffer named @samp{*grep*}.
@item M-x kill-compilation
directory.
@vindex compile-command
- When the shell command line is read, the minibuffer appears containing
-a default command line, which is the command you used the last time you
-did @kbd{M-x compile}. If you type just @key{RET}, the same command
-line is used again. For the first @kbd{M-x compile}, the default is
-@samp{make -k}. The default compilation command comes from the variable
+ When the shell command line is read, the minibuffer appears
+containing a default command line, which is the command you used the
+last time you did @kbd{M-x compile}. If you type just @key{RET}, the
+same command line is used again. For the first @kbd{M-x compile}, the
+default is @samp{make -k}, which is correct most of the time for
+nontrivial programs. (@xref{Top,, Make, make, GNU Make Manual}.)
+The default compilation command comes from the variable
@code{compile-command}; if the appropriate compilation command for a
file is something other than @samp{make -k}, it can be useful for the
file to specify a local value for @code{compile-command} (@pxref{File
the buffer, it remains fixed while more compilation output is added at
the end of the buffer.
+@cindex compilation buffer, keeping current position at the end
@vindex compilation-scroll-output
If you set the variable @code{compilation-scroll-output} to a
non-@code{nil} value, then the compilation buffer always scrolls to
follow output as it comes in.
@findex kill-compilation
- To kill the compilation process, do @kbd{M-x kill-compilation}. When
-the compiler process terminates, the mode line of the
-@samp{*compilation*} buffer changes to say @samp{signal} instead of
-@samp{run}. Starting a new compilation also kills any running
-compilation, as only one can exist at any time. However, @kbd{M-x
-compile} asks for confirmation before actually killing a compilation
-that is running.
+ When the compiler process terminates, for whatever reason, the mode
+line of the @samp{*compilation*} buffer changes to say @samp{signal}
+instead of @samp{run}. Starting a new compilation also kills any
+running compilation, as only one can exist at any time. However,
+@kbd{M-x compile} asks for confirmation before actually killing a
+compilation that is running. You can also kill the compilation
+process with @kbd{M-x kill-compilation}.
+
+@findex recompile
+ To rerun the last compilation with the same command, type @kbd{M-x
+recompile}. This automatically reuses the compilation command from the
+last invocation of @kbd{M-x compile}.
+
+ Emacs does not expect a compiler process to launch asynchronous
+subprocesses; if it does, and they keep running after the main
+compiler process has terminated, Emacs may kill them or their output
+may not arrive in Emacs. To avoid this problem, make the main process
+wait for its subprocesses to finish. In a shell script, you can do this
+using @samp{$!} and @samp{wait}, like this:
+
+@example
+(sleep 10; echo 2nd)& pid=$! # @r{Record pid of subprocess}
+echo first message
+wait $pid # @r{Wait for subprocess}
+@end example
+
+ If the background process does not output to the compilation buffer,
+so you only need to prevent it from being killed when the main
+compilation process terminates, this is sufficient:
+
+@example
+nohup @var{command}; sleep 1
+@end example
+
+@vindex compilation-environment
+ You can control the environment passed to the compilation command
+with the variable @code{compilation-environment}. Its value is a list
+of environment variable settings; each element should be a string of
+the form @code{"@var{envvarname}=@var{value}"}. These environment
+variable settings override the usual ones.
@node Grep Searching
@section Searching with Grep under Emacs
@code{grep} command.
@findex grep-find
- The command @kbd{M-x grep-find} is similar to @kbd{M-x grep}, but it
-supplies a different initial default for the command---one that runs
-both @code{find} and @code{grep}, so as to search every file in a
-directory tree. See also the @code{find-grep-dired} command,
-in @ref{Dired and Find}.
+@findex find-grep
+ The command @kbd{M-x grep-find} (also available as @kbd{M-x
+find-grep}) is similar to @kbd{M-x grep}, but it supplies a different
+initial default for the command---one that runs both @code{find} and
+@code{grep}, so as to search every file in a directory tree. See also
+the @code{find-grep-dired} command, in @ref{Dired and Find}.
@node Compilation Mode
@section Compilation Mode
mode, whose main feature is to provide a convenient way to look at the
source line where the error happened.
+ If you set the variable @code{compilation-scroll-output} to a
+non-@code{nil} value, then the compilation buffer always scrolls to
+follow output as it comes in.
+
@table @kbd
@item C-x `
Visit the locus of the next compiler error message or @code{grep} match.
@kindex C-x `
@findex next-error
You can visit the source for any particular error message by moving
-point in @samp{*compilation*} to that error message and typing @key{RET}
-(@code{compile-goto-error}). Or click @kbd{Mouse-2} on the error message;
-you need not switch to the @samp{*compilation*} buffer first.
+point in the @samp{*compilation*} buffer to that error message and
+typing @key{RET} (@code{compile-goto-error}). Alternatively, you can
+click @kbd{Mouse-2} on the error message; you need not switch to the
+@samp{*compilation*} buffer first.
To parse the compiler error messages sequentially, type @kbd{C-x `}
(@code{next-error}). The character following the @kbd{C-x} is the
buffer and finds no more error messages to visit, it fails and signals
an Emacs error.
+ You don't have to be in the compilation buffer in order to use
+@code{next-error}. If one window on the selected frame can be the
+target of the @code{next-error} call, it is used. Else, if a buffer
+previously had @code{next-error} called on it, it is used. Else,
+if the current buffer can be the target of @code{next-error}, it is
+used. Else, all the buffers Emacs manages are tried for
+@code{next-error} support.
+
@kbd{C-u C-x `} starts scanning from the beginning of the compilation
buffer. This is one way to process the same set of errors again.
+@vindex compilation-error-regexp-alist
+@vindex grep-regexp-alist
+ To parse messages from the compiler, Compilation mode uses the
+variable @code{compilation-error-regexp-alist} which lists various
+formats of error messages and tells Emacs how to extract the source file
+and the line number from the text of a message. If your compiler isn't
+supported, you can tailor Compilation mode to it by adding elements to
+that list. A similar variable @code{grep-regexp-alist} tells Emacs how
+to parse output of a @code{grep} command.
+
Compilation mode also redefines the keys @key{SPC} and @key{DEL} to
scroll by screenfuls, and @kbd{M-n} and @kbd{M-p} to move to the next or
previous error message. You can also use @kbd{M-@{} and @kbd{M-@}} to
@c Do you believe in GUD?
The GUD (Grand Unified Debugger) library provides an interface to
-various symbolic debuggers from within Emacs. We recommend the debugger
-GDB, which is free software, but you can also run DBX, SDB or XDB if you
-have them. GUD can also serve as an interface to the Perl's debugging
-mode, the Python debugger PDB, and to JDB, the Java Debugger.
+various symbolic debuggers from within Emacs. We recommend the
+debugger GDB, which is free software, but you can also run DBX, SDB or
+XDB if you have them. GUD can also serve as an interface to Perl's
+debugging mode, the Python debugger PDB, the bash debugger, and to
+JDB, the Java Debugger. @xref{Debugging,, The Lisp Debugger, elisp,
+the Emacs Lisp Reference Manual}, for information on debugging Emacs
+Lisp programs.
@menu
* Starting GUD:: How to start a debugger subprocess.
* Commands of GUD:: Key bindings for common commands.
* GUD Customization:: Defining your own commands for GUD.
* GUD Tooltips:: Showing variable values by pointing with the mouse.
+* GDB Graphical Interface:: An enhanced mode that uses GDB features to
+ implement a graphical debugging environment through
+ Emacs.
@end menu
@node Starting GUD
@table @kbd
@item M-x gdb @key{RET} @var{file} @key{RET}
@findex gdb
-Run GDB as a subprocess of Emacs. This command creates a buffer for
-input and output to GDB, and switches to it. If a GDB buffer already
-exists, it just switches to that buffer.
+Run GDB as a subprocess of Emacs. By default, GDB starts as for
+@kbd{M-x gdba} below. If you want GDB to start as in Emacs 21.3 and
+earlier then edit the string in the minibuffer or set
+@code{gud-gdb-command-name} to ``gdb --fullname''. You need to do
+this if you want to run multiple debugging sessions within one Emacs
+session. In this case, the command creates a buffer for input and
+output to GDB, and switches to it. If a GDB buffer already exists, it
+just switches to that buffer.
+
+@item M-x gdba @key{RET} @var{file} @key{RET}
+Run GDB as a subprocess of Emacs, providing a graphical interface
+to GDB features through Emacs. @xref{GDB Graphical Interface}.
@item M-x dbx @key{RET} @var{file} @key{RET}
@findex dbx
@node Debugger Operation
@subsection Debugger Operation
+@cindex fringes, and current execution line in GUD
When you run a debugger with GUD, the debugger uses an Emacs buffer
for its ordinary input and output. This is called the GUD buffer. The
debugger displays the source files of the program by visiting them in
Emacs buffers. An arrow (@samp{=>}) in one of these buffers indicates
-the current execution line.@footnote{Under a window system the arrow is
-displayed in the marginal area of the Emacs window.} Moving point in
-this buffer does not move the arrow.
+the current execution line.@footnote{Under a window system, the arrow
+appears in the left fringe of the Emacs window.} Moving point in this
+buffer does not move the arrow.
You can start editing these source files at any time in the buffers
-that were made to display them. The arrow is not part of the file's
+that display them. The arrow is not part of the file's
text; it appears only on the screen. If you do modify a source file,
keep in mind that inserting or deleting lines will throw off the arrow's
positioning; GUD has no way of figuring out which line corresponded
also provides commands for setting and clearing breakpoints, for
selecting stack frames, and for stepping through the program. These
commands are available both in the GUD buffer and globally, but with
-different key bindings.
+different key bindings. It also has its own toolbar from which you
+can invoke the more common commands by clicking on the appropriate
+icon. This is particularly useful for repetitive commands like
+gud-next and gud-step and allows the user to hide the GUD buffer.
- The breakpoint commands are usually used in source file buffers,
-because that is the way to specify where to set or clear the breakpoint.
-Here's the global command to set a breakpoint:
+ The breakpoint commands are normally used in source file buffers,
+because that is the easiest way to specify where to set or clear the
+breakpoint. Here's the global command to set a breakpoint:
@table @kbd
@item C-x @key{SPC}
If you are using GDB, these additional key bindings are available:
@table @kbd
+@item C-c C-r
+@kindex C-c C-r @r{(GUD)}
+@itemx C-x C-a C-r
+@findex gud-run
+Start execution of the program (@code{gud-run}).
+
+@item C-c C-u
+@kindex C-c C-u @r{(GUD)}
+@itemx C-x C-a C-u
+@findex gud-until
+Continue execution to the current line. The program will run until
+it hits a breakpoint, terminates, gets a signal that the debugger is
+checking for, or reaches the line on which the cursor currently sits
+(@code{gud-until}).
+
@item @key{TAB}
@kindex TAB @r{(GUD)}
@findex gud-gdb-complete-command
@findex gud-finish
Run the program until the selected stack frame returns (or until it
stops for some other reason).
+
+@item C-x C-a C-j
+@kindex C-x C-a C-j @r{(GUD)}
+@findex gud-jump
+Only useful in a source buffer, (@code{gud-jump}) transfers the
+program's execution point to the current line. In other words, the
+next line that the program executes will be the one where you gave the
+command. If the new execution line is in a different function from
+the previously one, GDB prompts for confirmation since the results may
+be bizarre. See the GDB manual entry regarding @code{jump} for
+details.
@end table
+With the GDB Graphical Interface, you can click @kbd{Mouse-1} on a
+line of the source buffer, in the fringe or display margin, to set a
+breakpoint there. If a breakpoint already exists on that line, this
+action will remove it (@code{gdb-mouse-set-clear-breakpoint}). Where
+Emacs uses the margin to display breakpoints, it is also possible to
+enable or disable them when you click @kbd{Mouse-3} there
+(@code{gdb-mouse-toggle--breakpoint}).
+
These commands interpret a numeric argument as a repeat count, when
that makes sense.
if you are using GDB; @code{dbx-mode-hook}, if you are using DBX;
@code{sdb-mode-hook}, if you are using SDB; @code{xdb-mode-hook}, if you
are using XDB; @code{perldb-mode-hook}, for Perl debugging mode;
-@code{jdb-mode-hook}, for PDB; @code{jdb-mode-hook}, for JDB. You can
+@code{pdb-mode-hook}, for PDB; @code{jdb-mode-hook}, for JDB. You can
use these hooks to define custom key bindings for the debugger
interaction buffer. @xref{Hooks}.
This defines a command named @var{function} which sends
@var{cmdstring} to the debugger process, and gives it the documentation
-string @var{docstring}. You can use the command thus defined in any
+string @var{docstring}. You can then use the command @var{function} in any
buffer. If @var{binding} is non-@code{nil}, @code{gud-def} also binds
the command to @kbd{C-c @var{binding}} in the GUD buffer's mode and to
@kbd{C-x C-a @var{binding}} generally.
the mouse in the GUD buffer or in source buffers with major modes in the
customizable list @code{tooltip-gud-modes}.
+@node GDB Graphical Interface
+@subsection GDB Graphical Interface
+
+By default, the command @code{gdb} starts GDB using a graphical
+interface where you view and control the program's data using Emacs
+windows. You can still interact with GDB through the GUD buffer, but
+the point of this mode is that you can do it through menus and clicks,
+without needing to know GDB commands.
+
+@findex gdba
+If you have customised @code{gud-gdb-command-name}, then start this
+mode with the command @code{gdba}.
+
+@menu
+* Layout:: Control the number of displayed buffers.
+* Breakpoints Buffer:: A breakpoint control panel.
+* Stack Buffer:: Select a frame from the call stack.
+* Watch Expressions:: Monitor variable values in the speedbar.
+* Other Buffers:: Input/output, locals, registers, assembler, threads
+ and memory buffers.
+@end menu
+
+@node Layout
+@subsubsection Layout
+@cindex GDB User Interface layout
+
+@findex gdb-many-windows
+@vindex gdb-many-windows
+
+If the variable @code{gdb-many-windows} is @code{nil} (the default
+value) then gdb just pops up the GUD buffer unless the variable
+@code{gdb-show-main} is non-@code{nil}. In this case it starts with
+two windows: one displaying the GUD buffer and the other with the
+source file with the main routine of the inferior.
+
+If @code{gdb-many-windows} is non-@code{nil}, regardless of the value of
+@code{gdb-show-main}, the layout below will appear unless
+@code{gdb-use-inferior-io-buffer} is @code{nil}. In this case the
+source buffer occupies the full width of the frame.
+
+@multitable @columnfractions .5 .5
+@item GUD buffer (I/O of GDB)
+@tab Locals buffer
+@item
+@tab
+@item Source buffer
+@tab Input/Output (of inferior) buffer
+@item
+@tab
+@item Stack buffer
+@tab Breakpoints buffer
+@end multitable
+
+To toggle this layout, do @kbd{M-x gdb-many-windows}.
+
+@findex gdb-restore-windows
+If you change the window layout, for example, while editing and
+re-compiling your program, then you can restore it with the command
+@code{gdb-restore-windows}.
+
+You may also choose which additional buffers you want to display,
+either in the same frame or a different one. Select GDB-windows or
+GDB-Frames from the menu-bar under the heading GUD. If the menu-bar
+is unavailable, type @code{M-x
+gdb-display-@var{buffertype}-buffer} or @code{M-x
+gdb-frame-@var{buffertype}-buffer} respectively, where @var{buffertype}
+is the relevant buffer type e.g breakpoints.
+
+When you finish debugging then kill the GUD buffer with @kbd{C-x k},
+which will also kill all the buffers associated with the session.
+However you need not do this if, after editing and re-compiling your
+source code within Emacs, you wish continue debugging. When you
+restart execution, GDB will automatically find your new executable.
+Keeping the GUD buffer has the advantage of keeping the shell history
+as well as GDB's breakpoints. You need to check, however, that the
+breakpoints in the recently edited code are still where you want them.
+
+@node Breakpoints Buffer
+@subsubsection Breakpoints Buffer
+
+The breakpoints buffer shows the existing breakpoints and watchpoints
+(@pxref{Breakpoints,,, gdb, The GNU debugger}). It has three special
+commands:
+
+@table @kbd
+@item @key{SPC}
+@kindex SPC @r{(GDB breakpoints buffer)}
+@findex gdb-toggle-breakpoint
+Enable/disable the breakpoint at the current line
+(@code{gdb-toggle-breakpoint}). On a graphical display, this changes
+the color of a bullet in the margin of the source buffer at the
+relevant line. This is red when the breakpoint is enabled and grey
+when it is disabled. Text-only terminals correspondingly display
+a @samp{B} or @samp{b}.
+
+@item @kbd{d}
+@kindex d @r{(GDB breakpoints buffer)}
+@findex gdb-delete-breakpoint
+Delete the breakpoint at the current line (@code{gdb-delete-breakpoint}).
+
+@item @key{RET}
+@kindex RET @r{(GDB breakpoints buffer)}
+@findex gdb-goto-breakpoint
+Display the file in the source buffer at the breakpoint specified at
+the current line (@code{gdb-goto-breakpoint}). Alternatively, click @kbd{Mouse-2} on the breakpoint that you wish to visit.
+@end table
+
+@node Stack Buffer
+@subsubsection Stack Buffer
+
+The stack buffer displays a @dfn{call stack}, with one line for each
+of the nested subroutine calls (@dfn{stack frames}) now active in the
+program. @xref{Backtrace,,info stack, gdb, The GNU debugger}.
+
+Move point to any frame in the stack and type @key{RET} to make it
+become the current frame (@code{gdb-frames-select}) and display the
+associated source in the source buffer. Alternatively, click
+@kbd{Mouse-2} to make the selected frame become the current one. If the
+locals buffer is displayed then its contents update to display the
+variables that are local to the new frame.
+
+@node Watch Expressions
+@subsubsection Watch Expressions
+@cindex Watching expressions in GDB
+
+If you want to see how a variable changes each time your program stops
+then place the cursor over the variable name and click on the watch
+icon in the toolbar (@code{gud-watch}).
+
+Each watch expression is displayed in the speedbar. Complex data
+types, such as arrays, structures and unions are represented in a tree
+format. To expand or contract a complex data type, click @kbd{Mouse-2}
+on the tag to the left of the expression.
+
+@kindex RET @r{(GDB speedbar)}
+@findex gdb-var-delete
+With the cursor over the root expression of a complex data type, type
+@kbd{D} to delete it from the speedbar
+(@code{gdb-var-delete}).
+
+@findex gdb-edit-value
+With the cursor over a simple data type or an element of a complex
+data type which holds a value, type @key{RET} or click @kbd{Mouse-2} to edit
+its value. A prompt for a new value appears in the mini-buffer
+(@code{gdb-edit-value}).
+
+If you set the variable @code{gdb-show-changed-values} to
+non-@code{nil} (the default value), then Emacs will use
+font-lock-warning-face to display values that have recently changed in
+the speedbar.
+
+If you set the variable @code{gdb-use-colon-colon-notation} to a
+non-@code{nil} value, then, in C, Emacs will use the
+FUNCTION::VARIABLE format to display variables in the speedbar.
+Since this does not work for variables defined in compound statements,
+the default value is @code{nil}.
+
+@node Other Buffers
+@subsubsection Other Buffers
+
+@table @asis
+@item Input/Output Buffer
+If the variable @code{gdb-use-inferior-io-buffer} is non-@code{nil},
+the executable program that is being debugged takes its input and
+displays its output here. Some of the commands from shell mode are
+available here. @xref{Shell Mode}.
+
+@item Locals Buffer
+The locals buffer displays the values of local variables of the
+current frame for simple data types (@pxref{Frame Info,,, gdb, The GNU
+debugger}).
+
+Arrays and structures display their type only. You must display them
+separately to examine their values. @ref{Watch Expressions}.
+
+@item Registers Buffer
+The registers buffer displays the values held by the registers
+(@pxref{Registers,,, gdb, The GNU debugger}).
+
+@item Assembler Buffer
+The assembler buffer displays the current frame as machine code. An
+overlay arrow points to the current instruction and you can set and
+remove breakpoints as with the source buffer. Breakpoint icons also
+appear in the fringe or margin.
+
+@item Threads Buffer
+
+The threads buffer displays a summary of all threads currently in your
+program (@pxref{Threads,,, gdb, The GNU debugger}). Move point to
+any thread in the list and type @key{RET} to make it become the
+current thread (@code{gdb-threads-select}) and display the associated
+source in the source buffer. Alternatively, click @kbd{Mouse-2} to
+make the selected thread become the current one.
+
+@item Memory Buffer
+
+The memory buffer allows the user to examine sections of program
+memory (@pxref{Memory,,, gdb, The GNU debugger}). Click @kbd{Mouse-1}
+on the appropriate part of the header line to change the starting
+address or number of data items that the buffer displays.
+Click @kbd{Mouse-3} on the header line to select the display format
+or unit size for these data items.
+
+@end table
+
@node Executing Lisp
@section Executing Lisp Expressions
compiled file, since it will load and run faster.
If @code{load-library} finds that @file{@var{lib}.el} is newer than
-@file{@var{lib}.elc} file, it prints a warning, because it's likely that
+@file{@var{lib}.elc} file, it issues a warning, because it's likely that
somebody made changes to the @file{.el} file and forgot to recompile
it.
Thus, the compiled code for @file{foo.el} goes in @file{foo.elc}.
That's why @code{load-library} searches for @samp{.elc} files first.
+@vindex load-dangerous-libraries
+@cindex Lisp files byte-compiled by XEmacs
+ By default, Emacs refuses to load compiled Lisp files which were
+compiled with XEmacs, a modified versions of Emacs---they can cause
+Emacs to crash. Set the variable @code{load-dangerous-libraries} to
+@code{t} if you want to try loading them.
+
@node Lisp Eval
-@section Evaluating Emacs-Lisp Expressions
+@section Evaluating Emacs Lisp Expressions
@cindex Emacs-Lisp mode
@cindex mode, Emacs-Lisp
Evaluate all the Lisp expressions in the buffer.
@end table
+@ifinfo
+@c This uses ``colon'' instead of a literal `:' because Info cannot
+@c cope with a `:' in a menu
+@kindex M-@key{colon}
+@end ifinfo
+@ifnotinfo
@kindex M-:
+@end ifnotinfo
@findex eval-expression
@kbd{M-:} (@code{eval-expression}) is the most basic command for evaluating
a Lisp expression interactively. It reads the expression using the
variable to the initial value specified in the @code{defvar} expression.
@code{defcustom} expressions are treated similarly.
This special feature is convenient for debugging Lisp programs.
+Typing @kbd{C-M-x} on a @code{defface} expression reinitializes
+the face according to the @code{defface} specification.
@kindex C-x C-e
@findex eval-last-sexp
region as one or more Lisp expressions, evaluating them one by one.
@kbd{M-x eval-current-buffer} is similar but evaluates the entire
buffer. This is a reasonable way to install the contents of a file of
-Lisp code that you are just ready to test. Later, as you find bugs and
+Lisp code that you are ready to test. Later, as you find bugs and
change individual functions, use @kbd{C-M-x} on each function that you
change. This keeps the Lisp world in step with the source file.
the function definition that point is in, but the way of doing so is
different according to where the relevant Lisp environment is found.
@xref{Executing Lisp}.
+
+@ignore
+ arch-tag: 9c3c2f71-b332-4144-8500-3ff9945a50ed
+@end ignore