wiki:HemlockUser/BasicCommands

Version 1 (modified by rme, 6 years ago) (diff)

--

2 Basic Commands

2.1 Motion Commands

There is a fairly small number of basic commands for moving around in the buffer. While there are many other more complex motion commands, these are by far the most commonly used and the easiest to learn.

Forward Character (bound to C-f, Rightarrow) [Command]

Backward Character (bound to C-b, Leftarrow) [Command]

Forward Character moves the point forward by one character. If a prefix argument is supplied, then the point is moved by that many characters. Backward Character is identical, except that it moves the point backwards.

Forward Word (bound to M-f) [Command]

Backward Word (bound to M-b) [Command]

These commands move the point forward and backward over words. The point is always left between the last word and first non-word character in the direction of motion. This means that after moving backward the cursor appears on the first character of the word, while after moving forward, the cursor appears on the delimiting character. Supplying a prefix argument moves the point by that many words.

Next Line (bound to C-n, Downarrow) [Command]

Previous Line (bound to C-p, Uparrow) [Command]

Goto Absolute Line [Command]

Next Line and Previous Line move to adjacent lines, while remaining the same distance within a line. Note that this motion is by logical lines, each of which may take up many lines on the screen if it wraps. If a prefix argument is supplied, then the point is moved by that many lines.

The position within the line at the start is recorded, and each successive use of C-p or C-n attempts to move the point to that position on the new line. If it is not possible to move to the recorded position because the line is shorter, then the point is left at the end of the line.

Goto Absolute Line moves to the indicated line, as if you counted them starting at the beginning of the buffer with number one. If the user supplies a prefix argument, it is the line number; otherwise, Hemlock prompts the user for the line.

End of Line (bound to C-e) [Command]

Beginning of Line (bound to C-a) [Command]

End of Line moves the point to the end of the current line, while Beginning of Line moves to the beginning. If a prefix argument is supplied, then the point is moved to the end or beginning of the line that many lines below the current one.

Scroll Window Down (bound to C-v) [Command]

Scroll Window Up (bound to M-v) [Command]

Scroll Window Down moves forward in the buffer by one screenful of text, the exact amount being determined by the size of the window. If a prefix argument is supplied, then this scrolls the screen that many lines. When this action scrolls the line with the point off the screen, it this command moves the point to the vertical center of the window. Scroll Window Up is identical to Scroll Window Down, except that it moves backwards.

Scroll Overlap (initial value 2) [Variable]

This variable is used by Scroll Window Down and Scroll Window Up to determine the number of lines by which the new and old screen should overlap.

End of Buffer (bound to M-<) [Command]

Beginning of Buffer (bound to M->) [Command]

These commands are used to conveniently get to the very beginning and end of the text in a buffer. Before the point is moved, its position is saved by pushing it on the mark stack (see page 2.2).

Top of Window (bound to M-,) [Command]

Bottom of Window (bound to M-.) [Command]

Top of Window moves the point to the beginning of the first line displayed in the current window. Bottom of Window moves to the beginning of the last line displayed.

2.2 The Mark and The Region

Each buffer has a distinguished position known as the mark. The mark initially points to the beginning of the buffer. The area between the mark and the point is known as the region. Many Hemlock commands which manipulate large pieces of text use the text in the region. To use these commands, one must first use some command to mark the region.

Although the mark is always pointing somewhere (initially to the beginning of the buffer), region commands insist that the region be made active before it can be used. This prevents accidental use of a region command from mysteriously mangling large amounts of text.

Active Regions Enabled (initial value t) [Variable]

When this variable is true, region commands beep unless the region is active. This may be set to nil for more traditional Emacs region semantics.

Once a marking command makes the region active, it remains active until:

  • a command uses the region,
  • a command modifies the buffer,
  • a command changes the current window or buffer,
  • a command signals an editor error,
  • or the user types C-g.

Motion commands have the effect of redefining the region, since they move the point and leave the region active.

Commands that insert a large chunk of text into the buffer usually set an ephemerally active region around the inserted text. An ephemerally active region is always deactivated by the next command, regardless of the kind of command. The ephemerally active region allows an immediately following region command to manipulate the inserted text, but doesn't persist annoyingly. This is also very useful with active region highlighting, since it visibly marks the inserted text.

Highlight Active Region (initial value t) [Variable]

Active Region Highlighting Font (initial value nil) [Variable]

When Highlight Active Region is true, Hemlock displays the text in the region in a different font whenever the region is active. This provides a visible indication of what text will be manipulated by a region command. Active region highlighting is only supported under X windows.

Active Region Highlighting Font is the name of the font to use for active region highlighting. If unspecified, Hemlock uses an underline font.

Set/Pop? Mark (bound to C-@) [Command]

This command moves the mark to the point (saving the old mark on the mark stack) and activates the region. After using this command to mark one end of the region, use motion commands to move to the other end, then do the region command. This is the traditional Emacs marking command; when running under a windowing system with mouse support, it is usually easier to use the mouse with the Point to Here and Generic Pointer Up.

For historical reasons, the prefix argument causes this command to do things that are distinct commands in Hemlock. A prefix argument of four does Pop and Goto Mark, and a prefix argument of 16 does Pop Mark.

Mark Whole Buffer (bound to C-x h) [Command]

Mark to Beginning of Buffer (bound to C-<) [Command]

Mark to End of Buffer (bound to C->) [Command]

Mark Whole Buffer sets the region around the whole buffer, with the point at the beginning and the mark at the end. If a prefix argument is supplied, then the mark is put at the beginning and the point at the end. The mark is pushed on the mark stack beforehand, so popping the stack twice will restore it.

Mark to Beginning of Buffer sets the current region from point to the beginning of the buffer.

Mark to End of Buffer sets the current region from the end of the buffer to point.

Activate Region (bound to C-x C-Space, C-x C-@) [Command]

This command makes the region active, using whatever the current position of the mark happens to be. This is useful primarily when the region is accidentally deactivated.

2.2.1 The Mark Stack

As was hinted at earlier, each buffer has a mark stack, providing a history of positions in that buffer. The current mark is the mark on the top of the stack; earlier values are recovered by popping the stack. Since commands that move a long distance save the old position on the mark stack, the mark stack commands are useful for jumping to interesting places in a buffer without having to do a search.

Pop Mark (bound to C-M-Space) [Command]

Pop and Goto Mark (bound to M-@, M-Space) [Command]

Pop Mark pops the mark stack, restoring the current mark to the next most recent value. Pop and Goto Mark also pops the mark stack, but instead of discarding the current mark, it moves the point to that position. Both commands deactivate the region.

Exchange Point and Mark (bound to C-x C-x) [Command]

This command interchanges the position of the point and the mark, thus moving to where the mark was, and leaving the mark where the point was. This command can be used to switch between two positions in a buffer, since repeating it undoes its effect. The old mark isn't pushed on the mark stack, since it is saved in the point.

2.2.2 Using The Mouse

It can be convenient to use the mouse to point to positions in text, especially when moving large distances. Hemlock defines several commands for using the mouse. These commands can only be used when running under X windows

Here to Top of Window (bound to Rightdown) [Command]

Top Line to Here (bound to Leftdown) [Command]

Here to Top of Window scrolls the window so as to move the line which is under the mouse cursor to the top of the window. This has the effect of moving forward in the buffer by the distance from the top of the window to the mouse cursor. Top Line to Here is the inverse operation, it scrolls backward, moving current the top line underneath the mouse.

If the mouse is near the left edge of a window, then these commands do smooth scrolling. Here To Top of Window repeatedly scrolls the window up by one line until the mouse button is released. Similarly, Top Line to Here smoothly scrolls down.

Point to Here (bound to Middledown, S-Leftdown) [Command]

This command moves the point to the position of the mouse, changing to a different window if necessary.

When used in a window's modeline, this moves the point of the window's buffer to the position within the file that is the same percentage, start to end, as the horizontal position of the mouse within the modeline. This also makes this window current if necessary.

This command supplies a function Generic Pointer Up invokes if it runs without any intervening generic pointer up predecessors executing. If the position of the pointer is different than the current point when the user invokes Generic Pointer Up, then this function pushes a buffer mark at point and moves point to the pointer's position. This allows the user to mark off a region with the mouse.

Generic Pointer Up (bound to Middleup, S-Leftup) [Command]

Other commands determine this command's action by supplying functions that this command invokes. The following built-in commands supply the following generic up actions:

Point to Here
When the position of the pointer is different than the current point, the action pushes a buffer mark at point and moves point to the pointer's position.
Bufed Goto and Quit
The action is a no-op.

Insert Kill Buffer (bound to S-Rightdown) [Command]

This command is a combination of Point to Here and Un-Kill. It moves the point to the mouse location and inserts the most recently killed text.

2.3 Modification Commands

There is a wide variety of basic text-modification commands, but once again the simplest ones are the most often used.

2.3.1 Inserting Characters

In Hemlock, you can insert characters with graphic representations by typing the corresponding key-event which you normally generate with the obvious keyboard key. You can only insert characters whose codes correspond to ASCII codes. To insert those without graphic representations, use Quoted Insert.

Self Insert [Command]

Self Insert inserts into the buffer the character corresponding to the key-event typed to invoke the command. This command is normally bound to all such key-events Space. If a prefix argument is supplied, then this inserts the character that many times.

New Line (bound to Return) [Command]

This command, which has roughly the same effect as inserting a Newline, is used to move onto a new blank line. If there are at least two blank lines beneath the current one then Return cleans off any whitespace on the next line and uses it, instead of inserting a newline. This behavior is desirable when inserting in the middle of text, because the bottom half of the screen does not scroll down each time New Line is used.

Quoted Insert (bound to C-q) [Command]

Many key-events have corresponding ASCII characters, but these key-events are bound to commands other than Self Insert. Sometimes they are otherwise encumbered such as with C-g. Quoted Insert prompts for a key-event, without any command interpretation semantics, and inserts the corresponding character. If the appropriate character has some code other than an ASCII code, this will beep and abort the command. A common use for this command is inserting a Formfeed by typing C-q C-l. If a prefix argument is supplied, then the character is inserted that many times.

Open Line (bound to C-o) [Command]

This command inserts a newline into the buffer without moving the point. This command may also be given a prefix argument to insert a number of newlines, thus opening up some room to work in the middle of a screen of text. See also Delete Blank Lines.

2.3.2 Deleting Characters

There are a number of commands for deleting characters as well.

Character Deletion Threshold (initial value 5) [Variable]

If more than this many characters are deleted by a character deletion command, then the deleted text is placed in the kill ring.

Delete Next Character (bound to C-d) [Command]

Delete Previous Character (bound to Delete, Backspace) [Command]

Delete Next Character deletes the character immediately following the point, that is, the character which appears under the cursor. When given a prefix argument, C-d deletes that many characters after the point. Delete Previous Character is identical, except that it deletes characters before the point.

Delete Previous Character Expanding Tabs [Command]

Delete Previous Character Expanding Tabs is identical to Delete Previous Character, except that it treats tabs as the equivalent number of spaces. Various language modes that use tabs for indentation bind Delete to this command.

2.3.3 Killing and Deleting

Hemlock has many commands which kill text. Killing is a variety of deletion which saves the deleted text for later retrieval. The killed text is saved in a ring buffer known as the kill ring. Killing has two main advantages over deletion:

  1. If text is accidentally killed, a not uncommon occurrence, then it can be restored.
  1. Text can be moved from one place to another by killing it and then restoring it in the new location.

Killing is not the same as deleting. When a command is said to delete text, the text is permanently gone and is not pushed on the kill ring. Commands which delete text generally only delete things of little importance, such as single characters or whitespace.

2.3.4 Kill Ring Manipulation

Un-Kill (bound to C-y) [Command]

This command "yanks" back the most recently killed piece of text, leaving the mark before the inserted text and the point after. If a prefix argument is supplied, then the text that distance back in the kill ring is yanked.

Rotate Kill Ring (bound to M-y) [Command]

This command rotates the kill ring forward, replacing the most recently yanked text with the next most recent text in the kill ring. M-y may only be used immediately after a use of C-y or a previous use of M-y. This command is used to step back through the text in the kill ring if the desired text was not the most recently killed, and thus could not be retrieved directly with a C-y. If a prefix argument is supplied, then the kill ring is rotated that many times.

Kill Region (bound to C-w) [Command]

This command kills the text between the point and mark, pushing it onto the kill ring. This command is usually the best way to move or remove large quantities of text.

Save Region (bound to M-w) [Command]

This command pushes the text in the region on the kill ring, but doesn't actually kill it, giving an effect similar to typing C-w C-y. This command is useful for duplicating large pieces of text.

2.3.5 Killing Commands

Most commands which kill text append into the kill ring, meaning that consecutive uses of killing commands will insert all text killed into the top entry in the kill ring. This allows large pieces of text to be killed by repeatedly using a killing command.

Kill Line (bound to C-k) [Command]

Backward Kill Line [Command]

Kill Line kills the text from the point to the end of the current line, deleting the line if it is empty. If a prefix argument is supplied, then that many lines are killed. Note that a prefix argument is not the same as a repeat count.

Backward Kill Line is similar, except that it kills from the point to the beginning of the line. If it is called at the beginning of the line, it kills the newline and any trailing whitespace on the previous line. With a prefix argument, this command is the same as Kill Line with a negated argument.

Kill Next Word (bound to M-d) [Command]

Kill Previous Word (bound to M-Backspace, M-Delete) [Command]

Kill Next Word kills from the point to the end of the current or next word. If a prefix argument is supplied, then that many words are killed. Kill Previous Word is identical, except that it kills backward.

2.3.6 Case Modification Commands

Hemlock provides a few case modification commands, which are often useful for correcting typos.

Capitalize Word (bound to M-c) [Command]

Lowercase Word (bound to M-l) [Command]

Uppercase Word (bound to M-u) [Command]

These commands modify the case of the characters from the point to the end of the current or next word, leaving the point after the end of the word affected. A positive prefix argument modifies that many words, moving forward. A negative prefix argument modifies that many words before the point, but leaves the point unmoved.

Lowercase Region (bound to C-x C-l) [Command]

Uppercase Region (bound to C-x C-u) [Command]

These commands case-fold the text in the region. Since these commands can damage large amounts of text, they ask for confirmation before modifying large regions and can be undone with Undo.

2.3.7 Transposition Commands

Hemlock provides a number of transposition commands. A transposition command swaps the "things" before and after the point and moves forward one "thing". Just how a "thing" is defined depends on the particular transposition command. Transposition commands, particularly Transpose Characters and Transpose Words, are useful for correcting typos. More obscure transposition commands can be used to amaze your friends and demonstrate your immense knowledge of exotic Emacs commands.

To the uninitiated, the behavior of transposition commands may seem mysterious; this has led some implementors to attempt to improve the definition of transposition, but right-thinking people will accept no substitutes. The Emacs transposition definition used in Hemlock has two useful properties:

  1. Repeated applications of a transposition command have a useful effect. The way to visualize this effect is that each use of the transposition command drags the previous thing over the next thing. It is possible to correct double transpositions easily using Transpose Characters.
  1. Transposition commands move backward with a negative prefix argument, thus undoing the effect of the equivalent positive argument.

Transpose Characters (bound to C-t) [Command]

This command exchanges the characters on either side of the point and moves forward, unless at the end of a line, in which case it transposes the previous two characters without moving.

Transpose Lines (bound to C-x C-t) [Command]

This command transposes the previous and current line, moving down to the next line. With a zero argument, it transposes the current line and the line the mark is on.

Transpose Words (bound to M-t) [Command]

This command transposes the previous word and the current or next word.

Transpose Regions (bound to C-x t) [Command]

This command transposes two regions with endpoints defined by the mark stack and point. To use this command, place three marks (in order) at the start and end of the first region, and at the start of the second region, then place the point at the end of the second region. Unlike the other transposition commands, a second use will simply undo the effect of the first use, and to do even this, you must reactivate the current region.

2.3.8 Whitespace Manipulation

These commands change the amount of space between words. See also the indentation commands in section 7.2.

Just One Space (bound to M-|) [Command]

This command deletes all whitespace characters before and after the point and then inserts one space. If a prefix argument is supplied, then that number of spaces is inserted.

Delete Horizontal Space (bound to M-\) [Command]

This command deletes all blank characters around the point.

Delete Blank Lines (bound to C-x C-o) [Command]

This command deletes all blank lines surrounding the current line, leaving the point on a single blank line. If the point is already on a single blank line, then that line is deleted. If the point is on a non-blank line, then all blank lines immediately following that line are deleted. This command is often used to clean up after Open Line.

2.4 Filtering

Filtering is a simple way to perform a fairly arbitrary transformation on text. Filtering text replaces the string in each line with the result of applying a Lisp function of one argument to that string. The function must neither destructively modify the argument nor the return value. It is an error for the function to return a string containing newline characters.

Filter Region [Command]

This function prompts for an expression which is evaluated to obtain a function to be used to filter the text in the region. For example, to capitalize all the words in the region one could respond:

Function: #'string-capitalize

Since the function may be called many times, it should probably be compiled. Functions for one-time use can be compiled using the compile function as in the following example which removes all the semicolons on any line which contains the string "PASCAL":

Function: (compile nil '(lambda (s)
                          (if (search "PASCAL" s)
                            (remove #\; s)
                            s)))

2.5 Searching and Replacing

Searching for some string known to appear in the text is a commonly used method of moving long distances in a file. Replacing occurrences of one pattern with another is a useful way to make many simple changes to text. Hemlock provides powerful commands for doing both of these operations.

String Search Ignore Case (initial value t) [Variable]

This variable determines the kind of search done by searching and replacing commands.

Incremental Search (bound to C-s) [Command]

Reverse Incremental Search (bound to C-r) [Command]

Incremental Search searches for an occurrence of a string after the current point. It is known as an incremental search because it reads key-events form the keyboard one at a time and immediately searches for the pattern of corresponding characters as you type. This is useful because it is possible to initially type in a very short pattern and then add more characters if it turns out that this pattern has too many spurious matches.

This command dispatches on the following key-events as sub-commands:

C-s
Search forward for an occurrence of the current pattern. This can be used repeatedly to skip from one occurrence of the pattern to the next, or it can be used to change the direction of the search if it is currently a reverse search. If C-s is typed when the search string is empty, then a search is done for the string that was used by the last searching command.
C-r
Similar to C-s, except that it searches backwards.
Delete, Backspace
Undoes the effect of the last key-event typed. If that key-event simply added to the search pattern, then this removes the character from the pattern, moving back to the last match found before entering the removed character. If the character was a C-s or C-r, then this moves back to the previous match and possibly reverses the search direction.
C-g
If the search is currently failing, meaning that there is no occurrence of the search pattern in the direction of search, then C-g deletes enough characters off the end of the pattern to make it successful. If the search is currently successful, then C-g causes the search to be aborted, leaving the point where it was when the search started. Aborting the search inhibits the saving of the current search pattern as the last search string.
Escape
Exit at the current position in the text, unless the search string is empty, in which case a non-incremental string search is entered.
C-q
Search for the character corresponding to the next key-event, rather than treating it as a command.

Any key-event not corresponding to a graphic character, except those just described, causes the search to exit. Hemlock then uses the key-event in it normal command interpretation.

For example, typing C-a will exit the search and go to the beginning of the current line. When either of these commands successfully exits, they push the starting position (before the search) on the mark stack. If the current region was active when the search started, this foregoes pushing a mark.

Forward Search (bound to M-s) [Command]

Reverse Search (bound to M-r) [Command]

These commands do a normal dumb string search, prompting for the search string in a normal dumb fashion. One reason for using a non-incremental search is that it may be faster since it is possible to specify a long search string from the very start. Since Hemlock uses the Boyer--Moore search algorithm, the speed of the search increases with the size of the search string. When either of these commands successfully exits, they push the starting position (before the search) on the mark stack. This is inhibited when the current region is active.

Query Replace (bound to M-%) [Command]

This command prompts in the echo area for a target string and a replacement string. It then searches for an occurrence of the target after the point. When it finds a match, it prompts for a key-event indicating what action to take. The following are valid responses:

Space, y
Replace this occurrence of the target with the replacement string, and search again.
Delete, Backspace, n
Do not replace this occurrence, but continue the search.
!
Replace this and all remaining occurrences without prompting again.
.
Replace this occurrence and exit.
C-r
Go into a recursive edit (see section 1.13) at the current location. The search will be continued from wherever the point is left when the recursive edit is exited. This is useful for handling more complicated cases where a simple replacement will not achieve the desired effect.
Escape
Exit without doing any replacement.
Home, C-_, ?, h
Print a list of all the options available.

Any other key-event causes the command to exit, returning the key-event to the input stream; thus, Hemlock will interpret it normally for a command binding.

When the current region is active, this command uses it instead of the region from point to the end of the buffer. This is especially useful when you expect to use the ! option.

If the replacement string is all lowercase, then a heuristic is used that attempts to make the case of the replacement the same as that of the particular occurrence of the target pattern. If "foo" is being replaced with "bar" then "Foo" is replaced with "Bar" and "FOO" with "BAR".

This command may be undone with Undo, but its undoing may not be undone. On a successful exit from this command, the starting position (before the search) is pushed on the mark stack.

Case Replace (initial value t) [Variable]

If this variable is true then the case preserving heuristic in Query Replace is enabled, otherwise all replacements are done with the replacement string exactly as specified.

Replace String [Command]

This command is the same as Query Replace except it operates without ever querying the user before making replacements. After prompting for a target and replacement string, it replaces all occurrences of the target string following the point. If a prefix argument is specified, then only that many occurrences are replaced. When the current region is active, this command uses it instead of the region from point to the end of the buffer.

List Matching Lines [Command]

This command prompts for a search string and displays in a pop-up window all the lines containing the string that are after the point. If a prefix argument is specified, then this displays that many lines before and after each matching line. When the current region is active, this command uses it instead of the region from point to the end of the buffer.

Delete Matching Lines [Command] Delete Non-Matching Lines [Command]

Delete Matching Lines prompts for a search string and deletes all lines containing the string that are after the point. Similarly, Delete Non-Matching Lines deletes all lines following the point that do not contain the specified string. When the current region is active, these commands uses it instead of the region from point to the end of the buffer.

2.6 Page Commands

Another unit of text recognized by Hemlock is the page. A page is a piece of text delimited by formfeeds (L's.) The first non-blank line after the page marker is the page title. The page commands are quite useful when logically distinct parts of a file are put on separate pages. See also Count Lines Page. These commands only recognize L's at the beginning of a lines, so those quoted in string literals do not get in the way.

Previous Page (bound to C-x ]) [Command]

Next Page (bound to C-x [) [Command]

Previous Page moves the point to the previous page delimiter, while Next Page moves to the next one. Any page delimiters next to the point are skipped. The prefix argument is a repeat count.

Mark Page (bound to C-x C-p) [Command]

This command puts the point at the beginning of the current page and the mark at the end. If given a prefix argument, marks the page that many pages from the current one.

Goto Page [Command]

This command does various things, depending on the prefix argument:

no argument
goes to the next page.
positive argument
goes to an absolute page number, moving that many pages from the beginning of the file.
zero argument
prompts for string and goes to the page with that string in its title. Repeated invocations in this manner continue searching from the point of the last find, and a first search with a particular pattern pushes a buffer mark.
negative argument
moves backward by that many pages, if possible.

View Page Directory [Command]

Insert Page Directory [Command]

View Page Directory uses a pop-up window to display the number and title of each page in the current buffer. Insert Page Directory is the same except that it inserts the text at the beginning of the buffer. With a prefix argument, Insert Page Directory inserts at the point.

2.7 Counting Commands

Count Words [Command]

This command counts the number of words from the current point to the end of the buffer, displaying a message in the echo area. When the current region is active, this uses it instead of the region from the point to the end of the buffer. Word delimiters are determined by the current major mode.

Count Lines [Command]

This command counts the number of lines from the current point to the end of the buffer, displaying a message in the echo area. When the current region is active, this uses it instead of the region from the point to the end of the buffer.

Count Lines Page (bound to C-x l) [Command]

This command displays the number of lines in the current page and the number of lines before and after the point within that page. If given a prefix argument, the entire buffer is counted instead of just the current page.

Count Occurrences [Command]

This command prompts for a search string and displays the number of occurrences of that string in the text from the point to the end of the buffer. When the current region is active, this uses it instead of the region from the point to the end of the buffer.

2.8 Registers

Registers allow you to save a text position or chunk of text associated with a key-event. This is a convenient way to repeatedly access a commonly-used location or text fragment. The concept and key bindings should be familiar to TECO users.

Save Position (bound to C-x s) [Command]

Jump to Saved Position (bound to C-x j) [Command]

These commands manipulate registers containing textual positions. Save Position prompts for a register and saves the location of the current point in that register. Jump to Saved Position prompts for a register and moves the point to the position saved in that register. If the saved position is in a different buffer, then that buffer is made current.

Put Register (bound to C-x x) [Command]

Get Register (bound to C-x g) [Command]

These commands manipulate registers containing text. Put Register prompts for a register and puts the text in the current region into the register. Get Register prompts for a register and inserts the text in that register at the current point.

List Registers [Command]

Kill Register [Command]

List Registers displays a list of all the currently defined registers in a pop-up window, along with a brief description of their contents. Kill Register prompts for the name of a register and deletes that register.