Go to the previous, next section.
This chapter contains several brief topics that do not fit anywhere else.
A recursive edit is a situation in which you are using Emacs
commands to perform arbitrary editing while in the middle of another Emacs
command. For example, when you type C-r inside of a query-replace,
you enter a recursive edit in which you can change the current buffer. On
exiting from the recursive edit, you go back to the query-replace.
Exiting the recursive edit means returning to the unfinished
command, which continues execution. For example, exiting the recursive
edit requested by C-r in query-replace causes query replacing
to resume. Exiting is done with C-M-c (exit-recursive-edit).
You can also abort the recursive edit. This is like exiting, but
also quits the unfinished command immediately. Use the command C-]
(abort-recursive-edit) for this. See section Quitting and Aborting.
The mode line shows you when you are in a recursive edit by displaying square brackets around the parentheses that always surround the major and minor mode names. Every window's mode line shows this, in the same way, since being in a recursive edit is true of Emacs as a whole rather than any particular buffer.
It is possible to be in recursive edits within recursive edits. For
example, after typing C-r in a query-replace, you might type a
command that entered the debugger. In such circumstances, two or more sets
of square brackets appear in the mode line. Exiting the inner recursive
edit (such as, with the debugger c command) would resume the command
where it called the debugger. After the end of this command, you would be
able to exit the first recursive edit. Aborting also gets out of only one
level of recursive edit; it returns immediately to the command level of the
previous recursive edit. So you could immediately abort that one too.
Alternatively, the command M-x top-level aborts all levels of recursive edits, returning immediately to the top level command reader.
The text being edited inside the recursive edit need not be the same text that you were editing at top level. It depends on what the recursive edit is for. If the command that invokes the recursive edit selects a different buffer first, that is the buffer you will edit recursively. In any case, you can switch buffers within the recursive edit in the normal manner (as long as the buffer-switching keys have not been rebound). You could probably do all the rest of your editing inside the recursive edit, visiting files and all. But this could have surprising effects (such as stack overflow) from time to time. So remember to exit or abort the recursive edit when you no longer need it.
In general, GNU Emacs tries to avoid using recursive edits. It is usually preferable to allow the user to switch among the possible editing modes in any order he likes. With recursive edits, the only way to get to another state is to go "back" to the state that the recursive edit was invoked from.
Narrowing means focusing in on some portion of the buffer, making the rest temporarily invisible and inaccessible. Cancelling the narrowing, and making the entire buffer once again visible, is called widening. The amount of narrowing in effect in a buffer at any time is called the buffer's restriction.
narrow-to-region).
widen).
When you have narrowed down to a part of the buffer, that part appears to be all there is. You can't see the rest, you can't move into it (motion commands won't go outside the visible part), you can't change it in any way. However, it is not gone, and if you save the file all the invisible text will be saved. In addition to sometimes making it easier to concentrate on a single subroutine or paragraph by eliminating clutter, narrowing can be used to restrict the range of operation of a replace command or repeating keyboard macro. The word `Narrow' appears in the mode line whenever narrowing is in effect.
The primary narrowing command is C-x n (narrow-to-region).
It sets the current buffer's restrictions so that the text in the current
region remains visible but all text before the region or after the region
is invisible. Point and mark do not change.
Because narrowing can easily confuse users who do not understand it,
narrow-to-region is normally a disabled command. Attempting to use
this command asks for confirmation and gives you the option of enabling it;
once you enable the command, confirmation will no longer be required for
it. See section Disabling Commands.
The way to undo narrowing is to widen with C-x w (widen).
This makes all text in the buffer accessible again.
You can get information on what part of the buffer you are narrowed down to using the C-x = command. See section Cursor Position Information.
Emacs provides several commands for sorting text in the buffer. All operate on the contents of the region (the text between point and the mark). They divide the text of the region into many sort records, identify a sort key for each record, and then reorder the records into the order determined by the sort keys. The records are ordered so that their keys are in alphabetical order, or, for numeric sorting, in numeric order. In alphabetic sorting, all upper case letters `A' through `Z' come before lower case `a', in accord with the ASCII character sequence.
The various sort commands differ in how they divide the text into sort records and in which part of each record is used as the sort key. Most of the commands make each line a separate sort record, but some commands use paragraphs or pages as sort records. Most of the sort commands use each entire sort record as its own sort key, but some use only a portion of the record as the sort key.
You specify which field to sort by with a numeric argument: 1 to sort by field 1, etc. A negative argument means sort into descending order. Thus, minus 2 means sort by field 2 in reverse-alphabetical order.
If two lines are equal in the field being compared, their relative order in the text is not changed. This enables you to sort by multiple keys: sort first by the least significant key, then by the next-to-least key, and so on, ending with the most important key.
For example, if the buffer contains
On systems where clash detection (locking of files being edited) is implemented, Emacs also checks the first time you modify a buffer whether the file has changed on disk since it was last visited or saved. If it has, you are asked to confirm that you want to change the buffer.
then if you apply M-x sort-lines to the entire buffer you get
On systems where clash detection (locking of files being edited) is implemented, Emacs also checks the first time you modify a buffer saved. If it has, you are asked to confirm that you want to change the buffer. whether the file has changed on disk since it was last visited or
where the upper case `O' comes before all lower case letters. If you apply instead C-u 2 M-x sort-fields you get
implemented, Emacs also checks the first time you modify a buffer saved. If it has, you are asked to confirm that you want to change the buffer. On systems where clash detection (locking of files being edited) is whether the file has changed on disk since it was last visited or
where the sort keys were `Emacs', `If', `buffer', `systems' and `the'.
M-x sort-columns requires more explanation. You specify the columns by putting point at one of the columns and the mark at the other column. Because this means you cannot put point or the mark at the beginning of the first line to sort, this command uses an unusual definition of `region': all of the line point is in is considered part of the region, and so is all of the line the mark is in.
For example, to sort a table by information found in columns 10 to 15, you could put the mark on column 10 in the first line of the table, and point on column 15 in the last line of the table, and then use this command. Or you could put the mark on column 15 in the first line and point on column 10 in the last line.
This can be thought of as sorting the rectangle specified by point and the mark, except that the text on each line to the left or right of the rectangle moves along with the text inside the rectangle. See section Rectangles.
Emacs has commands for passing single command lines to inferior shell processes; it can also run a shell interactively with input and output to an Emacs buffer `*shell*'.
shell-command).
shell-command-on-region).
M-! (shell-command) reads a line of text using the
minibuffer and creates an inferior shell to execute the line as a command.
Standard input from the command comes from the null device. If the shell
command produces any output, the output goes into an Emacs buffer named
`*Shell Command Output*', which is displayed in another window but not
selected. A numeric argument, as in M-1 M-!, directs this command to
insert any output into the current buffer. In that case, point is left
before the output and the mark is set after the output.
M-| (shell-command-on-region) is like M-! but passes
the contents of the region as input to the shell command, instead of no
input. If a numeric argument is used, meaning insert output in the current
buffer, then the old region is deleted first and the output replaces it as
the contents of the region.
Both M-! and M-| use shell-file-name to specify the
shell to use. This variable is initialized based on your SHELL
environment variable when Emacs is started. If the file name does not
specify a directory, the directories in the list exec-path are
searched; this list is initialized based on the environment variable
PATH when Emacs is started. Your `.emacs' file can override
either or both of these default initializations.
With M-! and M-|, Emacs has to wait until the shell command completes. You can quit with C-g; that terminates the shell command.
To run a subshell interactively, putting its typescript in an Emacs buffer, use M-x shell. This creates (or reuses) a buffer named `*shell*' and runs a subshell with input coming from and output going to that buffer. That is to say, any "terminal output" from the subshell will go into the buffer, advancing point, and any "terminal input" for the subshell comes from text in the buffer. To give input to the subshell, go to the end of the buffer and type the input, terminated by RET.
Emacs does not wait for the subshell to do anything. You can switch windows or buffers and edit them while the shell is waiting, or while it is running a command. Output from the subshell waits until Emacs has time to process it; this happens whenever Emacs is waiting for keyboard input or for time to elapse.
If you would like multiple subshells, change the name of buffer `*shell*' to something different by using M-x rename-buffer. The next use of M-x shell will create a new buffer `*shell*' with its own subshell. By renaming this buffer as well you can create a third one, and so on. All the subshells run independently and in parallel.
The file name used to load the subshell is the value of the variable
explicit-shell-file-name, if that is non-nil. Otherwise, the
environment variable ESHELL is used, or the environment variable
SHELL if there is no ESHELL. If the file name specified
is relative, the directories in the list exec-path are searched
(see section Single Shell Commands).
As soon as the subshell is started, it is sent as input the contents of
the file `~/.emacs_shellname', if that file exists, where
shellname is the name of the file that the shell was loaded
from. For example, if you use csh, the file sent to it is
`~/.emacs_csh'; if you use the Bourne-Again shell, the file sent
to it is `~/.emacs_bash'.
cd, pushd and popd commands given to the inferior
shell are watched by Emacs so it can keep the `*shell*' buffer's
default directory the same as the shell's working directory. These
commands are recognized syntactically by examining lines of input that are
sent. If you use aliases for these commands, you can tell Emacs to
recognize them also. For example, if the value of the variable
shell-pushd-regexp matches the beginning of a shell command line,
that line is regarded as a pushd command. Change this variable when
you add aliases for `pushd'. Likewise, shell-popd-regexp and
shell-cd-regexp are used to recognize commands with the meaning of
`popd' and `cd'. These commands are recognized only at the
beginning of a shell command line.
If Emacs gets an error while trying to handle what it believes is
a `cd', `pushd' or `popd' command, and the value of
shell-set-directory-error-hook is non-nil, that value is
called as a function with no arguments.
The shell buffer uses Shell mode, which defines several special keys attached to the C-c prefix. They are chosen to resemble the usual editing and job control characters present in shells that are not under Emacs, except that you must type C-c first. Here is a complete list of the special key bindings of Shell mode:
send-shell-input). When a line is copied, any
text at the beginning of the line that matches the variable
shell-prompt-pattern is left out; this variable's value should be a
regexp string that matches the prompts that you use in your subshell.
shell-send-eof).
kill-shell-input).
backward-kill-word).
interrupt-shell-subjob).
stop-shell-subjob).
quit-shell-subjob).
kill-output-from-shell).
show-output-from-shell).
copy-last-shell-input). No final newline
is inserted, and the input copied is not resubmitted until you type
RET.
The Emacs commands for making hardcopy derive their names from the Unix commands `print' and `lpr'.
print-buffer but prints only the current region.
lpr-buffer but prints only the current region.
All the hardcopy commands pass extra switches to the lpr
program based on the value of the variable lpr-switches. Its
value should be a list of strings, each string a switch starting with
`-'. For example, the value could be ("-Pfoo") to print on
printer `foo'. You can specify an alternative command to run
instead of lpr by setting the variable lpr-command.
M-x dissociated-press is a command for scrambling a file of text either word by word or character by character. Starting from a buffer of straight English, it produces extremely amusing output. The input comes from the current Emacs buffer. Dissociated Press writes its output in a buffer named `*Dissociation*', and redisplays that buffer after every couple of lines (approximately) to facilitate reading it.
dissociated-press asks every so often whether to continue
operating. Answer n to stop it. You can also stop at any time by
typing C-g. The dissociation output remains in the `*Dissociation*'
buffer for you to copy elsewhere if you wish.
Dissociated Press operates by jumping at random from one point in the buffer to another. In order to produce plausible output rather than gibberish, it insists on a certain amount of overlap between the end of one run of consecutive words or characters and the start of the next. That is, if it has just printed out `president' and then decides to jump to a different point in the file, it might spot the `ent' in `pentagon' and continue from there, producing `presidentagon'. Long sample texts produce the best results.
A positive argument to M-x dissociated-press tells it to operate character by character, and specifies the number of overlap characters. A negative argument tells it to operate word by word and specifies the number of overlap words. In this mode, whole words are treated as the elements to be permuted, rather than characters. No argument is equivalent to an argument of two. For your againformation, the output goes only into the buffer `*Dissociation*'. The buffer you start with is not changed.
Dissociated Press produces nearly the same results as a Markov chain based on a frequency table constructed from the sample text. It is, however, an independent, ignoriginal invention. Dissociated Press techniquitously copies several consecutive characters from the sample between random choices, whereas a Markov chain would choose randomly for each word or character. This makes for more plausible sounding results, and runs faster.
It is a mustatement that too much use of Dissociated Press can be a developediment to your real work. Sometimes to the point of outragedy. And keep dissociwords out of your documentation, if you want it to be well userenced and properbose. Have fun. Your buggestions are welcome.
If you are a little bit bored, you can try M-x hanoi. If you are considerably bored, give it a numeric argument. If you are very very bored, try an argument of 9. Sit back and watch.
When you are frustrated, try the famous Eliza program. Just do M-x doctor. End each input by typing RET twice.
When you are feeling strange, type M-x yow.
GNU Emacs can be programmed to emulate (more or less) most other editors. Standard facilities can emulate these:
Most of the EDT emulation commands are keypad keys, and most standard Emacs key bindings are still available. The EDT emulation rebindings are done in the global keymap, so there is no problem switching buffers or major modes while in EDT emulation.
It is also possible to run Mocklisp code written for Gosling Emacs. See section Converting Mocklisp to Lisp.
Because vi emulation works through major modes, it does not work to switch buffers during emulation. Return to normal Emacs first.
If you plan to use vi emulation much, you probably want to bind a key
to the vi-mode command.
This emulation does not work through major modes, and it is possible
to switch buffers in various ways within the emulator. It is not
so necessary to assign a key to the command vip-mode as
it is with vi-mode because terminating insert mode does
not use it.
For full information, see the long comment at the beginning of the source file, which is `lisp/vip.el' in the Emacs distribution.
I am interested in hearing which vi emulator users prefer, as well as in receiving more complete user documentation for either or both emulators. Warning: loading both at once may cause name conficts; no one has checked.
Go to the previous, next section.