GNUtools/emacs/info/emacs-3 - annotate

Return to emacs-3 CVS log

Up to [Apple XNU] / GNUtools / emacs / info

Annotation of GNUtools/emacs/info/emacs-3, revision 1.1.1.1

1.1 root 1: This is Info file ../info/emacs, produced by Makeinfo-1.49 from the
2: input file emacs.texi.
3:
4: This file documents the GNU Emacs editor.
5:
6: Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman.
7:
8: Permission is granted to make and distribute verbatim copies of this
9: manual provided the copyright notice and this permission notice are
10: preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of
13: this manual under the conditions for verbatim copying, provided also
14: that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
15: General Public License" are included exactly as in the original, and
16: provided that the entire resulting derived work is distributed under the
17: terms of a permission notice identical to this one.
18:
19: Permission is granted to copy and distribute translations of this
20: manual into another language, under the above conditions for modified
21: versions, except that the sections entitled "The GNU Manifesto",
22: "Distribution" and "GNU General Public License" may be included in a
23: translation approved by the author instead of in the original English.
24:
25:
26: File: emacs, Node: Repetition, Prev: Completion, Up: Minibuffer
27:
28: Repeating Minibuffer Commands
29: =============================
30:
31: Every command that uses the minibuffer at least once is recorded on a
32: special history list, together with the values of the minibuffer
33: arguments, so that you can repeat the command easily. In particular,
34: every use of `Meta-x' is recorded, since `M-x' uses the minibuffer to
35: read the command name.
36:
37: `C-x ESC'
38: Re-execute a recent minibuffer command `repeat-complex-command').
39:
40: `M-p'
41: Within `C-x ESC', move to the previous recorded command
42: (`previous-complex-command').
43:
44: `M-n'
45: Within `C-x ESC', move to the next (more recent) recorded command
46: (`next-complex-command').
47:
48: `M-x list-command-history'
49: Display the entire command history, showing all the commands `C-x
50: ESC' can repeat, most recent first.
51:
52: `C-x ESC' is used to re-execute a recent minibuffer-using command.
53: With no argument, it repeats the last such command. A numeric argument
54: specifies which command to repeat; 1 means the last one, and larger
55: numbers specify earlier ones.
56:
57: `C-x ESC' works by turning the previous command into a Lisp
58: expression and then entering a minibuffer initialized with the text for
59: that expression. If you type just RET, the command is repeated as
60: before. You can also change the command by editing the Lisp expression.
61: Whatever expression you finally submit is what will be executed. The
62: repeated command is added to the front of the command history unless it
63: is identical to the most recently executed command already there.
64:
65: Even if you don't understand Lisp syntax, it will probably be obvious
66: which command is displayed for repetition. If you do not change the
67: text, you can be sure it will repeat exactly as before.
68:
69: Once inside the minibuffer for `C-x ESC', if the command shown to
70: you is not the one you want to repeat, you can move around the list of
71: previous commands using `M-n' and `M-p'. `M-p' replaces the contents
72: of the minibuffer with the next earlier recorded command, and `M-n'
73: replaces them with the next later command. After finding the desired
74: previous command, you can edit its expression as usual and then
75: resubmit it by typing RET as usual. Any editing you have done on the
76: command to be repeated is lost if you use `M-n' or `M-p'.
77:
78: `M-p' is more useful than `M-n', since more often you will initially
79: request to repeat the most recent command and then decide to repeat an
80: older one instead. These keys are specially defined within `C-x ESC'
81: to run the commands `previous-complex-command' and
82: `next-complex-command'.
83:
84: The list of previous minibuffer-using commands is stored as a Lisp
85: list in the variable `command-history'. Each element is a Lisp
86: expression which describes one command and its arguments. Lisp
87: programs can reexecute a command by feeding the corresponding
88: `command-history' element to `eval'.
89:
90:
91: File: emacs, Node: M-x, Next: Help, Prev: Minibuffer, Up: Top
92:
93: Running Commands by Name
94: ************************
95:
96: The Emacs commands that are used often or that must be quick to type
97: are bound to keys--short sequences of characters--for convenient use.
98: Other Emacs commands that do not need to be brief are not bound to
99: keys; to run them, you must refer to them by name.
100:
101: A command name is, by convention, made up of one or more words,
102: separated by hyphens; for example, `auto-fill-mode' or `manual-entry'.
103: The use of English words makes the command name easier to remember than
104: a key made up of obscure characters, even though it is more characters
105: to type. Any command can be run by name, even if it is also runnable by
106: keys.
107:
108: The way to run a command by name is to start with `M-x', type the
109: command name, and finish it with RET. `M-x' uses the minibuffer to
110: read the command name. RET exits the minibuffer and runs the command.
111:
112: Emacs uses the minibuffer for reading input for many different
113: purposes; on this occasion, the string `M-x' is displayed at the
114: beginning of the minibuffer as a "prompt" to remind you that your input
115: should be the name of a command to be run. *Note Minibuffer::, for
116: full information on the features of the minibuffer.
117:
118: You can use completion to enter the command name. For example, the
119: command `forward-char' can be invoked by name by typing
120:
121: M-x forward-char RET
122: or
123:
124: M-x fo TAB c RET
125:
126: Note that `forward-char' is the same command that you invoke with the
127: key `C-f'. Any command (interactively callable function) defined in
128: Emacs can be called by its name using `M-x' whether or not any keys are
129: bound to it.
130:
131: If you type `C-g' while the command name is being read, you cancel
132: the `M-x' command and get out of the minibuffer, ending up at top level.
133:
134: To pass a numeric argument to the command you are invoking with
135: `M-x', specify the numeric argument before the `M-x'. `M-x' passes the
136: argument along to the function which it calls. The argument value
137: appears in the prompt while the command name is being read.
138:
139: Normally, when describing a command that is run by name, we omit the
140: RET that is needed to terminate the name. Thus we might speak of `M-x
141: auto-fill-mode' rather than `M-x auto-fill-mode RET'. We mention the
142: RET only when there is a need to emphasize its presence, such as when
143: describing a sequence of input that contains a command name and
144: arguments that follow it.
145:
146: `M-x' is defined to run the command `execute-extended-command',
147: which is responsible for reading the name of another command and
148: invoking it.
149:
150:
151: File: emacs, Node: Help, Next: Mark, Prev: M-x, Up: Top
152:
153: Help
154: ****
155:
156: Emacs provides extensive help features which revolve around a single
157: character, `C-h'. `C-h' is a prefix key that is used only for
158: documentation-printing commands. The characters that you can type after
159: `C-h' are called "help options". One help option is `C-h'; that is how
160: you ask for help about using `C-h'.
161:
162: `C-h C-h' prints a list of the possible help options, and then asks
163: you to go ahead and type the option. It prompts with a string
164:
165: A B C F I K L M N S T V W C-c C-d C-n C-w. Type C-h again for more help:
166:
167: and you should type one of those characters.
168:
169: Typing a third `C-h' displays a description of what the options mean;
170: it still waits for you to type an option. To cancel, type `C-g'.
171:
172: Here is a summary of the defined help commands.
173:
174: `C-h a STRING RET'
175: Display a list of commands whose names contain STRING
176: (`command-apropos').
177:
178: `C-h b'
179: Display a table of all key bindings in effect now; local bindings
180: of the current major mode first, followed by all global bindings
181: (`describe-bindings').
182:
183: `C-h c KEY'
184: Print the name of the command that KEY runs
185: (`describe-key-briefly'). `c' is for `character'. For more
186: extensive information on KEY, use `C-h k'.
187:
188: `C-h f FUNCTION RET'
189: Display documentation on the Lisp function named FUNCTION
190: (`describe-function'). Note that commands are Lisp functions, so
191: a command name may be used.
192:
193: `C-h i'
194: Run Info, the program for browsing documentation files (`info').
195: The complete Emacs manual is available on-line in Info.
196:
197: `C-h k KEY'
198: Display name and documentation of the command KEY runs
199: (`describe-key').
200:
201: `C-h l'
202: Display a description of the last 100 characters you typed
203: (`view-lossage').
204:
205: `C-h m'
206: Display documentation of the current major mode (`describe-mode').
207:
208: `C-h n'
209: Display documentation of Emacs changes, most recent first
210: (`view-emacs-news').
211:
212: `C-h s'
213: Display current contents of the syntax table, plus an explanation
214: of what they mean (`describe-syntax').
215:
216: `C-h t'
217: Display the Emacs tutorial (`help-with-tutorial').
218:
219: `C-h v VAR RET'
220: Display the documentation of the Lisp variable VAR
221: (`describe-variable').
222:
223: `C-h w COMMAND RET'
224: Print which keys run the command named COMMAND (`where-is').
225:
226: Documentation for a Key
227: =======================
228:
229: The most basic `C-h' options are `C-h c' (`describe-key-briefly')
230: and `C-h k' (`describe-key'). `C-h c KEY' prints in the echo area the
231: name of the command that KEY is bound to. For example, `C-h c C-f'
232: prints `forward-char'. Since command names are chosen to describe what
233: the command does, this is a good way to get a very brief description of
234: what KEY does.
235:
236: `C-h k KEY' is similar but gives more information. It displays the
237: documentation string of the command KEY is bound to as well as its
238: name. This is too big for the echo area, so a window is used for the
239: display.
240:
241: Help by Command or Variable Name
242: ================================
243:
244: `C-h f' (`describe-function') reads the name of a Lisp function
245: using the minibuffer, then displays that function's documentation string
246: in a window. Since commands are Lisp functions, you can use this to get
247: the documentation of a command that is known by name. For example,
248:
249: C-h f auto-fill-mode RET
250:
251: displays the documentation of `auto-fill-mode'. This is the only way
252: to see the documentation of a command that is not bound to any key (one
253: which you would normally call using `M-x').
254:
255: `C-h f' is also useful for Lisp functions that you are planning to
256: use in a Lisp program. For example, if you have just written the code
257: `(make-vector len)' and want to be sure that you are using
258: `make-vector' properly, type `C-h f make-vector RET'. Because `C-h f'
259: allows all function names, not just command names, you may find that
260: some of your favorite abbreviations that work in `M-x' don't work in
261: `C-h f'. An abbreviation may be unique among command names yet fail to
262: be unique when other function names are allowed.
263:
264: The function name for `C-h f' to describe has a default which is
265: used if you type RET leaving the minibuffer empty. The default is the
266: function called by the innermost Lisp expression in the buffer around
267: point, provided that is a valid, defined Lisp function name. For
268: example, if point is located following the text `(make-vector (car x)',
269: the innermost list containing point is the one that starts with
270: `(make-vector', so the default is to describe the function
271: `make-vector'.
272:
273: `C-h f' is often useful just to verify that you have the right
274: spelling for the function name. If `C-h f' mentions a default in the
275: prompt, you have typed the name of a defined Lisp function. If that
276: tells you what you want to know, just type `C-g' to cancel the `C-h f'
277: command and go on editing.
278:
279: `C-h w COMMAND RET' tells you what keys are bound to COMMAND. It
280: prints a list of the keys in the echo area. Alternatively, it says that
281: the command is not on any keys, which implies that you must use `M-x'
282: to call it.
283:
284: `C-h v' (`describe-variable') is like `C-h f' but describes Lisp
285: variables instead of Lisp functions. Its default is the Lisp symbol
286: around or before point, but only if that is the name of a known Lisp
287: variable. *Note Variables::.
288:
289: Apropos
290: =======
291:
292: A more sophisticated sort of question to ask is, "What are the
293: commands for working with files?" For this, type `C-h a file RET',
294: which displays a list of all command names that contain `file', such as
295: `copy-file', `find-file', and so on. With each command name appears a
296: brief description of how to use the command, and what keys you can
297: currently invoke it with. For example, it would say that you can
298: invoke `find-file' by typing `C-x C-f'. The `a' in `C-h a' stands for
299: `Apropos'; `C-h a' runs the Lisp function `command-apropos'.
300:
301: Because `C-h a' looks only for functions whose names contain the
302: string which you specify, you must use ingenuity in choosing the string.
303: If you are looking for commands for killing backwards and `C-h a
304: kill-backwards RET' doesn't reveal any, don't give up. Try just
305: `kill', or just `backwards', or just `back'. Be persistent. Pretend
306: you are playing Adventure. Also note that you can use a regular
307: expression as the argument (*note Regexps::.).
308:
309: Here is a set of arguments to give to `C-h a' that covers many
310: classes of Emacs commands, since there are strong conventions for naming
311: the standard Emacs commands. By giving you a feel for the naming
312: conventions, this set should also serve to aid you in developing a
313: technique for picking `apropos' strings.
314:
315: char, line, word, sentence, paragraph, region, page, sexp, list,
316: defun, buffer, screen, window, file, dir, register, mode,
317: beginning, end, forward, backward, next, previous, up, down,
318: search, goto, kill, delete, mark, insert, yank, fill, indent, case,
319: change, set, what, list, find, view, describe.
320:
321: To list all Lisp symbols that contain a match for a regexp, not just
322: the ones that are defined as commands, use the command `M-x apropos'
323: instead of `C-h a'.
324:
325: Other Help Commands
326: ===================
327:
328: `C-h i' (`info') runs the Info program, which is used for browsing
329: through structured documentation files. The entire Emacs manual is
330: available within Info. Eventually all the documentation of the GNU
331: system will be available. Type `h' after entering Info to run a
332: tutorial on using Info.
333:
334: If something surprising happens, and you are not sure what commands
335: you typed, use `C-h l' (`view-lossage'). `C-h l' prints the last 100
336: command characters you typed in. If you see commands that you don't
337: know, you can use `C-h c' to find out what they do.
338:
339: Emacs has several major modes, each of which redefines a few keys and
340: makes a few other changes in how editing works. `C-h m'
341: (`describe-mode') prints documentation on the current major mode, which
342: normally describes all the commands that are changed in this mode.
343:
344: `C-h b' (`describe-bindings') and `C-h s' (`describe-syntax')
345: present other information about the current Emacs mode. `C-h b'
346: displays a list of all the key bindings now in effect; the local
347: bindings of the current major mode first, followed by the global
348: bindings (*note Key Bindings::.). `C-h s' displays the contents of the
349: syntax table, with explanations of each character's syntax (*note
350: Syntax::.).
351:
352: The other `C-h' options display various files of useful information.
353: `C-h C-w' displays the full details on the complete absence of
354: warranty for GNU Emacs. `C-h n' (`view-emacs-news') displays the file
355: `emacs/etc/NEWS', which contains documentation on Emacs changes
356: arranged chronologically. `C-h t' (`help-with-tutorial') displays the
357: learn-by-doing Emacs tutorial. `C-h C-c' (`describe-copying') displays
358: the file `emacs/etc/COPYING', which tells you the conditions you must
359: obey in distributing copies of Emacs. `C-h C-d'
360: (`describe-distribution') displays another file named
361: `emacs/etc/DISTRIB', which tells you how you can order a copy of the
362: latest version of Emacs.
363:
364:
365: File: emacs, Node: Mark, Next: Killing, Prev: Help, Up: Top
366:
367: The Mark and the Region
368: ***********************
369:
370: There are many Emacs commands which operate on an arbitrary
371: contiguous part of the current buffer. To specify the text for such a
372: command to operate on, you set the "mark" at one end of it, and move
373: point to the other end. The text between point and the mark is called
374: the "region". You can move point or the mark to adjust the boundaries
375: of the region. It doesn't matter which one is set first
376: chronologically, or which one comes earlier in the text.
377:
378: Once the mark has been set, it remains until it is set again at
379: another place. The mark remains fixed with respect to the preceding
380: character if text is inserted or deleted in the buffer. Each Emacs
381: buffer has its own mark, so that when you return to a buffer that had
382: been selected previously, it has the same mark it had before.
383:
384: Many commands that insert text, such as `C-y' (`yank') and `M-x
385: insert-buffer', position the mark at one end of the inserted text--the
386: opposite end from where point is positioned, so that the region
387: contains the text just inserted.
388:
389: Aside from delimiting the region, the mark is also useful for
390: remembering a spot that you may want to go back to. To make this
391: feature more useful, Emacs remembers 16 previous locations of the mark,
392: in the `mark ring'.
393:
394: * Menu:
395:
396: * Setting Mark:: Commands to set the mark.
397: * Using Region:: Summary of ways to operate on contents of the region.
398: * Marking Objects:: Commands to put region around textual units.
399: * Mark Ring:: Previous mark positions saved so you can go back there.
400:
401:
402: File: emacs, Node: Setting Mark, Next: Using Region, Prev: Mark, Up: Mark
403:
404: Setting the Mark
405: ================
406:
407: Here are some commands for setting the mark:
408:
409: `C-SPC'
410: Set the mark where point is (`set-mark-command').
411:
412: `C-@'
413: The same.
414:
415: `C-x C-x'
416: Interchange mark and point (`exchange-point-and-mark').
417:
418: For example, if you wish to convert part of the buffer to all
419: upper-case, you can use the `C-x C-u' (`upcase-region') command, which
420: operates on the text in the region. You can first go to the beginning
421: of the text to be capitalized, type `C-SPC' to put the mark there, move
422: to the end, and then type `C-x C-u'. Or, you can set the mark at the
423: end of the text, move to the beginning, and then type `C-x C-u'. Most
424: commands that operate on the text in the region have the word `region'
425: in their names.
426:
427: The most common way to set the mark is with the `C-SPC' command
428: (`set-mark-command'). This sets the mark where point is. Then you can
429: move point away, leaving the mark behind. It is actually incorrect to
430: speak of the character `C-SPC'; there is no such character. When you
431: type SPC while holding down CTRL, what you get on most terminals is the
432: character `C-@'. This is the key actually bound to `set-mark-command'.
433: But unless you are unlucky enough to have a terminal where typing
434: `C-SPC' does not produce `C-@', you might as well think of this
435: character as `C-SPC'.
436:
437: Since terminals have only one cursor, there is no way for Emacs to
438: show you where the mark is located. You have to remember. The usual
439: solution to this problem is to set the mark and then use it soon,
440: before you forget where it is. But you can see where the mark is with
441: the command `C-x C-x' (`exchange-point-and-mark') which puts the mark
442: where point was and point where the mark was. The extent of the region
443: is unchanged, but the cursor and point are now at the previous location
444: of the mark.
445:
446: `C-x C-x' is also useful when you are satisfied with the location of
447: point but want to move the mark; do `C-x C-x' to put point there and
448: then you can move it. A second use of `C-x C-x', if necessary, puts
449: the mark at the new location with point back at its original location.
450:
451:
452: File: emacs, Node: Using Region, Next: Marking Objects, Prev: Setting Mark, Up: Mark
453:
454: Operating on the Region
455: =======================
456:
457: Once you have created an active region, you can do many things to
458: the text in it:
459: * Kill it with `C-w' (*note Killing::.).
460:
461: * Save it in a register with `C-x x' (*note Registers::.).
462:
463: * Save it in a buffer or a file (*note Accumulating Text::.).
464:
465: * Convert case with `C-x C-l' or `C-x C-u'
466: (*note Case::.).
467:
468: * Evaluate it as Lisp code with `M-x eval-region' (*note Lisp
469: Eval::.).
470:
471: * Fill it as text with `M-g' (*note Filling::.).
472:
473: * Print hardcopy with `M-x print-region' (*note Hardcopy::.).
474:
475: * Indent it with `C-x TAB' or `C-M-\'
476: (*note Indentation::.).
477:
478:
479: File: emacs, Node: Marking Objects, Next: Mark Ring, Prev: Using Region, Up: Mark
480:
481: Commands to Mark Textual Objects
482: ================================
483:
484: There are commands for placing point and the mark around a textual
485: object such as a word, list, paragraph or page.
486:
487: `M-@'
488: Set mark after end of next word (`mark-word'). This command and
489: the following one do not move point.
490:
491: `C-M-@'
492: Set mark after end of next Lisp expression (`mark-sexp').
493:
494: `M-h'
495: Put region around current paragraph (`mark-paragraph').
496:
497: `C-M-h'
498: Put region around current Lisp defun (`mark-defun').
499:
500: `C-x h'
501: Put region around entire buffer (`mark-whole-buffer').
502:
503: `C-x C-p'
504: Put region around current page (`mark-page').
505:
506: `M-@' (`mark-word') puts the mark at the end of the next word, while
507: `C-M-@' (`mark-sexp') puts it at the end of the next Lisp expression.
508: These characters allow you to save a little typing or redisplay,
509: sometimes.
510:
511: Other commands set both point and mark, to delimit an object in the
512: buffer. `M-h' (`mark-paragraph') moves point to the beginning of the
513: paragraph that surrounds or follows point, and puts the mark at the end
514: of that paragraph (*note Paragraphs::.). `M-h' does all that's
515: necessary if you wish to indent, case-convert, or kill a whole
516: paragraph. `C-M-h' (`mark-defun') similarly puts point before and the
517: mark after the current or following defun (*note Defuns::.). `C-x C-p'
518: (`mark-page') puts point before the current page (or the next or
519: previous, according to the argument), and mark at the end (*note
520: Pages::.). The mark goes after the terminating page delimiter (to
521: include it), while point goes after the preceding page delimiter (to
522: exclude it). Finally, `C-x h' (`mark-whole-buffer') sets up the entire
523: buffer as the region, by putting point at the beginning and the mark at
524: the end.
525:
526:
527: File: emacs, Node: Mark Ring, Prev: Marking Objects, Up: Mark
528:
529: The Mark Ring
530: =============
531:
532: Aside from delimiting the region, the mark is also useful for
533: remembering a spot that you may want to go back to. To make this
534: feature more useful, Emacs remembers 16 previous locations of the mark,
535: in the "mark ring". Most commands that set the mark push the old mark
536: onto this ring. To return to a marked location, use `C-u C-SPC' (or
537: `C-u C-@'); this is the command `set-mark-command' given a numeric
538: argument. It moves point to where the mark was, and restores the mark
539: from the ring of former marks. So repeated use of this command moves
540: point to all of the old marks on the ring, one by one. The marks you
541: see go to the end of the ring, so no marks are lost.
542:
543: Each buffer has its own mark ring. All editing commands use the
544: current buffer's mark ring. In particular, `C-u C-SPC' always stays in
545: the same buffer.
546:
547: Many commands that can move long distances, such as `M-<'
548: (`beginning-of-buffer'), start by setting the mark and saving the old
549: mark on the mark ring. This is to make it easier for you to move back
550: later. Searches do this except when they do not actually move point.
551: You can tell when a command sets the mark because `Mark Set' is printed
552: in the echo area.
553:
554: Another way of remembering positions so you can go back to them is
555: with registers (*note RegPos::.).
556:
557: The variable `mark-ring-max' is the maximum number of entries to
558: keep in the mark ring. If that many entries exist and another one is
559: pushed, the last one in the list is discarded. Repeating `C-u C-SPC'
560: circulates through the limited number of entries that are currently in
561: the ring.
562:
563: The variable `mark-ring' holds the mark ring itself, as a list of
564: marker objects in the order most recent first. This variable is local
565: in every buffer.
566:
567:
568: File: emacs, Node: Killing, Next: Yanking, Prev: Mark, Up: Top
569:
570: Deletion and Killing
571: ====================
572:
573: Most commands which erase text from the buffer save it so that you
574: can get it back if you change your mind, or move or copy it to other
575: parts of the buffer. These commands are known as "kill" commands. The
576: rest of the commands that erase text do not save it; they are known as
577: "delete" commands. (This distinction is made only for erasure of text
578: in the buffer.)
579:
580: The delete commands include `C-d' (`delete-char') and DEL
581: (`delete-backward-char'), which delete only one character at a time,
582: and those commands that delete only spaces or newlines. Commands that
583: can destroy significant amounts of nontrivial data generally kill. The
584: commands' names and individual descriptions use the words `kill' and
585: `delete' to say which they do. If you do a kill or delete command by
586: mistake, you can use the `C-x u' (`undo') command to undo it (*note
587: Undo::.).
588:
589: Deletion
590: --------
591:
592: `C-d'
593: Delete next character (`delete-char').
594:
595: `DEL'
596: Delete previous character (`delete-backward-char').
597:
598: `M-\'
599: Delete spaces and tabs around point (`delete-horizontal-space').
600:
601: `M-SPC'
602: Delete spaces and tabs around point, leaving one space
603: (`just-one-space').
604:
605: `C-x C-o'
606: Delete blank lines around the current line (`delete-blank-lines').
607:
608: `M-^'
609: Join two lines by deleting the intervening newline, and any
610: indentation following it (`delete-indentation').
611:
612: The most basic delete commands are `C-d' (`delete-char') and DEL
613: (`delete-backward-char'). `C-d' deletes the character after point, the
614: one the cursor is "on top of". Point doesn't move. DEL deletes the
615: character before the cursor, and moves point back. Newlines can be
616: deleted like any other characters in the buffer; deleting a newline
617: joins two lines. Actually, `C-d' and DEL aren't always delete
618: commands; if given an argument, they kill instead, since they can erase
619: more than one character this way.
620:
621: The other delete commands are those which delete only formatting
622: characters: spaces, tabs and newlines. `M-\'
623: (`delete-horizontal-space') deletes all the spaces and tab characters
624: before and after point. `M-SPC' (`just-one-space') does likewise but
625: leaves a single space after point, regardless of the number of spaces
626: that existed previously (even zero).
627:
628: `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
629: current line, and if the current line is blank deletes all blank lines
630: preceding the current line as well (leaving one blank line, the current
631: line). `M-^' (`delete-indentation') joins the current line and the
632: previous line, or the current line and the next line if given an
633: argument, by deleting a newline and all surrounding spaces, possibly
634: leaving a single space. *Note M-^: Indentation.
635:
636: Killing by Lines
637: ----------------
638:
639: `C-k'
640: Kill rest of line or one or more lines (`kill-line').
641:
642: The simplest kill command is `C-k'. If given at the beginning of a
643: line, it kills all the text on the line, leaving it blank. If given on
644: a blank line, the blank line disappears. As a consequence, if you go
645: to the front of a non-blank line and type `C-k' twice, the line
646: disappears completely.
647:
648: More generally, `C-k' kills from point up to the end of the line,
649: unless it is at the end of a line. In that case it kills the newline
650: following the line, thus merging the next line into the current one.
651: Invisible spaces and tabs at the end of the line are ignored when
652: deciding which case applies, so if point appears to be at the end of
653: the line, you can be sure the newline will be killed.
654:
655: If `C-k' is given a positive argument, it kills that many lines and
656: the newlines that follow them (however, text on the current line before
657: point is spared). With a negative argument, it kills back to a number
658: of line beginnings. An argument of -2 means kill back to the second
659: line beginning. If point is at the beginning of a line, that line
660: beginning doesn't count, so `C-u - 2 C-k' with point at the front of a
661: line kills the two previous lines.
662:
663: `C-k' with an argument of zero kills all the text before point on the
664: current line.
665:
666: Other Kill Commands
667: -------------------
668:
669: `C-w'
670: Kill region (from point to the mark) (`kill-region'). *Note
671: Words::.
672:
673: `M-d'
674: Kill word (`kill-word').
675:
676: `M-DEL'
677: Kill word backwards (`backward-kill-word').
678:
679: `C-x DEL'
680: Kill back to beginning of sentence (`backward-kill-sentence').
681: *Note Sentences::.
682:
683: `M-k'
684: Kill to end of sentence (`kill-sentence').
685:
686: `C-M-k'
687: Kill sexp (`kill-sexp'). *Note Lists::.
688:
689: `M-z CHAR'
690: Kill up to next occurrence of CHAR (`zap-to-char').
691:
692: A kill command which is very general is `C-w' (`kill-region'), which
693: kills everything between point and the mark. With this command, you
694: can kill any contiguous sequence of characters, if you first set the
695: mark at one end of them and go to the other end.
696:
697: A convenient way of killing is combined with searching: `M-z'
698: (`zap-to-char') reads a character and kills from point up to (but not
699: including) the next occurrence of that character in the buffer. If
700: there is no next occurrence, killing goes to the end of the buffer. A
701: numeric argument acts as a repeat count. A negative argument means to
702: search backward and kill text before point.
703:
704: Other syntactic units can be killed: words, with `M-DEL' and `M-d'
705: (*note Words::.); sexps, with `C-M-k' (*note Lists::.); and sentences,
706: with `C-x DEL' and `M-k' (*note Sentences::.).
707:
708:
709: File: emacs, Node: Yanking, Next: Accumulating Text, Prev: Killing, Up: Top
710:
711: Yanking
712: =======
713:
714: "Yanking" is getting back text which was killed. This is what some
715: systems call "pasting". The usual way to move or copy text is to kill
716: it and then yank it one or more times.
717:
718: `C-y'
719: Yank last killed text (`yank').
720:
721: `M-y'
722: Replace re-inserted killed text with the previously killed text
723: (`yank-pop').
724:
725: `M-w'
726: Save region as last killed text without actually killing it
727: (`copy-region-as-kill').
728:
729: `C-M-w'
730: Append next kill to last batch of killed text (`append-next-kill').
731:
732: * Menu:
733:
734: * Kill Ring:: Where killed text is stored. Basic yanking.
735: * Appending Kills:: Several kills in a row all yank together.
736: * Earlier Kills:: Yanking something killed some time ago.
737:
738:
739: File: emacs, Node: Kill Ring, Next: Appending Kills, Prev: Yanking, Up: Yanking
740:
741: The Kill Ring
742: -------------
743:
744: All killed text is recorded in the "kill ring", a list of blocks of
745: text that have been killed. There is only one kill ring, used in all
746: buffers, so you can kill text in one buffer and yank it in another
747: buffer. This is the usual way to move text from one file to another.
748: (*Note Accumulating Text::, for some other ways.)
749:
750: The command `C-y' (`yank') reinserts the text of the most recent
751: kill. It leaves the cursor at the end of the text. It sets the mark at
752: the beginning of the text. *Note Mark::.
753:
754: `C-u C-y' leaves the cursor in front of the text, and sets the mark
755: after it. This is only if the argument is specified with just a `C-u',
756: precisely. Any other sort of argument, including `C-u' and digits, has
757: an effect described below (under "Yanking Earlier Kills").
758:
759: If you wish to copy a block of text, you might want to use `M-w'
760: (`copy-region-as-kill'), which copies the region into the kill ring
761: without removing it from the buffer. This is approximately equivalent
762: to `C-w' followed by `C-y', except that `M-w' does not mark the buffer
763: as "modified" and does not temporarily change the screen.
764:
765:
766: File: emacs, Node: Appending Kills, Next: Earlier Kills, Prev: Kill Ring, Up: Yanking
767:
768: Appending Kills
769: ---------------
770:
771: Normally, each kill command pushes a new block onto the kill ring.
772: However, two or more kill commands in a row combine their text into a
773: single entry, so that a single `C-y' gets it all back as it was before
774: it was killed. This means that you don't have to kill all the text in
775: one command; you can keep killing line after line, or word after word,
776: until you have killed it all, and you can still get it all back at
777: once. (Thus we join television in leading people to kill
778: thoughtlessly.)
779:
780: Commands that kill forward from point add onto the end of the
781: previous killed text. Commands that kill backward from point add onto
782: the beginning. This way, any sequence of mixed forward and backward
783: kill commands puts all the killed text into one entry without
784: rearrangement. Numeric arguments do not break the sequence of appending
785: kills. For example, suppose the buffer contains
786:
787: This is the first
788: line of sample text
789: and here is the third.
790:
791: with point at the beginning of the second line. If you type `C-k C-u 2
792: M-DEL C-k', the first `C-k' kills the text `line of sample text', `C-u
793: 2 M-DEL' kills `the first' with the newline that followed it, and the
794: second `C-k' kills the newline after the second line. The result is
795: that the buffer contains `This is and here is the third.' and a single
796: kill entry contains `the firstRETline of sample textRET'--all the
797: killed text, in its original order.
798:
799: If a kill command is separated from the last kill command by other
800: commands (not just numeric arguments), it starts a new entry on the kill
801: ring. But you can force it to append by first typing the command
802: `C-M-w' (`append-next-kill') in front of it. The `C-M-w' tells the
803: following command, if it is a kill command, to append the text it kills
804: to the last killed text, instead of starting a new entry. With
805: `C-M-w', you can kill several separated pieces of text and accumulate
806: them to be yanked back in one place.
807:
808:
809: File: emacs, Node: Earlier Kills, Prev: Appending Kills, Up: Yanking
810:
811: Yanking Earlier Kills
812: ---------------------
813:
814: To recover killed text that is no longer the most recent kill, you
815: need the `Meta-y' (`yank-pop') command. `M-y' can be used only after a
816: `C-y' or another `M-y'. It takes the text previously yanked and
817: replaces it with the text from an earlier kill. So, to recover the
818: text of the next-to-the-last kill, you first use `C-y' to recover the
819: last kill, and then use `M-y' to replace it with the previous kill.
820:
821: You can think in terms of a "last yank" pointer which points at an
822: item in the kill ring. Each time you kill, the "last yank" pointer
823: moves to the newly made item at the front of the ring. `C-y' yanks the
824: item which the "last yank" pointer points to. `M-y' moves the "last
825: yank" pointer to a different item, and the text in the buffer changes to
826: match. Enough `M-y' commands can move the pointer to any item in the
827: ring, so you can get any item into the buffer. Eventually the pointer
828: reaches the end of the ring; the next `M-y' moves it to the first item
829: again.
830:
831: Yanking moves the "last yank" pointer around the ring, but it does
832: not change the order of the entries in the ring, which always runs from
833: the most recent kill at the front to the oldest one still remembered.
834:
835: `M-y' can take a numeric argument, which tells it how many items to
836: advance the "last yank" pointer by. A negative argument moves the
837: pointer toward the front of the ring; from the front of the ring, it
838: moves to the last entry and starts moving forward from there.
839:
840: Once the text you are looking for is brought into the buffer, you can
841: stop doing `M-y' commands and it will stay there. It's just a copy of
842: the kill ring item, so editing it in the buffer does not change what's
843: in the ring. As long as no new killing is done, the "last yank" pointer
844: remains at the same place in the kill ring, so repeating `C-y' will
845: yank another copy of the same old kill.
846:
847: If you know how many `M-y' commands it would take to find the text
848: you want, you can yank that text in one step using `C-y' with a numeric
849: argument. `C-y' with an argument greater than one restores the text
850: the specified number of entries back in the kill ring. Thus, `C-u 2
851: C-y' gets the next to the last block of killed text. It is equivalent
852: to `C-y M-y'. `C-y' with a numeric argument starts counting from the
853: "last yank" pointer, and sets the "last yank" pointer to the entry that
854: it yanks.
855:
856: The length of the kill ring is controlled by the variable
857: `kill-ring-max'; no more than that many blocks of killed text are saved.
858:
859:
860: File: emacs, Node: Accumulating Text, Next: Rectangles, Prev: Yanking, Up: Top
861:
862: Accumulating Text
863: =================
864:
865: Usually we copy or move text by killing it and yanking it, but there
866: are other ways that are useful for copying one block of text in many
867: places, or for copying many scattered blocks of text into one place.
868:
869: You can accumulate blocks of text from scattered locations either
870: into a buffer or into a file if you like. These commands are described
871: here. You can also use Emacs registers for storing and accumulating
872: text. *Note Registers::.
873:
874: `C-x a'
875: Append region to contents of specified buffer (`append-to-buffer').
876:
877: `M-x prepend-to-buffer'
878: Prepend region to contents of specified buffer.
879:
880: `M-x copy-to-buffer'
881: Copy region into specified buffer, deleting that buffer's old
882: contents.
883:
884: `M-x insert-buffer'
885: Insert contents of specified buffer into current buffer at point.
886:
887: `M-x append-to-file'
888: Append region to contents of specified file, at the end.
889:
890: To accumulate text into a buffer, use the command `C-x a BUFFERNAME'
891: (`append-to-buffer'), which inserts a copy of the region into the
892: buffer BUFFERNAME, at the location of point in that buffer. If there
893: is no buffer with that name, one is created. If you append text into a
894: buffer which has been used for editing, the copied text goes into the
895: middle of the text of the buffer, wherever point happens to be in it.
896:
897: Point in that buffer is left at the end of the copied text, so
898: successive uses of `C-x a' accumulate the text in the specified buffer
899: in the same order as they were copied. Strictly speaking, `C-x a' does
900: not always append to the text already in the buffer; but if `C-x a' is
901: the only command used to alter a buffer, it does always append to the
902: existing text because point is always at the end.
903:
904: `M-x prepend-to-buffer' is just like `C-x a' except that point in
905: the other buffer is left before the copied text, so successive
906: prependings add text in reverse order. `M-x copy-to-buffer' is similar
907: except that any existing text in the other buffer is deleted, so the
908: buffer is left containing just the text newly copied into it.
909:
910: You can retrieve the accumulated text from that buffer with `M-x
911: insert-buffer'; this too takes BUFFERNAME as an argument. It inserts a
912: copy of the text in buffer BUFFERNAME into the selected buffer. You
913: could alternatively select the other buffer for editing, perhaps moving
914: text from it by killing or with `C-x a'. *Note Buffers::, for
915: background information on buffers.
916:
917: Instead of accumulating text within Emacs, in a buffer, you can
918: append text directly into a file with `M-x append-to-file', which takes
919: FILE-NAME as an argument. It adds the text of the region to the end of
920: the specified file. The file is changed immediately on disk. This
921: command is normally used with files that are not being visited in
922: Emacs. Using it on a file that Emacs is visiting can produce confusing
923: results, because the text inside Emacs for that file will not change
924: while the file itself changes.
925:
926:
927: File: emacs, Node: Rectangles, Next: Registers, Prev: Accumulating Text, Up: Top
928:
929: Rectangles
930: ==========
931:
932: The rectangle commands affect rectangular areas of the text: all the
933: characters between a certain pair of columns, in a certain range of
934: lines. Commands are provided to kill rectangles, yank killed
935: rectangles, clear them out, or delete them. Rectangle commands are
936: useful with text in multicolumnar formats, such as perhaps code with
937: comments at the right, or for changing text into or out of such formats.
938:
939: When you must specify a rectangle for a command to work on, you do
940: it by putting the mark at one corner and point at the opposite corner.
941: The rectangle thus specified is called the "region-rectangle" because
942: it is controlled about the same way the region is controlled. But
943: remember that a given combination of point and mark values can be
944: interpreted either as specifying a region or as specifying a rectangle;
945: it is up to the command that uses them to choose the interpretation.
946:
947: `M-x delete-rectangle'
948: Delete the text of the region-rectangle, moving any following text
949: on each line leftward to the left edge of the region-rectangle.
950:
951: `M-x kill-rectangle'
952: Similar, but also save the contents of the region-rectangle as the
953: "last killed rectangle".
954:
955: `M-x yank-rectangle'
956: Yank the last killed rectangle with its upper left corner at point.
957:
958: `M-x open-rectangle'
959: Insert blank space to fill the space of the region-rectangle. The
960: previous contents of the region-rectangle are pushed rightward.
961:
962: `M-x clear-rectangle'
963: Clear the region-rectangle by replacing its contents with spaces.
964:
965: The rectangle operations fall into two classes: commands deleting and
966: moving rectangles, and commands for blank rectangles.
967:
968: There are two ways to get rid of the text in a rectangle: you can
969: discard the text (delete it) or save it as the "last killed" rectangle.
970: The commands for these two ways are `M-x delete-rectangle' and `M-x
971: kill-rectangle'. In either case, the portion of each line that falls
972: inside the rectangle's boundaries is deleted, causing following text
973: (if any) on the line to move left.
974:
975: Note that "killing" a rectangle is not killing in the usual sense;
976: the rectangle is not stored in the kill ring, but in a special place
977: that can only record the most recent rectangle killed. This is because
978: yanking a rectangle is so different from yanking linear text that
979: different yank commands have to be used and yank-popping is hard to
980: make sense of.
981:
982: Inserting a rectangle is the opposite of deleting one. All you need
983: to specify is where to put the upper left corner; that is done by
984: putting point there. The rectangle's first line is inserted there, the
985: rectangle's second line is inserted at a point one line vertically
986: down, and so on. The number of lines affected is determined by the
987: height of the saved rectangle.
988:
989: To insert the last killed rectangle, type `M-x yank-rectangle'. This
990: can be used to convert single-column lists into double-column lists;
991: kill the second half of the list as a rectangle and then yank it beside
992: the first line of the list.
993:
994: There are two commands for working with blank rectangles: `M-x
995: clear-rectangle' to blank out existing text, and `M-x open-rectangle'
996: to insert a blank rectangle. Clearing a rectangle is equivalent to
997: deleting it and then inserting as blank rectangle of the same size.
998:
999: Rectangles can also be copied into and out of registers. *Note
1000: Rectangle Registers: RegRect.
1001:
1002:
1003: File: emacs, Node: Registers, Next: Display, Prev: Rectangles, Up: Top
1004:
1005: Registers
1006: *********
1007:
1008: Emacs "registers" are places you can save text or positions for
1009: later use. Text saved in a register can be copied into the buffer once
1010: or many times; a position saved in a register is used by moving point
1011: to that position. Rectangles can also be copied into and out of
1012: registers (*note Rectangles::.).
1013:
1014: Each register has a name, which is a single character. A register
1015: can store either a piece of text or a position or a rectangle, but only
1016: one thing at any given time. Whatever you store in a register remains
1017: there until you store something else in that register.
1018:
1019: * Menu:
1020:
1021: * RegPos:: Saving positions in registers.
1022: * RegText:: Saving text in registers.
1023: * RegRect:: Saving rectangles in registers.
1024:
1025: `M-x view-register RET R'
1026: Display a description of what register R contains.
1027:
1028: `M-x view-register' reads a register name as an argument and then
1029: displays the contents of the specified register.
1030:
1031:
1032: File: emacs, Node: RegPos, Next: RegText, Prev: Registers, Up: Registers
1033:
1034: Saving Positions in Registers
1035: =============================
1036:
1037: Saving a position records a spot in a buffer so that you can move
1038: back there later. Moving to a saved position reselects the buffer and
1039: moves point to the spot.
1040:
1041: `C-x / R'
1042: Save location of point in register R (`point-to-register').
1043:
1044: `C-x j R'
1045: Jump to the location saved in register R (`register-to-point').
1046:
1047: To save the current location of point in a register, choose a name R
1048: and type `C-x / R'. The register R retains the location thus saved
1049: until you store something else in that register.
1050:
1051: The command `C-x j R' moves point to the location recorded in
1052: register R. The register is not affected; it continues to record the
1053: same location. You can jump to the same position using the same
1054: register any number of times.
1055:
1056:
1057: File: emacs, Node: RegText, Next: RegRect, Prev: RegPos, Up: Registers
1058:
1059: Saving Text in Registers
1060: ========================
1061:
1062: When you want to insert a copy of the same piece of text frequently,
1063: it may be impractical to use the kill ring, since each subsequent kill
1064: moves the piece of text further down on the ring. It becomes hard to
1065: keep track of what argument is needed to retrieve the same text with
1066: `C-y'. An alternative is to store the text in a register with `C-x x'
1067: (`copy-to-register') and then retrieve it with `C-x g'
1068: (`insert-register').
1069:
1070: `C-x x R'
1071: Copy region into register R (`copy-to-register').
1072:
1073: `C-x g R'
1074: Insert text contents of register R (`insert-register').
1075:
1076: `C-x x R' stores a copy of the text of the region into the register
1077: named R. Given a numeric argument, `C-x x' deletes the text from the
1078: buffer as well.
1079:
1080: `C-x g R' inserts in the buffer the text from register R. Normally
1081: it leaves point before the text and places the mark after, but with a
1082: numeric argument it puts point after the text and the mark before.
1083:
1084:
1085: File: emacs, Node: RegRect, Prev: RegText, Up: Registers
1086:
1087: Saving Rectangles in Registers
1088: ==============================
1089:
1090: A register can contain a rectangle instead of linear text. The
1091: rectangle is represented as a list of strings. *Note Rectangles::, for
1092: basic information on rectangles and how rectangles in the buffer are
1093: specified.
1094:
1095: `C-x r R'
1096: Copy the region-rectangle into register R
1097: (`copy-region-to-rectangle'). With numeric argument, delete it as
1098: well.
1099:
1100: `C-x g R'
1101: Insert the rectangle stored in register R (if it contains a
1102: rectangle) (`insert-register').
1103:
1104: The `C-x g' command inserts linear text if the register contains
1105: that, or inserts a rectangle if the register contains one.
1106:
1107:
1108: File: emacs, Node: Display, Next: Search, Prev: Registers, Up: Top
1109:
1110: Controlling the Display
1111: ***********************
1112:
1113: Since only part of a large buffer fits in the window, Emacs tries to
1114: show the part that is likely to be interesting. The display control
1115: commands allow you to specify which part of the text you want to see.
1116:
1117: `C-l'
1118: Clear screen and redisplay, scrolling the selected window to center
1119: point vertically within it (`recenter').
1120:
1121: `C-v'
1122: Scroll forward (a windowful or a specified number of lines)
1123: (`scroll-up').
1124:
1125: `M-v'
1126: Scroll backward (`scroll-down').
1127:
1128: `ARG C-l'
1129: Scroll so point is on line ARG (`recenter').
1130:
1131: `C-x <'
1132: Scroll text in current window to the left (`scroll-left').
1133:
1134: `C-x >'
1135: Scroll to the right (`scroll-right').
1136:
1137: `C-x $'
1138: Make deeply indented lines invisible (`set-selective-display').
1139:
1140: * Menu:
1141:
1142: * Scrolling:: Moving text up and down in a window.
1143: * Horizontal Scrolling:: Moving text left and right in a window.
1144: * Selective Display:: Hiding lines with lots of indentation.
1145: * Display Vars:: Information on variables for customizing display.
1146:
1147:
1148: File: emacs, Node: Scrolling, Next: Horizontal Scrolling, Prev: Display, Up: Display
1149:
1150: Scrolling
1151: =========
1152:
1153: If a buffer contains text that is too large to fit entirely within a
1154: window that is displaying the buffer, Emacs shows a contiguous section
1155: of the text. The section shown always contains point.
1156:
1157: "Scrolling" means moving text up or down in the window so that
1158: different parts of the text are visible. Scrolling forward means that
1159: text moves up, and new text appears at the bottom. Scrolling backward
1160: moves text down and new text appears at the top.
1161:
1162: Scrolling happens automatically if you move point past the bottom or
1163: top of the window. You can also explicitly request scrolling with the
1164: commands in this section.
1165:
1166: `C-l'
1167: Clear screen and redisplay, scrolling the selected window to center
1168: point vertically within it (`recenter').
1169:
1170: `C-v'
1171: Scroll forward (a windowful or a specified number of lines)
1172: (`scroll-up').
1173:
1174: `M-v'
1175: Scroll backward (`scroll-down').
1176:
1177: `ARG C-l'
1178: Scroll so point is on line ARG (`recenter').
1179:
1180: The most basic scrolling command is `C-l' (`recenter') with no
1181: argument. It clears the entire screen and redisplays all windows. In
1182: addition, the selected window is scrolled so that point is halfway down
1183: from the top of the window.
1184:
1185: The scrolling commands `C-v' and `M-v' let you move all the text in
1186: the window up or down a few lines. `C-v' (`scroll-up') with an
1187: argument shows you that many more lines at the bottom of the window,
1188: moving the text and point up together as `C-l' might. `C-v' with a
1189: negative argument shows you more lines at the top of the window.
1190: `Meta-v' (`scroll-down') is like `C-v', but moves in the opposite
1191: direction.
1192:
1193: To read the buffer a windowful at a time, use `C-v' with no argument.
1194: It takes the last two lines at the bottom of the window and puts them at
1195: the top, followed by nearly a whole windowful of lines not previously
1196: visible. If point was in the text scrolled off the top, it moves to the
1197: new top of the window. `M-v' with no argument moves backward with
1198: overlap similarly. The number of lines of overlap across a `C-v' or
1199: `M-v' is controlled by the variable `next-screen-context-lines'; by
1200: default, it is two.
1201:
1202: Another way to do scrolling is with `C-l' with a numeric argument.
1203: `C-l' does not clear the screen when given an argument; it only scrolls
1204: the selected window. With a positive argument N, it repositions text
1205: to put point N lines down from the top. An argument of zero puts point
1206: on the very top line. Point does not move with respect to the text;
1207: rather, the text and point move rigidly on the screen. `C-l' with a
1208: negative argument puts point that many lines from the bottom of the
1209: window. For example, `C-u - 1 C-l' puts point on the bottom line, and
1210: `C-u - 5 C-l' puts it five lines from the bottom. Just `C-u' as
1211: argument, as in `C-u C-l', scrolls point to the center of the screen.
1212:
1213: Scrolling happens automatically if point has moved out of the visible
1214: portion of the text when it is time to display. Usually the scrolling
1215: is done so as to put point vertically centered within the window.
1216: However, if the variable `scroll-step' has a nonzero value, an attempt
1217: is made to scroll the buffer by that many lines; if that is enough to
1218: bring point back into visibility, that is what is done.
1219:
1220:

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.