The current version of MicroEMACS is 4.00 and for the rest of this document, we shall simply refer to this version as "EMACS". Any modifications for later versions will be in the file README on the MicroEMACS distribution disk.
Many times throughout this manual we will be talking about commands and the keys on the keyboard needed to use them. There are a number of "special" keys which can be used and are listed here:
| <NL> | NewLine which is also called RETURN, ENTER, or |
|---|---|
| ^ | The control key can be used before any alphabetic
character and some symbols. For example, ^C means to
hold down the |
| ^X | The CONTROL-X key is used at the beginning of many different commands. |
| META or M- | This is a special EMACS key used to begin many commands. This key is pressed and then released before typing the next character. On Sun Unix systems, this is the <ESC> key,but it can be changed. (consult appendix E to learn what key is used for META on your computer). |
Whenever a command is described, the manual will list the actual keystrokes needed to execute it in boldface using the above conventions, and also the name of the command in italics.
In order to use EMACS, you must call it up from your system or
computer's command prompt. On UNIX and MSDOS machines, just type "emacs"
from the command prompt and follow it with the
The screen is divided into a number of areas or windows. On some
systems the top window contains a function list of unshifted and shifted
function keys. We will discuss these keys later. Below them is an EMACS
mode line which, as we will see, informs you of the present mode of
operation of the editor--for example "(WRAP)" if you set EMACS to wrap at
the end of each line. Under the mode line is the text window where text
appears and is manipulated. Since each window has its own mode line, below
the text window is it's mode line. The last line of the screen is the
command line where EMACS takes commands and reports on what it is doing.
Entering text in EMACS is simple. Type the following sentence
fragment:
The text is displayed at the top of the text window. Now type:
Notice that some of your text has dissapeared off the left side of
the screen. Don't panic--your text is safe!!! You've just discovered that
EMACS doesn't "wrap" text to the next line like most word processors
unless you hit <NL>. But since EMACS is used for both word processing, and
text editing, it has a bit of a dual personality. You can change the way
it works by setting various modes. In this case, you need to set WRAP
mode, using the add-mode command, by typing ^XM. The command line at the
base of the screen will prompt you for the mode you wish to add. Type wrap
followed by the <NL> key and any text you now enter will be wrapped.
However, the command doesn't wrap text already entered. To get rid of the
long line, press and hold down the <BACKSPACE> key until the line is gone.
Now type in the words you deleted, watch how EMACS goes down to the next
line at the right time. (In some versions of EMACS, WRAP is a default mode
in which case you don't have to worry about the instructions relating to
adding this mode.)
Now let's type a longer insert. Hit
Fang Rock lighthouse, center of a series of mysterious and
terrifying events at the turn of the century, is built on a
rocky island a few miles of the Channel coast. So small is the
island that wherever you stand its rocks are wet with sea spray.
The lighthouse tower is in the center of the island. A steep
flight of steps leads to the heavy door in its base. Winding
stairs lead up to the crew room.
Now let's practice moving around in this text. To move the cursor
back to the word "Winding," enter M-B previous-word. This command moves
the cursor backwards by one word at a time. Note you have to press the key
combination every time the cursor steps back by one word. Continuously
pressing META and toggling B produces an error message. To move forward to
the word "stairs" enter M-F next-word, which moves the cursor forward by
one word at a time.
Notice that EMACS commands are usually mnemonic--F for forward, B
for backward, for example.
To move the cursor up one line, enter ^P previous-line, down one
line ^N next-line. Practice this movement by moving the cursor to the word
"terrifying" in the second line.
The cursor may also be moved forward or backward in smaller
increments. To move forward by one character, enter ^F forward-character,
to move backward, ^B backward-character. EMACS also allows you to specify
a number which is normally used to tell a command to execute many times.
To repeat most commands, press META and then the number before you enter
the command. Thus, the command META 5 ^F (M-5^F) will move the cursor
forward by five characters. Try moving around in the text by using these
commands. For extra practice, see how close you can come to the word
"small" in the first paragraph by giving an argument to the commands
listed here.
Two other simple cursor commands that are useful to help us move
around in the text are M-N next-paragraph which moves the cursor to the
second paragraph, and M-P previous-paragraph which moves it back to the
previous paragraph. The cursor may also be moved rapidly from one end of
the line to the other. Move the cursor to the word "few" in the second
line. Press ^A beginning-of-line. Notice the cursor moves to the word
"events" at the beginning of the line. Pressing ^E end-of-line moves the
cursor to the end of the line.
Finally, the cursor may be moved from any point in the file to the
end or beginning of the file. Entering M-> end-of-file moves the cursor to
the end of the buffer, M-< beginning-of-file to the first character of the
file.
On the IBM-PC, the ATARI ST and many other machines, the cursor
keys can also be used to move the cursor.
Practice moving the cursor in the text until you are comfortable
with the commands we've explored in this chapter.
When you've finished practicing cursor movement, save your file.
Your file currently resides in a BUFFER. The buffer is a temporary storage
area for your text, and is lost when the computer is turned off. You can
save the buffer to a file by entering M-y save-file. Notice that EMACS
informs you that your file has no name and will not let you save it.
To save your buffer to a file with a different name than it's
current one (which is empty), press ^X^W write-file. EMACS will prompt
you for the filename you wish to write. Enter the name fang.txt and press
return. On a micro, the drive light will come on, and EMACS will inform
you it is writing the file. When it finishes, it will inform you of the
number of lines it has written to the disk.
Congratulations!! You've just saved your first EMACS file!
In chapter 1, you learned how to enter text, how to use wrap mode,
how to move the cursor, and to save a buffer. The following is a table of
the commands covered in this chapter and their corresponding key bindings:
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation
In the first chapter, you learned how to create and save a file in
EMACS. Let's do some more editing on this file. Call up emacs by typing in
the following command.
emacs fang.txt
On icon oriented systems, double click on the uEMACS icon, usually
a file dialog box of some sort will appear. Choose FANG.TXT from the
appropriate folder.
Shortly after you invoke EMACS, the text should appear on the
screen ready for you to edit. The text you are looking at currently
resides in a buffer. A buffer is a temporary area of computer memory which
is the primary unit internal to EMACS -- this is the place where EMACS
goes to work. The mode line at the bottom of the screen lists the buffer
name, FANG.TXT and the name of the file with which this buffer is
associated, FANG.TXT
The computer talks to you through the use of its screen. This
screen usually has an area of 24 lines each of 80 characters across. You
can use EMACS to subdivide the screen into several separate work areas, or
windows, each of which can be 'looking into' different files or sections
of text. Using windows, you can work on several related texts at one time,
copying and moving blocks of text between windows with ease. To keep track
of what you are editing, each window is identified by a mode line on the
last line of the window which lists the name of the buffer which it is
looking into, the file from which the text was read, and how the text is
being edited.
An EMACS mode tells EMACS how to deal with user input. As we have
already seen, the mode 'WRAP' controls how EMACS deals with long lines
(lines with over 79 characters) while the user is typing them in. The
'VIEW' mode, allows you to read a file without modifying it. Modes are
associated with buffers and not with files; hence, a mode needs to be
explicitly set or removed every time you edit a file. A new file read into
a buffer with a previously specified mode will be edited under this mode.
If you use specific modes frequently, EMACS allows you to set the modes
which are used by all new buffers, called global modes.
Your previously-saved text should look like this:
Fang Rock lighthouse, center of a series of mysterious and
terrifying events at the turn of the century, is built on a
rocky island a few miles of the Channel coast. So small is the
island that wherever you stand its rocks are wet with sea spray.
The lighthouse tower is in the center of the island. A steep
flight of steps leads to the heavy door in its base. Winding
stairs lead up to the crew room.
Let's assume you want to add a sentence in the second paragraph
after the word base . Move the cursor until it is on the W of
Winding. Now type the following:
This gives entry to the lower floor where the big steam
generator throbs steadily away, providing power for the electric
lantern.
If the line fails to wrap and you end up with a '$' sign in the
right margin, just enter M-Q fill-paragraph to reformat the paragraph.
This new command attempts to fill out a paragraph. Long lines are divided
up, and words are shuffled around to make the paragraph look nicer.
Notice that all visible EMACS characters are self-inserting -- all
you had to do was type the characters to insert and the existing text made
space for it. With a few exceptions discussed later, all non-printing
characters (such as control or escape sequences) are commands. To insert
spaces, simply use the space bar. Now move to the first line of the file
and type ^O open-line (Oh, not zero). You've just learned how to insert a
blank line in your text.
EMACS offers a number of deletion options. For example, move the
cursor until it's under the period at the end of the insertion you just
did. Press the backspace key. Notice the "n" on "lantern" disappeared.
The backspace implemented on EMACS is called a destructive backspace--it
removes text immediately before the current cursor position from the
buffer. Now type ^H delete-previous-character. Notice that the cursor
moves back and obliterates the "r"--either command will backspace the
cursor.
Type in the two letters you erased to restore your text and move
the cursor to the beginning of the buffer M-> beginning-of-file. Move the
cursor down one line to the beginning of the first paragraph.
To delete the forward character, type ^D delete-next-character.
The "F" of "Fang" disappears. Continue to type ^D until the whole word is erased EMACS also permits the deletion of larger elements of text. Move
the cursor to the word center in the first line of text. Pressing
M-<backspace> delete-previous-word kills the word immediately before the
cursor. M-^H has the same effect.
Notice that the commands are very similar to the control commands
you used to delete individual letters. As a general rule in EMACS, control
sequences affect small areas of text, META sequences larger areas. The
word forward of the cursor position can therefore be deleted by typing M-D
delete-next-word. Now let's take out the remainder of the first line by
typing ^K kill-to-end-of-line. You now have a blank line at the top of
your screen. Typing ^K again or ^X^O delete-blank-lines deletes the blank
line and flushes the second line to the top of the text. Now exit EMACS by
typing ^X^C exit-emacs. Notice EMACS reminds you that you have not saved
your buffer. Ignore the warning and exit. This way you can exit EMACS
without saving any of the changes you just made.
In Chapter 2, you learned about the basic 'building blocks' of an
EMACS text file--buffers, windows, and files.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation 1.3 Parts and Pieces
f1 search-> f2 <-search | MicroEMACS: Text Editor
f3 hunt-> f4 <-hunt |
f5 fkeys f6 help | Available function key Pages include:
f7 nxt wind f8 pg[ ] | WORD BOX EMACS PASCAL C cObal Lisp
f9 save f10 exit | [use the f8 key to load Pages]
1.4 Entering Text
1.5 Basic cursor movement
1.6 Saving your text
Chapter 1 Summary
Key Binding Keystroke Effect
abort-command ^G aborts current command
add-mode ^XM allows addition of EMACS modes
backward-character ^B moves cursor left one character
beginning-of-file M-< moves cursor to beginning of file
beginning-of-line ^A moves cursor to beginning of line
end-of-file M-> moves cursor to end of file
end-of-line ^E moves cursor to end of line
forward-character ^F moves cursor right one character
next-line ^N moves cursor to next line
next-paragraph M-N moves cursor to next paragraph
next-word M-F moves cursor forward one word
previous-line ^P moves cursor backward by one line
previous-paragraph M-P moves cursor to previous paragraph
previous-word M-B moves cursor backward by one word
save-file M-y saves current buffer to a file
write-file ^X^W save current buffer under a new name
14 Jun 1996
Chapter 2
Basic Editing--Simple Insertions and Deletions
2.1 A Word About Windows, Buffers, Screens, and Modes
2.2 Insertions
2.3 Deletions
Chapter 2 Summary
Key binding Keystroke Effect delete-previous-character ^H deletes character immediately before the current cursor position
delete-next-character ^D deletes character immediately after current cursor position
delete-previous-word M-^H deletes word immediately before current cursor position
delete-next-word M-D deletes word immediately after current cursor position
kill-to-end-of-line ^K deletes from current cursor position to end of line
insert-space ^C inserts a space to right of cursor
open-line ^O inserts blank line
delete-blank-lines ^X^O removes blank line
exit-emacs ^X^C exits emacs
18 Jun 1996
At this point its time to familiarize ourselves with two more EMACS terms--the point and the mark. The point is located directly behind the current cursor position. The mark (as we shall see shortly) is user defined. These two elements together are called the current region and limit the region of text on which EMACS performs many of its editing functions.
Let's begin by entering some new text. Don't forget to add wrap
mode if its not set on this buffer. Start EMACS and open a file called
PUBLISH.TXT. Type in the following text:
Now let's do some editing. The last paragraph seems a little out
of place. To see what the document looks like without it we can cut it
from the text by moving the cursor to the beginning of the paragraph.
Enter M-<space> set-mark. EMACS will respond with "[Mark set]". Now move
the cursor to the end of the paragraph. You have just defined a region of
text. To remove this text from the screen, type ^W kill-region. The
paragraph disappears from the screen.
On further consideration, however, perhaps the paragraph we cut wasn't so bad after all. The problem may have been one of placement. If we could tack it on to the end of the first paragraph it might work quite well to support and strengthen the argument. Move the cursor to the end of the first paragraph and enter ^Y yank. Your text should now look like this:
>
The text you cut initially didn't simply just disappear, it was cut into a buffer that retains the 'killed' text appropriately called the kill buffer. ^Y "yanks" the text back from this buffer into the current buffer. If you have a long line (indicated, remember, by the "$" sign), simply hit M-Q to reformat the paragraph.
There are other uses to which the kill buffer can be put. Using the method we've already learned, define the last paragraph as a region. Now type M-W copy-region. Nothing seems to have happened; the cursor stays blinking at the point. But things have changed, even though you may not be able to see any alteration.
To see what has happened to the contents of the kill buffer, move the cursor down a couple of lines and "yank" the contents of the kill buffer back with ^Y. Notice the last paragraph is now repeated. The region you defined is "tacked on" to the end of your file because M-W copies a region to the kill buffer while leaving the original text in your working buffer. Some caution is needed however, because the contents of the kill buffer are updated when you delete any regions, lines or words. If you are moving large quantities of text, complete the operation before you do any more deletions or you could find that the text you want to move has been replaced by the most recent deletion. Remember--a buffer is a temporary area of computer memory that is lost when the machine is powered down or switched off. In order to make your changes permanent, they must be saved to a file before you leave EMACS. Let's delete the section of text we just added and save the file to disk.
In Chapter 3, you learned how to achieve longer insertions and deletions. The EMACS terms point and mark were introduced and you learned how to manipulate text with the kill buffer.
| Key Binding | Keystroke | Effect |
|---|---|---|
| set-mark | M- | Marks the beginning of a region |
| delete-region | ^W | Deletes region between point and mark and places it in KILL buffer |
| copy-region | M-W | Copies text between point and mark into KILL buffer |
| yank-text | ^Y | Inserts a copy of the KILL buffer into current buffer at point |
Load EMACS and bring in the file you just saved. Your file should
look like the one below.
Let's use EMACS to search for the word revolutionary in the second paragraph. Because EMACS searches from the current cursor position toward the end of buffers, and we intend to search forward, move the cursor to the beginning of the text. Enter ^X t search-forward. Note that the command line now reads
Search [] <META>:
EMACS is prompting you to enter the search string -- the text you want to find. Enter the word revolutionary and hit the META key. The cursor moves to the end of the word revolutionary.
Notice that you must enter the <META>key to start the search. If you simply press <NL> the command line responds with <NL>. Although this may seem infuriating to users who are used to pressing the return key to execute any command, EMACS' use of <META> to begin searches allows it to pinpoint text with great accuracy. After every line wrap or carriage return, EMACS 'sees' a new line character (<NL>). If you need to search for a word at the end of a line, you can specify this word uniquely in EMACS.
In our sample text for example, the word and occurs a number of times, but only once at the end of a line. To search for this particular occurrence of the word, move the cursor to the beginning of the buffer and type ^X t. Notice that EMACS stores the last specified search string as the default string. If you press <META> now, EMACS will search for the default string, in this case, revolutionary.
To change this string so we can search for our specified and simply enter the word and followed by <NL>. The command line now shows:
search [and<NL>]<META>:
Press and the cursor moves to and at the end of the second last line.
If the mode EXACT is active in the current buffer, EMACS searches on a case sensitive basis. Thus, for example you could search for Publishing as distinct from publishing.
Backward searching is very similar to forward searching except that it is implemented in the reverse direction. To implement a reverse search, type ^R search-reverse. Because EMACS makes no distinction between forward and backward stored search strings, the last search item you entered appears as the default string. Try searching back for any word that lies between the cursor and the beginning of the buffer. Notice that when the item is found, the point moves to the beginning of the found string (i.e., the cursor appears under the first letter of the search item).
Practice searching for other words in your text.
Searching and replacing is a powerful and quick way of making changes to your text. Our sample text is about electronic publishing, but the correct term is 'desktop' publishing. To make the necessary changes we need to replace all occurrences of the word electronic with desktop First, move the cursor to the top of the current buffer with the M-< command. Then type M-R replace-string. The command line responds:
Replace []<META>:
where the square brackets enclose the default string. Type the word electronic and hit <META>. The command line responds:
with []<META>
type desktop<META>. EMACS replaces all instances of the original word with your revision. Of course, you will have to capitalize the first letter of desktop where it occurs at the beginning of a sentence.
You have just completed an unconditional replace. In this operation, EMACS replaces every instance of the found string with the replacement string.
You may also replace text on a case by case basis. The M-^R query- replace-string command causes EMACS to pause at each instance of the found string.
For example, assume we want to replace some instances of the word desktop with the word personal. Go back to the beginning of the current buffer and enter the M-^R query-replace command. The procedure is very similar to that which you followed in the unconditional search/replace option. When the search begins however, you will notice that EMACS pauses at each instance of publishing and asks whether you wish to replace it with the replacement string. You have a number of options available for response:
| Response | Effect |
|---|---|
| Y(es) | Make the current replacement and skip to the next occurrence of the search string |
| N(o) | Do not make this replacement but continue |
| ! | Do the rest of the replacements with no more queries |
| U(ndo) | Undo just the last replacement and query for it again (This can only go back ONE time) |
| ^G | Abort the replacement command (This action does not undo previously-authorized replacements |
| . | Same effect as ^G, but cursor returns to the point at which the replacement command was given |
| ? | This lists help for the query replacement command |
Practice searching and searching and replacing until you feel comfortable with the commands and their effects.
In this chapter, you learned how to search for specified strings of text in EMACS. The chapter also dealt with searching for and replacing elements within a buffer.
| Key Binding | Keystroke | Effect |
|---|---|---|
| search-forward | ^X t | Searches from point to end of buffer. Point is moved from current location to the end of the found string |
| search-backward | ^R | Searches from point to beginning of buffer. Point is moved from current location to beginning of found string |
| replace | M-R | Replace ALL occurrences of search string with specified (null) string from point to the end of the current buffer |
| query-replace | M-^R | As above, but pause at each found string and query for action |
You will recall that windows are areas of buffer text that you can see on the screen. Because EMACS can support several screen windows simultaneously you can use them to look into different places in the same buffer. You can also use them to look at text in different buffers. In effect, you can edit several files at the same time.
Let's invoke EMACS and pull back our file on desktop publishing by typing
emacs publish.txt
When the text appears, type the ^X2 split-current-window command. The window splits into two windows. The window where the cursor resides is called the current window -- in this case the bottom window. Notice that each window has a text area and a mode line. The command line is however, common to all windows on the screen.
The two windows on your screen are virtually mirror images of each other because the new window is opened into the same buffer as the one you are in when you issue the open-window command . All commands issued to EMACS are executed on the current buffer in the current window.
To move the cursor to the upper window (i.e., to make that window the current window, type ^XP previous-window. Notice the cursor moves to the upper or previous window. Entering^XO next-window moves to the next window. Practice moving between windows. You will notice that you can also move into the Function Key menu by entering these commands.
Now move to the upper window. Let's open a new file. On the EMACS disk is a tutorial file. Let's call it into the upper window by typing:
Enter the filename
In a short time, the tutorial file will appear in the window. We now have two windows on the screen, each looking into different buffers. We have just used the ^X^F find-file command to find a file and bring it into our current window.
You can scroll any window up and down with the cursor keys, or with the commands we've learned so far. However, because the area of visible text in each window is relatively small, you can scroll the current window a line at a time.
Type ^X^N move-window-down
The current window scrolls down by one line -- the top line of text scrolls out of view, and the bottom line moves towards the top of the screen. You can imagine, if you like, the whole window slowly moving down to the end of the buffer in increments of one line. The command ^X^P move- window-up scrolls the window in the opposite direction.
As we have seen, EMACS editing commands are executed in the current window, but the program does support a useful feature that allows you to scroll the next window. M-^Z scroll-next-up scrolls the next window up, M-^V scroll-next-down scrolls it downward. From the tutorial window, practice scrolling the window with the desktop publishing text in it up and down.
When you're finished, exit EMACS without saving any changes in your files.
Experiment with splitting the windows on your screen. Open windows into different buffers and experiment with any other files you may have. Try editing the text in each window, but don't forget to save any changes you want to keep -- you still have to save each buffer separately.
Windows allow you to perform complex editing tasks with ease. However, they become an inconvenience when your screen is cluttered with open windows you have finished using. The simplest solution is to delete unneeded windows. The command ^X0 delete-window will delete the window you are currently working in and move you to the next window.
If you have a number of windows open, you can delete all but the current window by entering ^X1 delete-other-windows.
During complex editing tasks, you will probably find it convenient to have a number of windows on the screen simultaneously. However this situation may present inconveniences because the more windows you have on the screen the smaller they are; in some cases, a window may show only a couple of lines of text. To increase the flexibility and utility of the window environment, EMACS allows you to resize the window you are working in (called, as you will recall, the current window) to a convenient size for easier editing, and then shrink it when you no longer need it to be so large.
Let's try an example. Load in any EMACS text file and split the current window into two. Now type ^X^(Shift-6), grow-window. Your current window should be the lower one on the screen. Notice that it increases in size upwards by one line. If you are in the upper window, it increases in size in a downward direction. The command ^X^Z, shrink-window correspondingly decreases window size by one line at a time.
EMACS also allows you to resize a window more precisely by entering a numeric argument specifying the size of the window in lines. To resize the window this way, press the META key and enter a numeric argument (remember to keep it smaller than the number of lines on your screen display) then press ^XW resize-window. The current window will be enlarged or shrunk to the number of lines specified in the numeric argument. For example entering:
The cursor may be centered within a window by entering M-! or M-^L M-^L where
The ^L clear-and-redraw command is useful for 'cleaning up' a
'messy' screen that can result of using EMACS on a mainframe system and
being interrupted by a system message.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation Chapter 5 summary
In Chapter 5 you learned how to manipulate windows and the editing
flexibility they offer.
Key Binding Keystroke Effect
open-window ^X2 Splits current window into two windows if space available
close-windows ^X1 Closes all windows except current window
next-window ^XO[oh] Moves point into next (i.e. downward) window
previous-window ^XP Moves point to previous (i.e. upward) window
move-window-down ^X^N Scrolls current window down one line
move-window-up ^X^P Scrolls current window up one line
redraw-display M ! or M ^L Window is moved so line with point (with cursor) is at center of window
grow-window M-X ^ Current window is enlarged by one line and nearest window is shrunk by one line
shrink-window ^X^Z Current window is shrunk by one line and nearest window is enlarged by one line
clear-and-redraw ^L Screen is blanked and redrawn. Keeps screen updates in sync with your commands
scroll-next-up M-^Z Scrolls next window up by one line
scroll-next-down M-^V Scrolls next window down by one line
delete-window ^X0 Deletes current window delete-other-windows ^X1 Deletes all but current window
resize-window ^X^W Resizes window to a given numeric argument
On computers equipped with a mouse, the mouse can usually be used to make editing easier. If your computer has a mouse, let's try using it. Start MicroEMACS by typing:
emacs publish.txt
This brings EMACS up and allows it to edit the file from the last chapter. If the function key window is visible on the screen, press the F5 key to cause it to disappear. Now use the ^X2 split-current-window command to split the screen into two windows. Next use the ^X^F find-file command to read in the fang.txt file. Now your screen should have two windows looking into two different files.
Grab the mouse and move it around. On the screen an arrow, or block of color appears. This is called the mouse cursor and can be positioned on any character on the screen. On some computers, positioning the mouse cursor in the extreme upper right or left corner may bring down menus which allow you to access that computers utilities, sometimes called Desk Accessories.
Using the mouse button (or the left button if the mouse has more than one), position the mouse over some character in the current window. Click the mouse button once. The point will move to where the mouse cursor is. If you place the mouse cursor past the end of a line, the point will move to the end of that line.
Move the mouse cursor into the other window and click on one of the characters there. MicroEMACS will automatically make this window the current window (notice that the mode line changes) and position the point to the mouse cursor. This makes it very easy to use the mouse to switch to a different window quickly.
Besides just using the mouse to move around on the screen, you can use the same button to move text. Move the mouse cursor to a character in one of the windows, and click down... but don't let the button up yet! The point will move to where the mouse cursor is. Now move the mouse cursor up or down on the screen, and release the button. The point will again move to where the mouse cursor is, but this time it will bring the text under it along for the ride. This is called dragging, and is how you can make the text appear just where you want it to. If you try to drag text out of the current window, EMACS will ignore your attempt and leave the point where you first clicked down.
Now, click down on a word in one of the windows, and drag it directly to the left. Release the button and watch as the entire window slides, or scrolls to the left. The missing text has not been deleted, it is simply not visible, off the left hand side of the screen. Notice the mode line has changed and now looks like:
==== MicroEMACS 3.11 [<12] () == fang.txt == File: fang.txt =========
The number insided the brackets [] shows that the screen is now scrolled 12 characters from the left margin.
Now grab the same text again, and drag it to the right, pulling the rest of the text back into the current window. The [<] field will disappear, meaning that the window is no longer scrolled to the left. This feature is very useful for looking at wide charts and tables. Remember, MicroEMACS will only scroll the text in the current window sideways if you drag it straight to the side, otherwise it will drag the text vertically.
Now, place the mouse cursor over a character on the upper mode line, click down, move the mouse cursor up or down a few lines and let go of the button. The mode line moves to where you dragged it, changing the size of the windows above and below it. If you try to make a window with less than one line, EMACS will not let you. Dragging the mode lines can make it very fast and easy for you to rearrange the windows as you would like.
If you have a number of different windows visible on the screen, positioning the mouse over the mode line of one window and clicking the right mouse button will cause that window to be deleted.
If your mouse has two buttons, then you can use the right button to do some other things as well. Earlier, we learned how to define a region by using the M-<space> set-mark command. Now, position the mouse over at the beginning of a region you would like to copy. Next click and hold down the right mouse button. Notice that the point jumps to the mouse cursor and EMACS reports "[Mark Set]". Holding the button down move the mouse to the end of the text you wish to copy and release the mouse button. Emacs reports "[Region Copied]" to let you know it has copied the region into the KILL buffer. This has done the same job as the M-W copy- region command.
If you now click the right mouse button, without moving the mouse, the region you defined dissapear, being cut from the current buffer. This works just like the ^W kill-region command.
If you move the mouse away from where you cut the text, and click the right mouse button down and up without moving the mouse, the text in the KILL buffer gets inserted, or pasted into the current buffer at the point.
MicroEMACS can use more than one screen at once. Each screen is a collection of windows along with a mode line. These screens usually fill the terminal or computer screen on text based systems, but can also be held in different windows on graphically based systems like MicroSoft Windows, OS/2, the Macintosh Finder and X-Windows. Don't be confused by the two different uses of the term "window". Inside EMACS style editors, a window lets you view part of a buffer. Under graphical operating systems, a window holds a "virtual terminal", allowing you to manipulate more than one job, editing session or program at once. Within MicroEMACS, these operating system windows are called screens. All these screens are displayed on your current desktop.
You can change the size of a screen. Move the mouse to the last position of the command line. Press the left mouse button down. Holding it, move the mouse to the place you want the new lower right corner. Release the mouse. The desktop redraws, with your newly resized screen. MicroEMACS will ignore size changes that can not be done, like attempting to pull the lower left corner above the upper right corner of the current screen.
To change where on the desktop a screen is placed, move the mouse to the upper right corner of the screen, press the left mouse button down, move the mouse and release it where you want the screen displayed. Again, MicroEMACS will ignore placements that can not be done.
Creating a new screen is just like moving a screen, but using the right button. Move to the upper right of an existing screen, press the right mouse button down, and move the mouse, releasing the button where the new screen should appear. A new screen will have a single window, containing the contents of the current window in the copied screen, and will have that window's colors. The new screen will have the copied screen's size.
This is simple. Any mouse command can be done in any screen by placing the mouse on a visible part of the screen and clicking. The last screen the mouse is used on comes to front and is the current screen. Also, the A-C cycle-screens command brings the rearmost screen to front.
Place the mouse on the command line of the screen you want to delete. Click the right mouse button, the screen will disapear. If you delete the only remaining screen on the desktop, MicroEMACS will exit.
| Action | Mouse Directions | |||
|---|---|---|---|---|
| Move Cursor | |
|||
| Drag Text | |
|||
| Resize Windows | |
|||
| Delete Window | ||||
| Activate Screen | ||||
| Resize Screen | |
|||
| Copy Region | ||||
| Cut Region | |
|||
| Paste Region | |
|||
| Create Screen | |
|||
| Resize Screen | ||||
| Move Screen | |
| Delete Screen | position to command line of existing screen
| |
We have already learned a number of things about buffers. As you will recall, they are the major internal entities in EMACS -- the place where editing commands are executed. They are characterized by their names, their modes, and by the file with which they are associated. Each buffer also "remembers" its mark and point. This convenient feature allows you to go to other buffers and return to the original location in the "current" buffer.
Advanced users of EMACS frequently have a number of buffers in the computer's memory simultaneously. In the last chapter, for example, you opened at least two buffers -- one into the text you were editing, and the other into the EMACS on-line tutorial. If you deal with complex text files -- say, sectioned chapters of a book, you may have five or six buffers in the computer's memory. You could select different buffers by simply calling up the file with ^X^F find-file, and let EMACS open or reopen the buffer. However, EMACS offers fast and sophisticated buffering techniques that you will find easy to master and much more convenient to use.
Let's begin by opening three buffers. You can open any three you choose, for example call the following files into memory: fang.txt, publish.txt, and emacs.tut in the order listed here. When you've finished this process, you'll be looking at a screen showing the EMACS tutorial. Let's assume that you want to move to the fang.txt buffer. Enter:
^XX next-buffer
This command moves you to the next buffer. Because EMACS cycles through the buffer list, which is alphabetized, you will now be in the fang.txt buffer. Using ^XX again places you in the publish.txt buffer. If you are on a machine that supports function keys, using ^XX again places you in the Function Keys buffer. Using ^XX one last time cycles you back to the beginning of the list.
If you have a large number of buffers to deal with, this cycling
process may be slow and inconvenient. The command ^XB select-buffer allows
you to specify the buffer you wish to be switched to. When the command is
entered, EMACS prompts, "Use buffer:". Simply enter the buffer name (NOT
the file name), and that buffer will then become the current buffer. If
you type in part of the file name and press the space bar, EMACS will
attempt to complete the name from the list of current buffers. If it
succeeds, it will print the rest of the name and you can hit
Multiple buffer manipulation and editing is a complex activity,
and you will probably find it very inconvenient to re-save each buffer as
you modify it. The command ^X^B list-buffers creates a new window that
gives details about all the buffers currently known to EMACS. Buffers that
have been modified are identified by the "buffer changed" indicator (an
asterisk in the second column). You can thus quickly and easily identify
buffers that need to be saved to files before you exit EMACS. The buffer
window also provides other information -- buffer specific modes, buffer
size, and buffer name are also listed. To close this window, simply type
the close-windows command, ^X1.
To delete any buffer, type ^XK delete-buffer. EMACS prompts you
"Kill buffer:". Enter the buffer name you want to delete. As this is
destructive command, EMACS will ask for confirmation if the buffer was
changed and not saved. Answer Y(es) or N(o). As usual ^G cancels the
command.
In Chapter 7 you learned how to manipulate buffers.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation Chapter 7 Summary
Key Binding Keystroke Effect
next-buffer ^X^X Switch to the next buffer in the buffer list
select-buffer ^XB Switch to a particular buffer
list-buffers ^X^B List all buffers
delete-buffer ^XK Delete a particular buffer if it is off-screen
EMACS allows you to change the way it works in order to customized
it to the style of editing you are using. It does this by providing a
number of different modes. These modes can effect either a single buffer,
or any new buffer that is created. To add a mode to the current buffer,
type ^XM add-mode. EMACS will then prompt you for the name of a mode to
add. When you type in a legal mode name, and type a
To remove an existing mode, typing the ^X^M delete-mode will cause
EMACS to prompt you for the name of a mode to delete from the current
buffer. This will remove that mode from the mode list on the current mode
line.
Global modes are the modes which are inherited by any new buffers
which are created. For example, if you wish to always do string searching
with character case being significant, you would want global mode EXACT to
be set so that any new files read in inherent the EXACT mode. Global modes
are set with the M-M add-global-mode command, and unset with the M-^M
delete-global-mode command. Also, the current global modes are displayed
in the first line of a^X^B list-buffers command.
On machines which are capable of displaying colors, the mode
commands can also set the background and foreground character colors.
Using add-mode or delete-mode with a lowercase color will set the
background color in the current window. An uppercase color will set the
foreground color in the current window. Colors that EMACS knows about
are: white, cyan, magenta, yellow, blue, red, green, and black. If the
computer you are running on does not have eight colors, EMACS will attempt
to make some intelligent guess at what color to use when you ask for one
which is not there.
Automatic Save mode tells EMACS to automatically write out the
current buffer to its associated file on a regular basis. Normally this
will be every 256 characters typed into the file. The environment variable
$ACOUNT counts down to the next auto-save, and $ASAVE is the value used to
reset $ACOUNT after a save occurs.
CMODE is useful to C programmers. When CMODE is active, EMACS will
try to assist the user in a number of ways. This mode is set automatically
with files that have a .c or .h extension.
The <NL> key will normally attempt to return the user to the next
line at the same level of indentation as the last non blank line, unless
the current line ends with a open brace { in which case the new line
will be further indented by one tab position.
A close brace } will search for the corresponding open brace and
line up with it.
A pound sign # with only leading white space will delete all the
white space preceding itself. This will always bring preprocessor
directives flush to the left margin.
Whenever any close fence is typed, IE )]>}, if the matching open
fence is on screen in the current window, the cursor will briefly flash to
it, and then back. This makes balancing expressions, and matching blocks
much easier.
When a buffer is in CRYPT mode, it is encrypted whenever it is
written to a file, and decrypted when it is read from the file. The
encryption key can be specified on the command line with the -k switch, or
with the M-E set-encryption-key command. If you attempt to read or write a
buffer in crypt mode and now key has not been set, EMACS will execute set-
encryption-key automatically, prompting you for the needed key. Whenever
EMACS prompts you for a key, it will not echo the key to your screen as
you type it (IE make SURE you get it right when you set it originally).
The encryption algorithm used changes all characters into normal
printing characters, thus the resulting file is suitable for sending via
electronic mail. All version of MicroEMACS should be able decrypt the
resulting file regardless of what machine encrypted it. Also available
with EMACS is the stand alone program, MicroCRYPT, which can en/decrypt
the files produced by CRYPT mode in EMACS.
All string searches and replacements will take upper/lower case
into account. Normally the case of a string during a search or replace is
not taken into account.
In the MAGIC mode certain characters gain special meanings when
used in a search pattern. Collectively they are know as regular
expressions, and a limited number of them are supported in MicroEmacs.
They grant greater flexibility when using the search command. They have no
affect on the incremental search command.
The symbols that have special meaning in MAGIC mode are ^, $, .,
&, ?, *, +, [ (and ], used with it), and \.
The characters ^ and $ fix the search pattern to the beginning and
end of line, respectively. The ^ character must appear at the beginning of
the search string, and the $ must appear at the end, otherwise they loose
their meaning and are treated just like any other character. For example,
in MAGIC mode, searching for the pattern t$ would put the cursor at the
end of any line that ended with the letter t. Note that this is
different than searching for t<NL>, that is, 't' followed by a newline
character. The character $ (and ^, for that matter) matches a position,
not a character, so the cursor remains at the end of the line. But a
newline is a character that must be matched like any other character,
which means that the cursor is placed just after it - on the beginning of
the next line.
The character . has a very simple meaning -- it matches any single
character, except the newline. Thus a search for bad.er could match
badger, badder (slang), or up to the r of bad error.
The character [ indicates the beginning of a character class. It
is similar to the 'any' character ., but you get to choose which
characters you want to match. The character class is ended with the
character ]. So, while a search for ba.e will match bane, bade,
bale, bate, et cetera, you can limit it to matching babe and bake
by searching for ba[bk]e. Only one of the characters inside the [ and ]
will match a character. If in fact you want to match any character except
those in the character class, you can put a ^ as the first character. It
must be the first character of the class, or else it has no special
meaning. So, a search for [^aeiou] will match any character except a
vowel, but a search for [aeiou^] will match any vowel or a ^.
If you have many characters in order, that you want to put in the
character class, you may use a dash () as a range character. So, [az]
will match any letter (or any lower case letter if EXACT mode is on), and
[09af] will match any digit or any letter 'a' through 'f', which happen
to be the characters for hexadecimal numbers. If the dash is at the
beginning or end of a character class, it is taken to be just a dash.
The ? character indicates that the preceding character is
optional. The character may or may not appear in the matched string. For
example, a search for bea?st would match both beastand best. If
there is no preceding charcter for ? to modify, it is treated as a normal
question mark character.
The * character is known as closure, and means that zero or more
of the preceding character will match. If there is no preceding character,
* has no special meaning and is treated as a normal asterisk. The
closure symbol will also have no special meaning if it is preceded by the
beginning of line symbol ^, since it represents a position, not a
character.
The notion of zero or more characters is important. If, for
example, your cursor was on the line
This line is missing two vowels.
and a search was made for a*, the cursor would not move, because
it is guaranteed to match no letter a , which satisfies the search
conditions. If you wanted to search for one or more of the letter a, you
could search for aa, which would match the letter a, then zero or more
of them. A better way, however, is to use the + character.
The +character behaves in every respect like the * character,
with the exception that its minimum match range is one, not zero. Thus the
pattern a+is identical to aa*.
Under older versions of MicroEMACS, the closure symbols would not
operate on newlines. The current versions no longer have this restriction.
The \ is the escape character. With the exception of groups, which
are explained below, the \ is used at those times when you want to be in
MAGIC mode, but also want a regular expression character to be just a
character. It turns off the special meaning of the character. So a search
for it\. will search for a line with it., and not it followed by any
other character. Or, a search for TEST\*+ would match the word TEST
followed by one or more asterisks. The escape character will also let you
put ^, -, or ] inside a character class with no special side effects.
The character pair \( represent the start of a group in a search
string. A group is ended by the character pair \). All characters matched
within the \( and \) are part of a numbered group, and may be referenced
with the< &GROUP function, or with a \ followed by the group number in the
replacement string of replace-string or the query-replace-string commands.
For example, a search for INDEX\([0-9]+\), to be replaced by
getind(\1)would change
.
There may be up to nine groups. Groups may be nested.
The character & (ampersand) is a replacement character, and
represents all the characters which were matched by the search string.
When used in the M-R replace-string or the M-^R query-replace-string
commands, the & will be substituted for the search string.
OVER mode stands for overwrite mode. When in this mode, when
characters are typed, instead of simply inserting them into the file,
EMACS will attempt to overwrite an existing character past the point.
This is very useful for adjusting tables and diagrams.
Wrap mode is used when typing in continuous text. Whenever the
cursor is past the currently set fill column (72 by default) and the user
types a space or a <NL>, the last word of the line is brought down to the
beginning of the next line. Using this, one just types a continuous stream
of words and EMACS automatically inserts
The EMACS variable $wraphook contains the name of the function
which executes when EMACS detects it is time to wrap. This is
set to the function wrap-word by default, but can be changed to
activate different functions and macros at wrap time.
VIEW mode disables all commands which can change the current
buffer. EMACS will display an error message and ring the bell every time
you attempt to change a buffer in VIEW mode.
In Chapter 8 you learned about modes and their effects.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation
A file is simply a collection of related data. In EMACS we are
dealing with text files -- named collections of text residing on a disk
(or some other storage medium). You will recall that the major entities
EMACS deals with are buffers. Disk-based versions of files are only active
in EMACS when you are reading into or writing out of buffers. As we have
already seen, buffers and physical files are linked by associated file
names. For example, the buffer ch7.txt which is associated with the
physical disk file ch7.txt. You will notice that the file is usually
specified by the drive name or (in the case of a hard drive) a path. Thus
you can specify full file names in EMACS,
e.g. disk:\directories\filename.extension
If you do not specify a disk and directories, the default disk and
the current directory is used.
IMPORTANT -- If you do not explicitly save your buffer to a file,
all your edits will be lost when you leave EMACS (although EMACS will
prompt you when you are about to lose edits by exiting). In addition,
EMACS does not protect your disk-based files from overwriting when it
saves files. Thus when you instruct EMACS to save a file to disk, it will
create a file if the specified file doesn't exist, or it will overwrite
the previously saved version of the file thus replacing it. Your old
version is gone forever.
If you are at all unsure about your edits, or if (for any reason)
you wish to keep previous versions of a file, you can change the name of
the associated file with the command ^XN change-file-name. When this file
is saved to disk, EMACS will create a new physical file under the new
name. The earlier disk file will be preserved.
For example, let's load the file fang.txt into EMACS. Now, type
^XN. The EMACS command line prompts Name:. Enter a new name for the file
-- say new.txt and press <NL>. The file will be saved under the new
filename, and your disk directory will show both fang.txt and new.txt.
An alternative method is to write the file directly to disk under
a new filename. Let's pull our publish.txt file into EMACS. To write
this file under another filename, type ^X^W write-file. EMACS will prompt
you write file:. Enter an alternate filename -- desktop.txt. Your file
will be saved as the physical file desktop.txt.
Note that in the examples above, although you have changed the
names of the related files, the buffer names remain the same. However,
when you pull the physical file back into EMACS, you will find that the
buffer name now relates to the filename.
For example -- You are working with a buffer "
fang.txt with the
related file fang.txt. You change the name of the file to new.txt.
EMACS now shows you working with the buffer fang.txt and the related
file new.txt. Now pull the file new.txt into EMACS. Notice that the
buffer name has now changed to new.txt.
If for any reason a conflict of buffer names occurs,(if you have
files of the same name on different drives for example) EMACS will prompt
you use buffer:. Enter an alternative buffer name if you need to.
For a list of file related commands (including some we`ve already
seen), see the summary page.
In Chapter 9 you learned some of the more advanced concepts of
file naming and manipulation. The relationship between files and buffers
was discussed in some detail.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation 8.1 ASAVE mode
8.2 CMODE mode
8.3 CRYPT mode
8.4 EXACT mode
8.5 MAGIC mode
8.6 OVER mode
8.7 WRAP mode
NOTE to programmers:
8.8 VIEW mode
Chapter 8 Summary
35
Key Binding Keystroke Effect
add-mode ^XM Add a mode to the current buffer
delete-mode ^X^M Delete a mode from the current buffer
add-global-mode M-M Add a global mode to the current buffer
delete-global-mode M-^M Delete a global mode from the current buffer
Chapter 9
Files
Chapter 9 Summary
Key Binding Keystroke Effect
save-file M-y associated filename on default disk/directory (if not specified)
write-file ^X^W Current buffer contents will be saved under specified name
change-file-name ^XN The associated filename is changed (or associated if not previously specified) as specified
find-file ^X^F Reads specified file into buffer and switches you to that buffer, or switches to buffer in which the file has previously been read
read-file ^X^R Reads file into buffer thus overwriting buffer contents. If file has already been read into another buffer, you will be switched to it
view-file ^X^V The same as read-file except the buffer is automatically put into VIEW mode thus preventing any changes from being made
As we learned in the introduction, EMACS is not a word processor, but an editor. Some simple formatting options are available however, although in most cases they will not affect the appearance of the finished text when it is run through the formatter. We have already encountered WRAP mode which wraps lines longer than a certain length (default is 75 characters). You will recall that WRAP is enabled by entering ^XM and responding to the command line prompt with wrap.
You can also set your own wrap margin with the command ^XF set- fill-column. Notice EMACS responds "[Fill column is 1]." Now try typing some text. You'll notice some very strange things happening -- your text wraps at every word!! This effect occurs because the set wrap margin command must be preceded by a numeric argument or EMACS sets it to the first column. Thus any text you type that extends past the first column will wrap at the most convenient line break.
To reset the wrap column to 72 characters, press the <META> key and enter 72. EMACS will respond Arg: 72. Now press ^XF. EMACS will respond "[Fill column is 72]". Your text will again wrap at the margin you've been using up to this point.
After an intensive editing session, you may find that you have paragraphs containing lines of differing lengths. Although this disparity will not affect the formatted text, aesthetic and technical concerns may make it desirable to have consistent paragraph blocks on the screen. If you are in WRAP mode, you can reformat a paragraph with the command M-Q fill-paragraph. This command 'fills' the current paragraph reformatting it so all the lines are filled and wrap logically.
There may be occasions when you find it necessary to change the case of the text you've entered. EMACS allows you to change the case of even large amounts of text with ease. Let's try and convert a few of the office traditionalists to the joy of word processing. Type in the following text:
Let's give it a little more impact by capitalizing the first four
words. The first step is to define the region of text just as you would
if you were doing an extensive deletion. Set the mark at the beginning of
the paragraph with M-
THROW AWAY YOUR TYPEWRITER and learn to use a word processor. Word processing is relatively easy to learn and will increase your productivity enormously. Enter the Computer Age and find out just how much fun it can be!!
If you want to change the text back to lower case, type ^X^L case- region-lower. You can also capitalize individual words. To capitalize the word fun, position the cursor in front of the word and type M-U case- word-upper. The word is now capitalized. To change it ck to lower case, move the cursor back to the beginning of the word and type M-L case-word- lower.
You may also capitalize individual letters in EMACS. The command M-C case-word-capitalize capitalizes the first letter after the point. This command would normally be issued with the cursor positioned in front of the first letter of the word you wish to capitalize. If you issue it in the middle of a word, you can end up with some strAnge looking text.
Unless your formatter is instructed to take screen text literally (as MicroSCRIBE does in the 'verbatim' environment for example), tabs in EMACS generally affect screen formatting only.
When EMACS is first started, it sets the default tab to every eighth column. As long as you stay with default, every time you press the tab key a tab character, ^I is inserted. This character, like other control characters, is invisible -- but it makes a subtle and significant difference to your file and editing.
For example, in default mode, press the tab key and then type the word Test .Test appears at the eighth column. Move your cursor to the beginning of the word and delete the backward character. The word doesn't move back just one character, but flushes to the left margin. The reason for this behavior is easily explained. In tab default, EMACS inserts a 'real' tab character when you press the tab key. This character is inserted at the default position, but NO SPACES are inserted between the tab character and the margin (or previous tab character). As you will recall, EMACS only recognizes characters (such as spaces or letters) and thus when the tab character is removed, the text beyond the tab is flushed back to the margin or previous tab mark.
This situation changes if you alter the default configuration. The default value may be changed by entering a numeric argument before pressing the tab key. As we saw earlier, pressing the META key and entering a number allows you to specify how EMACS performs a given action. In this case, let's specify an argument of 10 and hit the tab key.
Now hit the tab key again and type Test. Notice the word now appears at the tenth column. Now move to the beginning of the word and delete the backward character. Test moves back by one character.
EMACS behaves differently in these circumstances because the ^I handle-tab function deals with tabbing in two distinct ways. In default conditions, or if the numeric argument of zero is used, handle-tab inserts a true tab character. If, however, a non-zero numeric argument is specified, handle-tab inserts the correct number of spaces needed to position the cursor at the next specified tab position. It does NOT insert the single tab character and hence any editing functions should take account of the number of spaces between tabbed columns.
The distance which a true tab character moves the cursor can be modified by changing the value of the $hardtab environment variable. Initially set to 8, this will determine how far each tab stop is placed from the previous one. (Use the ^XA set command to set the value of an environment variable).
Many times you would like to take text which has been created using the tab character and change it to use just spaces. The command ^X^D detab-region changes any tabs in the currently selected region into the right number of spaces so the text does not change. This is very useful for times when the file must be printed or transferred to a machine which does not understand tabs.
Also, the inverse command, ^X^E entab-region changes multiple spaces to tabs where possible. This is a good way to shrink the size of large documents, especially with data tables. Both of these commands can take a numeric argument which will be interpreted as the number of lines to en/detab.
Another function, related to those above is provided for by the ^X^T trim-region when invoked will delete any trailing white space in the selected region. A preceding numeric argument will do this for that number of lines.
In Chapter 10 introduced some of the formatting features of EMACS. Text-wrap, paragraph reformatting, and tabs were discussed in some detail. The commands in the following table were covered in the chapter.
| Key Binding | Keystroke | Effect | |
|---|---|---|---|
| add-mode/WRAP | ^XM[WRAP] | Add wrap mode to current buffer | |
| delete-mode/WRAP | ^X^M[WRAP] | Remove wrap mode from current buffer | |
| set-fill-column | ^XF | Set fill column to given numeric argument | |
| fill-paragraph | M-Q | Logically reformats the current paragraph | |
| case-word-upper | M-U | Text from point to end of the current word is changed to uppercase | |
| case-word-lower | M-L | Text from point to end of the current word is changed to lowercase | |
| case-word-capitalize | M-C | First word (or letter) after the point is capitalized | |
| case-region-upper | ^X^U | The current region is uppercased | |
| case-region-lower | ^X^L | The current region is lowercased | |
| handle-tab | ^I | Tab interval is set to the given numeric argument | |
| entab-region | ^X^E | Changes multiple spaces to tabs characters where possible | |
| detab-region | ^X^D | Changes tab characters to the appropriate number of spaces | |
| trim-region | ^X^T | Trims white space from the end of the lines in the current region |
EMACS has the ability to interface to other programs and the environment of the computer outside of itself. It does this through a series of commands that allow it to talk to the computer's command processor or shell. Just what this is varies between different computers. Under MSDOS or PCDOS this is the command.com command processor. Under UNIX it is the csh shell. On the Atari ST is can be the Mark Williams MSH or the Beckmeyer shell. In each case, it is the part of the computer's operating system that is responsible for determining what programs are executed, and when.
The ^X! shell-command command prompts the user for a command line to send out to the shell to execute. This can be very useful for doing file listings and changing the current directory or folder. EMACS gives control to the shell, which executed the command, and then types [END] and waits for the user to type a character before redrawing the screen and resuming editing. If the shell-command command is used from within the macro language, there is no pause.
^X@ pipe-command command allows EMACS to execute a shell command,
and if the particular computer allows it, send the results into a buffer
which is automatically displayed on the screen. The resulting buffer,
called "command" can be manipulated just like any other editing buffer.
Text can be copied out of it or rearranged as needed. This buffer is
originally created in VIEW mode, so remember to ^X^Mview
Many computers provide tools which will allow you to filter text,
making some modifications to it along the way. A very common tool is the
SORT program which accepts a file, sorts it, and prints the result out.
The EMACS command, ^X# filter-buffer sends the current buffer through such
a filter. Therefore, if you wished to sort the current buffer on a system
which supplied a sort filter, you would type ^X#sort<NL>. You can also
create your own filters by writing programs and utilities which read text
from the keyboard and display the results. EMACS will use any of these
which would normally be available from the current shell.
If you would like to execute another program directly, without the
overhead of an intervening shell, you can use the ^X$ execute-program
command. It will prompt you for an external program and its arguments and
attempt to execute it. Like when EMACS looks for command files, EMACS
will look first in the HOME directory, then down the execute PATH, and
finally in the current directory for the named program. On some systems,
it will automatically tack the proper extension on the file name to
indicate it is a program. On some systems that don't support this
function, ^X$ will be equivalent to ^X! shell-command.
Sometimes, you would like to get back to the shell and execute
other commands, without losing the current contents of EMACS. The ^XC i-
shell command shells out of EMACS, leaving EMACS in the computer and
executing another command shell. Most systems would allow you to return to
EMACS with the exit command.
On some systems, mainly advanced versions of UNIX, you can direct
EMACS to "go into the background" with the ^XD suspend-emacs command. This
places EMACS in the background returning you to the original command
shell. EMACS can then be returned to at any time with the fg foreground
command.
In Chapter 11 introduced different ways to access the computers
shell or command processor from within EMACS. The commands in the
following table were covered in the chapter.
MicroEMACS / uemacs - Binaries, Executables, Manuals, and Documentation Chapter 11 Summary
Key Binding Keystroke Effect
execute-program ^X$ Execute an external program directly
filter-command ^X# Send the current buffer through a shell filter
i-shell ^XC Escape to a new shell
pipe-command ^X@ Send the results of an external shell command to a buffer
shell-command ^X! Execute one shell command
suspend-emacs ^XD Place EMACS in the background (some UNIX systems only)
In many applications, you may need to repeat a series of characters or commands frequently. For example, a paper may require the frequent repetition of a complex formula or a long name. You may also have a series of EMACS commands that you invoke frequently. Keyboard macros offer a convenient method of recording and repeating these commands.
Imagine, for example, you are writing a scholarly paper on Asplenium platyneuron, the spleenwort fern. Even the dedicated botanist would probably find it a task bordering on the agonizing to type Asplenium platyneuron frequently throughout the paper. An alternative method is 'record' the name in a keyboard macro. Try it yourself.
The command ^X( begin-macro starts recording the all the keystrokes and commands you input. After you've typed it, enter Asplenium platyneuron. To stop recording, type ^X) end-macro. EMACS has stored all the keystrokes between the two commands. To repeat the name you've stored, just enter ^XE execute-macro, and the name "Asplenium platyneuron" appears. You can repeat this action as often as you want, and of course as with any EMACS command, you may precede it with a numerical argument to repeat it many times.
Because EMACS records keystrokes, you may freely intermix commands and text. Unfortunately, you can only store one macro at a time. Thus, if you begin to record another macro, the previously defined macro is lost. Be careful to ensure that you've finished with one macro before defining another. If you have a series of commands that you would like to 'record' for future use, use the procedure facilities detailed in chapter 13.
Chapter 12 covered keyboard macros. You learned how to record keystrokes and how to repeat the stored sequence.
| Key Binding | Keystroke | Effect |
|---|---|---|
| start-macro | ^X( | Starts recording all keyboard input |
| end-macro | ^X) | Stops recording keystrokes for macro |
| execute-macro | ^XE | Entire sequence of recorded keystrokes is replayed |
Procedures, or macros, are programs that are used to customize the editor and to perform complicated editing tasks. They may be stored in files or buffers and may be executed using an appropriate command, or bound to a particular keystroke. Portions of the standard start-up file are implemented via procedures, as well as the built in help system. The M-^E run command causes named procedures to be executed. The execute-file command allows you to execute a procedure stored in a disk file, and the execute-buffer command allows you to execute a procedure stored in a buffer. Procedures are stored for easy execution by executing files that contain the store-procedure command.
In a command file, the store-procedure command takes a string argument which is the name of a procedure to store. These procedures than can be executed with the M-^E run command. Also, giving the name of a stored procedure within another procedure will executed that named procedure as if it had been called up with the run command.
Some fairly length examples of MicroEMACS procedures can be seen by examining the standard files that come with EMACS. The emacs.rc file (called .emacsrc) under UNIX) is the MicroEMACS command file which is executed when EMACS is normally run. It contains a number of different stored procedures along with the lines to setup and display the Function key window and to call up other procedures and command files using function keys.
There are many different aspects to the language within MicroEMACS. Editor commands are the various commands that manipulate text, buffers, windows, et cetera, within the editor. Directives are commands which control what lines get executed within a macro. Also there are various types of variables. Environmental variables both control and report on different aspects of the editor. User variables hold string values which may be changed and inspected. Buffer variables allow text to be placed into variables. Interactive variable allow the program to prompt the user for information. Functions can be used to manipulate all these variables.
All constants and variable contents in EMACS are stored as strings of characters. Numbers are stored digit by digit as characters. This allows EMACS to be "typeless", not having different variables types be legal in different contexts. This has the disadvantage of forcing the user to be more careful about the context of the statements variables are placed in, but in turn gives them more flexibility in where they can place variables. Needless to say, this also allows EMACS's expression evaluator to be both concise and quick.
Wherever statements need to have arguments, it is legal to place constants. A constant is a double quote character, followed by a string of characters, and terminated by another double quote character. To represent various special characters within a constant, the tilde (~) character is used. The character following the tilde is interpreted according to the following table:
| Sequence | Result | |
|---|---|---|
| ~n | EMACS newline character (breaks lines) | |
| ~r | ^M | carriage return |
| ~l | ^J | linefeed |
| ~~ | ~ | tilde |
| ~b | ^H | backspace |
| ~f | ^L | formfeed |
| ~t | ^I | tab |
| ~" | " | quote |
Any character not in the table which follows a tilde will be passed unmodified. This action is similar to the ^Q quote-character command available from the keyboard.
EMACS may use different characters for line terminators on different computers. The ~n combination will always get the proper line terminating sequence for the current system.
The double quotes around constants are not needed if the constant contains no internal white space and it also does not happen to meet the rules for any other EMACS commands, directives, variables, or functions. This is reasonable useful for numeric constants.
Variables in MicroEMACS procedures can be used to return values within expressions, as repeat counts to editing commands, or as text to be inserted into buffers and messages. The value of these variables is set using the set ^XA command. For example, to set the current fill column to 64 characters, the following macro line would be used:
These variables are used to change different aspects of the way the editor works. Also they will return the current settings if used as part of an expression. All environmental variable names begin with a dollar sign ($) and are in lower case.
| $acount | The countdown of inserted characters until the next save-file. |
| $asave | The number of inserted characters between automatic file-saves in ASAVE mode. |
| $bufhook | The function named in this variable is run when a buffer is entered. It can be used to implement modes which are specific to a paricular file or file type. |
| $cbflags | Current buffer attribute flags (See appendix G for details). |
| $cbufname | Name of the current buffer. |
| $cfname | File name of the current buffer. |
| $cmdhook | Name of function to run before accepting a command. This is by default set to nop. |
| $cmode | Integer containing the mode of the current buffer. (See Appendix F for values). |
| $curchar | Ascii value of the character currently at the point. |
| $curcol | Current column of point in current buffer. |
| $curline | Current line of point in current buffer. |
| $curwidth | Number of columns used currently. |
| $curwind | Current window number. |
| $cwline | Current display line in current window. |
| $debug | Flag to trigger macro debugging. |
| $deskcolor | Color to use for current desktop, default to BLACK. |
| $diagflag | If set to TRUE, diagonal dragging of text and mode lines is enabled. If FALSE, text and modelines can only be dragged horizontally or vertically at one time. |
| $discmd | Controls the echoing of command prompts. Default is TRUE. |
| $disinp | Controls the echoing of input at the command prompts. Default is TRUE. |
| $disphigh | If set to TRUE, high-bit characters (single byte displayed in a pseudo-control format. The characters "^!" will lead off the sequence, followed by the character stripped of its high bit. Default is FALSE. |
| $exbhook | This variable holds the name of a function or macro which is run whenever you are switching out of a buffer. |
| $fcol | The current line position being displayed in the first column of the current window. |
| $fillcol | Current fill column. |
| $flicker | Flicker Flag set to TRUE if IBM CGA set to FALSE for most others. |
| $fmtlead | lists all formatter command leadin characters. Lines beginning with these characters will be considered the beginning of paragraphs. |
| $gflags | Global flags controlling some EMACS internal functions
|
| $gmode | Global mode flags.
|
| $hardtab | Number of spaces between hard tab stops. Normally 8, this can be used to change indentation only within the editor. |
| $hjump | The number in here tells EMACS how many columns to scroll the screen horizontally when a horizontal scroll is required. |
| $hscroll | This flag determines if EMACS will scroll the entire current window horizontally, or just the current line.
|
| $kill | This contains the first 127 characters currently in the kill buffer and can be used to set the contents of the kill buffer. |
| $language | READ ONLY Contains the name of the language which the current EMACS's message will display.
|
| $lastkey | READ ONLY Last keyboard character typed. |
| $lastmesg | READ ONLY Contains the text of the last message which emacs wrote on the command line. |
| $line | The current line in the current buffer can be retrieved and set with this environment variable. |
| $lterm | Character(s) to write as a line terminator when writing a file to disk. Default is null, which causes a '\n' character to be written. Not all operating systems support this. |
| $lwidth | READ ONLY Returns the number of characters in the current line. |
| $match | READ ONLY Last string matched in a search. |
| $msflag | If TRUE, the mouse (if present) is active. If FALSE, no mouse cursor is displayed, and no mouse actions are taken. |
| $numwind | The number of windows displayed. |
| $oldcrypt | Use the old method of encryption (which had a bug in it). Default is FALSE. |
| $orgrow | Desktop row position of current screen. |
| $orgcol | Desktop column position of current screen. |
| $pagelen | Number of screen lines used currently. |
| $palette | string used to control the palette register settings on graphics versions. The usually form consists of groups of three octal digits setting the red, green, and blue levels. |
| $paralead | Lists all paragraph start characters. |
| $pending | READ ONLY Flag to determine if there are user keystrokes waiting to be processed. |
| $popflag | Use pop-up windows. Default is TRUE. |
| $progname | READ ONLY Always contains the string "MicroEMACS" for standard MicroEMACS. Could be something else if EMACS is incorporated as part of someone else's program. |
| $ram | The amount of remaining memory if MicroEMACS was compiled with RAMSIZE set. A debugging tool. |
| $readhook | This variable holds the name of a function to execute whenever a file is read into EMACS. Normally, using the standard emacs.rc file, this is bound to a function which places EMACS into CMODE if the extension of the file read is .c or .h. |
| $region | Contains the string of the current region. It will truncate at the stringsize limit, 255. |
| $replace | Current default replace string. |
| $rval | This contains the return value from the last subprocess which was invoked from EMACS. |
| $scrname | The current screen name. |
| $search | Current default search string |
| $searchpnt | Set the placement of the of the cursor on a successful search match. $searchpnt = 0 (the default), causes the cursor to be placed at the end of the matched text on forward searches, and at the beginning of the text on reverse searches. $searchpnt = 1 causes the cursor to be placed at the the beginning of the matched text regardless of the search direction, while $searchpnt = 2 causes the cursor to be placed at the end. |
| $seed | Integer seed of the random number generator. |
| $softtab | Number of spaces inserted by EMACS when the handle-tab command (which is normally bound to the TAB key) is invoked. |
| $sres | Current screen resolution (CGA, MONO, EGA or VGA on the IBM-PC driver. LOW, MEDIUM, HIGH or DENSE on the Atari ST1040, NORMAL on most others). |
| $ssave | If TRUE, when EMACS is asked to save the current file, it writes all files out to a temporary file, deletes the original, and then renames the temporary to the old file name. The default value of this is TRUE. |
| $sscroll | Changes EMACS, when set to TRUE, to smoothly scroll windows (one line at a time) when cursoring off the ends of the current window. |
| $status | READ ONLY Status of the success of the last command (TRUE or FALSE). This is usually used with !force to check on the success of a search, or a file operation. |
| $sterm | This is the character used to terminate search string inputs. The default for this is the last key bound to meta-prefix. |
| $target | Current target for line moves (setting this fool's EMACS into believing the last command was a line move). |
| $time | READ ONLY Contains a string corresponding to the current date and time. Usually this is in a form similar to "Mon May 09 10:10:58 1988". Not all operating systems will support this. |
| $tpause | Controls the length of the pause to display a matched fence when the current buffer is in CMODE and a close fence has been typed. |
| $version | READ ONLY Contains the current MicroEMACS version number. |
| $wchars | When set, MicroEMACS uses the characters listed in it to determine if it is in a word or not. If it is not set (the default), the characters it uses are the upper and lower case letters, and the underscore. |
| $wline | Number of display lines in current window. |
| $wraphook | This variable contains the name of an EMACS function which is executed when a buffer is in WRAP mode and it is time to wrap. By default this is bound to wrap-word. |
| $writehook | This variable contains the name of an EMACS function or macro which is invoked whenever EMACS attempts to write a file out to disk. This is executed before the file is written, allowing you to process a file on the way out. |
| $xpos | The column the mouse was at the last mouse button press. |
| $yankflag | Controls the placement of the cursor after a yank command or an insert. When $yankflag is FALSE (the default), the cursor is placed at the end of the yanked or inserted text. When it is TRUE, the cursor remains at the start of the text. |
| $ypos | The line which the mouse was on during the last mouse button press. |
User variables allow you to store strings and manipulate them. These strings can be pieces of text, numbers (in text form), or the logical values TRUE and FALSE. These variables can be combined, tested, inserted into buffers, and otherwise used to control the way your macros execute. At the moment, up to 512 user variables may be in use in one editing session. All users variable names must begin with a percent sign (%) and may contain any printing characters. Only the first 10 characters are significant (IE differences beyond the tenth character are ignored). Most operators will truncate strings to a length of 128 characters.
Buffer variables are special in that they can only be queried and cannot be set. What buffer variables are is a way to take text from a buffer and place it in a variable. For example, if I have a buffer by the name of RIGEL2, and it contains the text:
and within a command I reference #rigel2, like:
insert-string #rigel2
MicroEMACS would start at the current point in the RIGEL2 buffer and grab all the text up to the end of that line and pass that back. Then it would advance the point to the beginning of the next line. Thus, after our last command executes, the string "Bloomington" gets inserted into the current buffer, and the buffer RIGEL2 now looks like this:
as you have probably noticed, a buffer variable consists of the buffer name, preceded by a pound sign (#).
Interactive variables are actually a method to prompt the user for a string. This is done by using an at sign (@) followed either with a quoted string, or a variable containing a string. The string is the placed on the bottom line, and the editor waits for the user to type in a string. Then the string typed in by the users is returned as the value of the interactive variable. For example:
will ask the user for a file name, and then attempt to find it. Note also that complex expressions can be built up with these operators, such as:
which prompts the user with the string:
File to decode[file1]:
set $fillcol &add $fillcol 2 \ \ \ \ \____second operand \ \ \ \_________first operand \ \ \_______________function to execute \ \_____________________variable to set \___________________________set (^XA) command
Function names always begin with the ampersand & character, and are only significant to the first three characters after the ampersand. Functions will normal expect one of three types of arguments, and will automatically convert types when needed. Different argument types include:
| <num> | an ascii string of digits which is interpreted as a numeric value. Any string which does not start with a digit or a minus sign (-) will be considered zero. |
| <str> | An arbitrary string of characters. At the moment, strings are limited to 128 characters in length. |
| <log> | A logical value consisting of the string "TRUE" or "FALSE". Numeric strings will also evaluate to "FALSE" if they are equal to zero, and "TRUE" if they are non-zero. Arbitrary text strings will have the value of "FALSE". |
A list of the currently available functions follows. Functions are always used in lower case, the uppercase letters in the function table are the short form of the function (IE &div for ÷).
| &ADD | <num> <num> | Add two numbers |
| &SUB | <num> <num> | Subtract the second number from the first |
| &TIMes | <num> <num> | Multiply two numbers |
| &DIVide | <num> <num> | Divide the first number by the second giving an integer result |
| &MOD | <num> <num> | Return the reminder of dividing the first number by the second |
| &NEGate | <neg> | Multiply the arg by -1 |
| &LENgth | <str> | Returns length of string |
| &SINdex | | Finds the position of <str2> within |
| &ASCii | <str> | Return the ascii code of the first character in <str> |
| &RND | <num> | Returns a random integer between 1 and <num> |
| &ABS | <num> | Returns the absolute value of <num> |
| &BANd | <num> <num> | Bitwise AND function |
| &BOR | <num> <num> | Bitwise OR function |
| &BXOr | <num> <num> | Bitwise XOR function |
| &BNOt | <num> | Bitwise NOT function |
| &CAT | <str> <str> | Concatenate the two strings to form one |
| &LEFt | <str> <num> | return the <num> leftmost characters from <str> |
| &RIGht | <str> <num> | return the <num> rightmost characters from <str> |
| &MID | <str> <num1> <num2> | Starting from <num1> position in <str>, return <num2> characters. |
| &UPPer | <str> | Uppercase <str> |
| &LOWer | <str> | Lowercase <str> |
| &CHR | <num> | return a string with the character represented by ascii code <num> |
| &G T C | returns a string of characters containing a EMACS command input from the user | |
| &G T K | return a string containing a single keystroke from the user | |
| &ENV | <str> | If the operating system is capable, this returns the environment string associated with <str> |
| &BIND | <str> | return the function name bound to the keystroke <str> |
| &XLATE | <str1> <str2> <str3> | |
| &FINd | <str> | Find the named file <str> along the path and return its full file specification or an empty string if none exists |
| &TRIM | <str> | Trim the trailing whitespace from a string |
| &NOT | <log> | Return the opposite logical value |
| &AND | <log1> <log2> | Returns TRUE if BOTH logical arguments are TRUE |
| &OR | <log1> <log2> | Returns TRUE if either argument is TRUE |
| &EQUal | <num> <num> | If <num> and <num> are numerically equal, return TRUE |
| &LESs | <num1> <num2> | If <num1> is less than <num2>, return TRUE. |
| &GREater | <num1> <num2> | If <num1> is greater than, or equal to <num2>, return TRUE. |
| &SEQual | <str1> <str2> | If the two strings are the same, return TRUE. |
| &SLEss | <str1> <str2> | If <str1> is less alphabetically than <str2>, return TRUE. |
| &SGReater | <str1> <str2> | If <str1> is alphabetically greater than or equal to <str2>, return TRUE. |
| &EXIst | <str> | Does the named file <str> exist? |
| &ISNum | <num> | Is the given argument a legitimate number? |
| &GROup | <num> | Return group <num> as set by a MAGIC mode search. |
| &SUPper | <str1> <str2> | Translate the first char in <str1> to the first char in <str2> when uppercasing. |
| &SLOwer | <str1> <str2> | Translate the first char in |
| &INDirect | <str> | Evaluate <str> as a variable. |
This last function deserves more explanation. The &IND function evaluates its argument, takes the resulting string, and then uses it as a variable name. For example, given the following code sequence:
the string giraffe would have been inserted at the point in the current buffer. This indirection can be safely nested up to about 10 levels.
Directives are commands which only operate within an executing procedure, IE they do not make sense as a single command. As such, they cannot be called up singly or bound to keystroke. Used within command files, they control what lines are executed and in what order.
Directives always start with the exclamation mark (!) character and must be the first non-wite space placed on a line. Directives executed interactively (via the execute-command-line command) will be ignored.
This directive is used to terminate a procedure or macro being stored. For example, if a file is being executed contains the text:
only the lines between the store-macro command and the !ENDM directive are stored in procedure get-red-viewd-file. Both named procedures and numbered macroes (via the store-macro command) should be terminated with this directive.
When MicroEMACS executes a procedure, if any command fails, the procedure is terminated at that point. If a line is preceded by a !FORCE directive, execution continues whether the command succeeds or not. For example:
Often this is used together with the $status environment variable to test if a command succeeded. For example:
This directive allows statements only to be executed if a condition specified in the directive is met. Every line following the !IF directive, until the first !ELSE or !ENDIF directive, is only executed if the expression following the !IF directive evaluates to a TRUE value. For example, the following commands creates the portion of a text file automatically. (yes believe me, this will be easier to understand then that last explanation....)
Flow can be controlled within a MicroEMACS procedure using the !GOTO directive. It takes as an argument a label. A label consists of a line starting with an asterisk (*) and then an alphanumeric label. Only labels in the currently executing procedure can be jumped to, and trying to jump to a non-existing label terminates execution of a procedure. For example:
This directive allows you to set up repetitive tasks easily and efficiently. If a group of statements need to be executed while a certain condition is true, enclose them with a while loop. For example,
This lets you abort out of the most executing currently inner
while loop, regardless of the condition. It is often used to abort
processing for error conditions. For example:
This while loop will process files until the list is exhausted or
there is an error while reading a file.
The !RETURN Directive causes the current procedure to exit, either
returning to the caller (if any) or to interactive mode. For example:
When developing new procedures, it is very convenient to be able to trace their execution to discover errors. The $debug environment variable enables procedure debugging. While this variable is TRUE, emacs will stop at each line it intends to execute and allow you to view it, and issue a number of different commands to help determine how the procedure is executing.
For example, we will step through the procedure which toggles the function key window off. The first thing to do, is to set $debug, using the ^XA set command. Type ^XA and emacs will prompt you on the command line with "Variable to set: ". Type in $debug and press the enter key. Emacs will then ask "Value: ". Type in TRUE (in capital letters) and press the enter key.
While macro debugging is enabled (as it is now) emacs will report each time a variable is assigned a value, by displaying the variable and its value on the command line. Right now,
Now, lets try to debug a macro. Press function key 5 which normally toggles the function key window. The first thing that appears is:
At this point, emacs is waiting for a command. It is prepared to see if the user variable %rcfkeys is TRUE, and execute some lines if they are. Suppose we want to see the value of this variable, type the letter e to evaluate an expression. Emacs will prompt with EXP: . Type %rcfkeys followed by the enter key. Emacs should then respond with TRUE to indicate that the function key window is currently on screen.
Press the space bar to allow the !if directive to execute. Emacs will decide that it is TRUE, and then display the next command to execute.
Notice emacs tells us what procedure we are currently executing (in this case, the macro bound to execute-macro-1). Press the space bar again to execute the !goto directive.
Emacs is saving the position of the current window so that it can attempt to return to it after it has brought up the function key window. [...THIS CHAPTER IS NOT FINISHED...] (sic)
One of the features which makes MicroEMACS very adaptable is its ability to use different keystrokes to execute different commands. The process of changing the particular command a key invokes is called rebinding. This allows us to make the editor look like other popular editors and programs.
Each command in MicroEMACS has a name which is used for binding purposes. For example, the command to move the cursor down one page is called next-line and is normally bound to the ^N key. If you decided that you also wanted to use the ^D key to move the cursor down one line, you would use the M-K bind-to-key command. EMACS would respond with ": bind- to-key " on the command line and allow you to type in a command name. Then type in the name of the command you want to change, in this case next- line, followed by the <NL> key. EMACS will then wait for you to type in the keys you want to activate the named function. Type a single ^D. From now on, typing ^D will cause EMACS to move down one line, rather than its original function of deleting characters.
To find out the name of a command, consult the list of valid EMACS commands in Appendix B. Also, you can use the ^X? describe-key command to look up the name of a command. Type ^X? and then the key to use that command, and EMACS will show you the name of the command.
After you have experimented with changing your key bindings, you may decide that you want to change some bindings permanently. To have EMACS rebind keys to your pleasure each time you start EMACS, you can add statements to the end of your startup file (emacs.rc or .emacsrc depending on the system). For example,
Notice, that control D character in the startup file is represented visibly as an uparrow key followed by a capital D. To know how to represent any keys you want to bind, use the describe-key command on the key, and use the sequence that is displayed.
This example would make function key 1 activate the command that splits the current window in two.
EMACS will let you define a large number of keys, but will report "Binding table FULL!" when it runs out of space to bind keys. Normally EMACS will allow up to 512 key bindings (including approx. 300 originally
If you want to get a current listing of all the commands and the keys bound to them, use the describe-bindings command. Notice, that this command is not bound to any keys!