Go to the first, previous, next, last section, table of contents.
The previous chapter discusses the Emacs commands that are useful for making changes in programs. This chapter deals with commands that assist in the larger process of developing and maintaining programs.
Emacs can run compilers for noninteractive languages such as C and Fortran as inferior processes, feeding the error log into an Emacs buffer. It can also parse the error messages and show you the source lines where compilation errors occurred.
grep asynchronously under Emacs, with matching lines
listed in the buffer named `*grep*'.
grep via find, with user-specified arguments, and
collect output in the buffer named `*grep*'.
grep subprocess.
To run make or another compilation command, do M-x
compile. This command reads a shell command line using the minibuffer,
and then executes the command in an inferior shell, putting output in
the buffer named `*compilation*'. The current buffer's default
directory is used as the working directory for the execution of the
command; normally, therefore, the compilation happens in this
directory.
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 M-x compile. If you type just RET, the same command
line is used again. For the first M-x compile, the default is
`make -k'. The default compilation command comes from the variable
compile-command; if the appropriate compilation command for a
file is something other than `make -k', it can be useful for the
file to specify a local value for compile-command (see section Local Variables in Files).
Starting a compilation displays the buffer `*compilation*' in another window but does not select it. The buffer's mode line tells you whether compilation is finished, with the word `run' or `exit' inside the parentheses. You do not have to keep this buffer visible; compilation continues in any case. While a compilation is going on, the string `Compiling' appears in the mode lines of all windows. When this string disappears, the compilation is finished.
If you want to watch the compilation transcript as it appears, switch to the `*compilation*' buffer and move point to the end of the buffer. When point is at the end, new compilation output is inserted above point, which remains at the end. If point is not at the end of the buffer, it remains fixed while more compilation output is added at the end of the buffer.
If you set the variable compilation-scroll-output to a
non-nil value, then the compilation buffer always scrolls to
follow output as it comes in.
To kill the compilation process, do M-x kill-compilation. When the compiler process terminates, the mode line of the `*compilation*' buffer changes to say `signal' instead of `run'. Starting a new compilation also kills any running compilation, as only one can exist at any time. However, M-x compile asks for confirmation before actually killing a compilation that is running.
Just as you can run a compiler from Emacs and then visit the lines
where there were compilation errors, you can also run grep and
then visit the lines on which matches were found. This works by
treating the matches reported by grep as if they were "errors."
To do this, type M-x grep, then enter a command line that
specifies how to run grep. Use the same arguments you would give
grep when running it normally: a grep-style regexp
(usually in single-quotes to quote the shell's special characters)
followed by file names, which may use wildcards. The output from
grep goes in the `*grep*' buffer. You can find the
corresponding lines in the original files using C-x ` and
RET, as with compilation errors.
If you specify a prefix argument for M-x grep, it figures out
the tag (see section Tags Tables) around point, and puts that into the default
grep command.
The command M-x grep-find is similar to M-x grep, but it
supplies a different initial default for the command--one that runs
both find and grep, so as to search every file in a
directory tree. See also the find-grep-dired command,
in section Dired and find.
The `*compilation*' buffer uses a special major mode, Compilation mode, whose main feature is to provide a convenient way to look at the source line where the error happened.
grep match.
You can visit the source for any particular error message by moving
point in `*compilation*' to that error message and typing RET
(compile-goto-error). Or click Mouse-2 on the error message;
you need not switch to the `*compilation*' buffer first.
To parse the compiler error messages sequentially, type C-x `
(next-error). The character following the C-x is the
backquote or "grave accent," not the single-quote. This command is
available in all buffers, not just in `*compilation*'; it displays
the next error message at the top of one window and source location of
the error in another window.
The first time C-x ` is used after the start of a compilation, it moves to the first error's location. Subsequent uses of C-x ` advance down to subsequent errors. If you visit a specific error message with RET or Mouse-2, subsequent C-x ` commands advance from there. When C-x ` gets to the end of the buffer and finds no more error messages to visit, it fails and signals an Emacs error.
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.
Compilation mode also redefines the keys SPC and DEL to scroll by screenfuls, and M-n and M-p to move to the next or previous error message. You can also use M-{ and M-} to move up or down to an error message for a different source file.
The features of Compilation mode are also available in a minor mode called Compilation Minor mode. This lets you parse error messages in any buffer, not just a normal compilation output buffer. Type M-x compilation-minor-mode to enable the minor mode. This defines the keys RET and Mouse-2, as in the Compilation major mode.
Compilation minor mode works in any buffer, as long as the contents are in a format that it understands. In an Rlogin buffer (see section Remote Host Shell), Compilation minor mode automatically accesses remote source files by FTP (see section File Names).
Emacs uses a shell to run the compilation command, but specifies the option for a noninteractive shell. This means, in particular, that the shell should start with no prompt. If you find your usual shell prompt making an unsightly appearance in the `*compilation*' buffer, it means you have made a mistake in your shell's init file by setting the prompt unconditionally. (This init file's name may be `.bashrc', `.profile', `.cshrc', `.shrc', or various other things, depending on the shell you use.) The shell init file should set the prompt only if there already is a prompt. In csh, here is how to do it:
if ($?prompt) set prompt = ...
And here's how to do it in bash:
if [ "${PS1+set}" = set ]
then PS1=...
fi
There may well be other things that your shell's init file ought to do only for an interactive shell. You can use the same method to conditionalize them.
The MS-DOS "operating system" does not support asynchronous subprocesses; to work around this lack, M-x compile runs the compilation command synchronously on MS-DOS. As a consequence, you must wait until the command finishes before you can do anything else in Emacs. See section Emacs and MS-DOS.
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.
There are several commands for starting a debugger, each corresponding to a particular debugger program.
gud-xdb-directories to specify directories to search for source
files.
Each of these commands takes one argument: a command line to invoke the debugger. In the simplest case, specify just the name of the executable file you want to debug. You may also use options that the debugger supports. However, shell wildcards and variables are not allowed. GUD assumes that the first argument not starting with a `-' is the executable file name.
Emacs can only run one debugger process at a time.
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 (`=>') in one of these buffers indicates the current execution line. 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 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 before your changes to the line number in a debugger message. Also, you'll typically have to recompile and restart the program for your changes to be reflected in the debugger's tables.
If you wish, you can control your debugger process entirely through the debugger buffer, which uses a variant of Shell mode. All the usual commands for your debugger are available, and you can use the Shell mode history commands to repeat them. See section Shell Mode.
The GUD interaction buffer uses a variant of Shell mode, so the commands of Shell mode are available (see section Shell Mode). GUD mode 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.
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:
Here are the other special commands provided by GUD. The keys starting with C-c are available only in the GUD interaction buffer. The key bindings that start with C-x C-a are available in the GUD interaction buffer and also in source files.
gud-refresh.
gud-step). If the line contains
a function call, execution stops after entering the called function.
gud-next).
gud-stepi).
gud-cont).
gud-remove). If you use this command in the GUD interaction
buffer, it applies to the line where the program last stopped.
The above commands are common to all supported debuggers. If you are using GDB or (some versions of) DBX, these additional commands are available:
gud-up). This is
equivalent to the `up' command.
gud-down). This is
equivalent to the `down' command.
If you are using GDB, these additional key bindings are available:
gud-gdb-complete-command).
This key is available only in the GUD interaction buffer, and requires
GDB versions 4.13 and later.
These commands interpret a numeric argument as a repeat count, when that makes sense.
Because TAB serves as a completion command, you can't use it to enter a tab as input to the program you are debugging with GDB. Instead, type C-q TAB to enter a tab.
On startup, GUD runs one of the following hooks: gdb-mode-hook,
if you are using GDB; dbx-mode-hook, if you are using DBX;
sdb-mode-hook, if you are using SDB; xdb-mode-hook, if you
are using XDB; perldb-mode-hook, for Perl debugging mode;
jdb-mode-hook, for PDB; jdb-mode-hook, for JDB. You can
use these hooks to define custom key bindings for the debugger
interaction buffer. See section Hooks.
Here is a convenient way to define a command that sends a particular command string to the debugger, and set up a key binding for it in the debugger interaction buffer:
(gud-def function cmdstring binding docstring)
This defines a command named function which sends
cmdstring to the debugger process, and gives it the documentation
string docstring. You can use the command thus defined in any
buffer. If binding is non-nil, gud-def also binds
the command to C-c binding in the GUD buffer's mode and to
C-x C-a binding generally.
The command string cmdstring may contain certain `%'-sequences that stand for data to be filled in at the time function is called:
Emacs has several different major modes for Lisp and Scheme. They are the same in terms of editing commands, but differ in the commands for executing Lisp expressions. Each mode has its own purpose.
Most editing commands for working with Lisp programs are in fact available globally. See section Editing Programs.
Lisp code for Emacs editing commands is stored in files whose names conventionally end in `.el'. This ending tells Emacs to edit them in Emacs-Lisp mode (see section Executing Lisp Expressions).
To execute a file of Emacs Lisp code, use M-x load-file. This command reads a file name using the minibuffer and then executes the contents of that file as Lisp code. It is not necessary to visit the file first; in any case, this command reads the file as found on disk, not text in an Emacs buffer.
Once a file of Lisp code is installed in the Emacs Lisp library
directories, users can load it using M-x load-library. Programs can
load it by calling load-library, or with load, a more primitive
function that is similar but accepts some additional arguments.
M-x load-library differs from M-x load-file in that it searches a sequence of directories and tries three file names in each directory. Suppose your argument is lib; the three names are `lib.elc', `lib.el', and lastly just `lib'. If `lib.elc' exists, it is by convention the result of compiling `lib.el'; it is better to load the compiled file, since it will load and run faster.
If load-library finds that `lib.el' is newer than
`lib.elc' file, it prints a warning, because it's likely that
somebody made changes to the `.el' file and forgot to recompile
it.
Because the argument to load-library is usually not in itself
a valid file name, file name completion is not available. Indeed, when
using this command, you usually do not know exactly what file name
will be used.
The sequence of directories searched by M-x load-library is
specified by the variable load-path, a list of strings that are
directory names. The default value of the list contains the directory where
the Lisp code for Emacs itself is stored. If you have libraries of
your own, put them in a single directory and add that directory
to load-path. nil in this list stands for the current default
directory, but it is probably not a good idea to put nil in the
list. If you find yourself wishing that nil were in the list,
most likely what you really want to do is use M-x load-file
this once.
Often you do not have to give any command to load a library, because
the commands defined in the library are set up to autoload that
library. Trying to run any of those commands calls load to load
the library; this replaces the autoload definitions with the real ones
from the library.
Emacs Lisp code can be compiled into byte-code which loads faster,
takes up less space when loaded, and executes faster. See section `Byte Compilation' in the Emacs Lisp Reference Manual.
By convention, the compiled code for a library goes in a separate file
whose name consists of the library source file with `c' appended.
Thus, the compiled code for `foo.el' goes in `foo.elc'.
That's why load-library searches for `.elc' files first.
Lisp programs intended to be run in Emacs should be edited in Emacs-Lisp mode; this happens automatically for file names ending in `.el'. By contrast, Lisp mode itself is used for editing Lisp programs intended for other Lisp systems. To switch to Emacs-Lisp mode explicitly, use the command M-x emacs-lisp-mode.
For testing of Lisp programs to run in Emacs, it is often useful to evaluate part of the program as it is found in the Emacs buffer. For example, after changing the text of a Lisp function definition, evaluating the definition installs the change for future calls to the function. Evaluation of Lisp expressions is also useful in any kind of editing, for invoking noninteractive functions (functions that are not commands).
eval-expression).
eval-last-sexp).
eval-defun).
M-: (eval-expression) is the most basic command for evaluating
a Lisp expression interactively. It reads the expression using the
minibuffer, so you can execute any expression on a buffer regardless of
what the buffer contains. When the expression is evaluated, the current
buffer is once again the buffer that was current when M-: was
typed.
In Emacs-Lisp mode, the key C-M-x is bound to the command
eval-defun, which parses the defun containing or following point
as a Lisp expression and evaluates it. The value is printed in the echo
area. This command is convenient for installing in the Lisp environment
changes that you have just made in the text of a function definition.
C-M-x treats defvar expressions specially. Normally,
evaluating a defvar expression does nothing if the variable it
defines already has a value. But C-M-x unconditionally resets the
variable to the initial value specified in the defvar expression.
This special feature is convenient for debugging Lisp programs.
The command C-x C-e (eval-last-sexp) evaluates the Lisp
expression preceding point in the buffer, and displays the value in the
echo area. It is available in all major modes, not just Emacs-Lisp
mode. It does not treat defvar specially.
If C-M-x, C-x C-e, or M-: is given a numeric argument, it inserts the value into the current buffer at point, rather than displaying it in the echo area. The argument's value does not matter.
The most general command for evaluating Lisp expressions from a buffer
is eval-region. M-x eval-region parses the text of the
region as one or more Lisp expressions, evaluating them one by one.
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
change individual functions, use C-M-x on each function that you
change. This keeps the Lisp world in step with the source file.
The buffer `*scratch*' which is selected when Emacs starts up is provided for evaluating Lisp expressions interactively inside Emacs.
The simplest way to use the `*scratch*' buffer is to insert Lisp expressions and type C-j after each expression. This command reads the Lisp expression before point, evaluates it, and inserts the value in printed representation before point. The result is a complete typescript of the expressions you have evaluated and their values.
The `*scratch*' buffer's major mode is Lisp Interaction mode, which is the same as Emacs-Lisp mode except for the binding of C-j.
The rationale for this feature is that Emacs must have a buffer when it starts up, but that buffer is not useful for editing files since a new buffer is made for every file that you visit. The Lisp interpreter typescript is the most useful thing I can think of for the initial buffer to do. Type M-x lisp-interaction-mode to put the current buffer in Lisp Interaction mode.
An alternative way of evaluating Emacs Lisp expressions interactively is to use Inferior Emacs-Lisp mode, which provides an interface rather like Shell mode (see section Shell Mode) for evaluating Emacs Lisp expressions. Type M-x ielm to create an `*ielm*' buffer which uses this mode.
Emacs has facilities for running programs in other Lisp systems. You can run a Lisp process as an inferior of Emacs, and pass expressions to it to be evaluated. You can also pass changed function definitions directly from the Emacs buffers in which you edit the Lisp programs to the inferior Lisp process.
To run an inferior Lisp process, type M-x run-lisp. This runs
the program named lisp, the same program you would run by typing
lisp as a shell command, with both input and output going through
an Emacs buffer named `*lisp*'. That is to say, any "terminal
output" from Lisp will go into the buffer, advancing point, and any
"terminal input" for Lisp comes from text in the buffer. (You can
change the name of the Lisp executable file by setting the variable
inferior-lisp-program.)
To give input to Lisp, go to the end of the buffer and type the input, terminated by RET. The `*lisp*' buffer is in Inferior Lisp mode, which combines the special characteristics of Lisp mode with most of the features of Shell mode (see section Shell Mode). The definition of RET to send a line to a subprocess is one of the features of Shell mode.
For the source files of programs to run in external Lisps, use Lisp mode. This mode can be selected with M-x lisp-mode, and is used automatically for files whose names end in `.l', `.lsp', or `.lisp', as most Lisp systems usually expect.
When you edit a function in a Lisp program you are running, the easiest
way to send the changed definition to the inferior Lisp process is the key
C-M-x. In Lisp mode, this runs the function lisp-eval-defun,
which finds the defun around or following point and sends it as input to
the Lisp process. (Emacs can send input to any inferior process regardless
of what buffer is current.)
Contrast the meanings of C-M-x in Lisp mode (for editing programs to be run in another Lisp system) and Emacs-Lisp mode (for editing Lisp programs to be run in Emacs): in both modes it has the effect of installing the function definition that point is in, but the way of doing so is different according to where the relevant Lisp environment is found. See section Executing Lisp Expressions.
Go to the first, previous, next, last section, table of contents.