![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-2 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / info|
Return to emacs-2 CVS log | Up to [Apple XNU] / GNUtools / emacs / info |
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: Commands, Next: Entering Emacs, Prev: Keys, Up: Top
27:
28: Keys and Commands
29: =================
30:
31: This manual is full of passages that tell you what particular keys
32: do. But Emacs does not assign meanings to keys directly. Instead, Emacs
33: assigns meanings to "functions", and then gives keys their meanings by
34: "binding" them to functions.
35:
36: A function is a Lisp object that can be executed as a program.
37: Usually it is a Lisp symbol which has been given a function definition;
38: every symbol has a name, usually made of a few English words separated
39: by dashes, such as `next-line' or `forward-word'. It also has a
40: "definition" which is a Lisp program; this is what makes the function
41: do what it does. Only some functions can be the bindings of keys;
42: these are functions whose definitions use `interactive' to specify how
43: to call them interactively. Such functions are called "commands", and
44: their names are "command names". *Note Defining Commands:
45: (elisp)Defining Commands, for more information.
46:
47: The bindings between keys and functions are recorded in various
48: tables called "keymaps". *Note Keymaps::.
49:
50: When we say that "`C-n' moves down vertically one line" we are
51: glossing over a distinction that is irrelevant in ordinary use but is
52: vital in understanding how to customize Emacs. It is the function
53: `next-line' that is programmed to move down vertically. `C-n' has this
54: effect because it is bound to that function. If you rebind `C-n' to
55: the function `forward-word' then `C-n' will move forward by words
56: instead. Rebinding keys is a common method of customization.
57:
58: In the rest of this manual, we usually ignore this subtlety to keep
59: things simple. To give the customizer the information he needs, we
60: state the name of the command which really does the work in parentheses
61: after mentioning the key that runs it. For example, we will say that
62: "The command `C-n' (`next-line') moves point vertically down," meaning
63: that `next-line' is a command that moves vertically down and `C-n' is a
64: key that is standardly bound to it.
65:
66: While we are on the subject of information for customization only,
67: it's a good time to tell you about "variables". Often the description
68: of a command will say, "To change this, set the variable `mumble-foo'."
69: A variable is a name used to remember a value. Most of the variables
70: documented in this manual exist just to facilitate customization: some
71: command or other part of Emacs examines the variable and behaves
72: differently accordingly. Until you are interested in customizing, you
73: can ignore the information about variables. When you are ready to be
74: interested, read the basic information on variables, and then the
75: information on individual variables will make sense. *Note Variables::.
76:
77:
78: File: emacs, Node: Entering Emacs, Next: Exiting, Prev: Commands, Up: Top
79:
80: Entering and Exiting Emacs
81: **************************
82:
83: The usual way to invoke Emacs is just to type `emacs RET' at the
84: shell. Emacs clears the screen and then displays an initial advisor
85: message and copyright notice. You can begin typing Emacs commands
86: immediately afterward.
87:
88: Some operating systems insist on discarding all type-ahead when Emacs
89: starts up; they give Emacs no way to prevent this. Therefore, it is
90: wise to wait until Emacs clears the screen before typing your first
91: editing command.
92:
93: Before Emacs reads the first command, you have not had a chance to
94: give a command to specify a file to edit. But Emacs must always have a
95: current buffer for editing. In an attempt to do something useful,
96: Emacs presents a buffer named `*scratch*' which is in Lisp Interaction
97: mode; you can use it to type Lisp expressions and evaluate them, or you
98: can ignore that capability and simply doodle. (You can specify a
99: different major mode for this buffer by setting the variable
100: `initial-major-mode' in your init file. *Note Init File::.)
101:
102: It is also possible to specify files to be visited, Lisp files to be
103: loaded, and functions to be called, by giving Emacs arguments in the
104: shell command line. *Note Command Switches::.
105:
106:
107: File: emacs, Node: Exiting, Next: Command Switches, Prev: Entering Emacs, Up: Top
108:
109: Exiting Emacs
110: =============
111:
112: There are two commands for exiting Emacs because there are two kinds
113: of exiting: "suspending" Emacs and "killing" Emacs. "Suspending" means
114: stopping Emacs temporarily and returning control to its superior
115: (usually the shell), allowing you to resume editing later in the same
116: Emacs job, with the same files, same kill ring, same undo history, and
117: so on. This is the usual way to exit. "Killing" Emacs means
118: destroying the Emacs job. You can run Emacs again later, but you will
119: get a fresh Emacs; there is no way to resume the same editing session
120: after it has been killed.
121:
122: `C-z'
123: Suspend Emacs (`suspend-emacs').
124:
125: `C-x C-c'
126: Kill Emacs (`save-buffers-kill-emacs').
127:
128: To suspend Emacs, type `C-z' (`suspend-emacs'). This takes you back
129: to the shell from which you invoked Emacs. You can resume Emacs with
130: the command `%emacs' if you are using the C shell or the Bourne-Again
131: shell.
132:
133: On systems that do not permit programs to be suspended, `C-z' runs an
134: inferior shell that communicates directly with the terminal, and Emacs
135: waits until you exit the subshell. The only way on these systems to get
136: back to the shell from which Emacs was run (to log out, for example) is
137: to kill Emacs. `C-d' or `exit' are typical commands to exit a subshell.
138:
139: To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs'). A
140: two-character key is used for this to make it harder to type. Unless a
141: numeric argument is used, this command first offers to save any modified
142: buffers. If you do not save them all, it asks for reconfirmation with
143: `yes' before killing Emacs, since any changes not saved before that
144: will be lost forever. Also, if any subprocesses are still running,
145: `C-x C-c' asks for confirmation about them, since killing Emacs will
146: kill the subprocesses immediately.
147:
148: In most programs running on Unix, certain characters may instantly
149: suspend or kill the program. (In Berkeley Unix these characters are
150: normally `C-z' and `C-c'.) This Unix feature is turned off while you
151: are in Emacs. The meanings of `C-z' and `C-x C-c' as keys in Emacs
152: were inspired by the standard Berkeley Unix meanings of `C-z' and
153: `C-c', but that is their only relationship with Unix. You could
154: customize these keys to do anything (*note Keymaps::.).
155:
156:
157: File: emacs, Node: Command Switches, Next: Basic, Prev: Exiting, Up: Top
158:
159: Command Line Switches and Arguments
160: ===================================
161:
162: GNU Emacs supports command line arguments to request various actions
163: when invoking Emacs. These are for compatibility with other editors and
164: for sophisticated activities. They are not needed for ordinary editing
165: with Emacs, so new users can skip this section.
166:
167: You may be used to using command line arguments with other editors
168: to specify which file to edit. That's because many other editors are
169: designed to be started afresh each time you want to edit. You edit one
170: file and then exit the editor. The next time you want to edit either
171: another file or the same one, you must run the editor again. With these
172: editors, it makes sense to use a command line argument to say which
173: file to edit.
174:
175: The recommended way to use GNU Emacs is to start it only once, just
176: after you log in, and do all your editing in the same Emacs process.
177: Each time you want to edit a different file, you visit it with the
178: existing Emacs, which eventually comes to have many files in it ready
179: for editing. Usually you do not kill the Emacs until you are about to
180: log out.
181:
182: In the usual style of Emacs use, files are nearly always read by
183: typing commands to an editor that is already running. So command line
184: arguments for specifying a file when the editor is started are seldom
185: used.
186:
187: Emacs accepts command-line arguments that specify files to visit,
188: functions to call, and other activities and operating modes.
189:
190: The command arguments are processed in the order they appear in the
191: command argument list; however, certain arguments (the ones in the
192: second table) must be at the front of the list if they are used.
193:
194: Here are the arguments allowed:
195:
196: `FILE'
197: Visit FILE using `find-file'. *Note Visiting::.
198:
199: `+LINENUM FILE'
200: Visit FILE using `find-file', then go to line number LINENUM in it.
201:
202: `-l FILE'
203: `-load FILE'
204: Load a file FILE of Lisp code with the function `load'. *Note Lisp
205: Libraries::.
206:
207: `-f FUNCTION'
208: `-funcall FUNCTION'
209: Call Lisp function FUNCTION with no arguments.
210:
211: `-i FILE'
212: `-insert FILE'
213: Insert the contents of FILE into the current buffer. This is like
214: what `M-x insert-buffer' does; see *Note Misc File Ops::.
215:
216: `-kill'
217: Exit from Emacs without asking for confirmation.
218:
219: The following switches are recognized only at the beginning of the
220: command line. If more than one of them appears, they must appear in the
221: order that they appear in this table.
222:
223: `-t DEVICE'
224: Use DEVICE as the device for terminal input and output.
225:
226: `-d DISPLAY'
227: When running with the X window system, use the display named
228: DISPLAY to make Emacs's X window.
229:
230: `-nw'
231: Don't use a window system; display text only, using an ordinary
232: terminal device. Thus, if you run an X-capable Emacs in an Xterm
233: with `emacs -nw', it displays in the Xterm's own window instead of
234: making its own.
235:
236: `-batch'
237: Run Emacs in "batch mode", which means that the text being edited
238: is not displayed and the standard Unix interrupt characters such
239: as `C-z' and `C-c' continue to have their normal effect. Emacs in
240: batch mode outputs to `stdout' only what would normally be printed
241: in the echo area under program control.
242:
243: Batch mode is used for running programs written in Emacs Lisp from
244: shell scripts, makefiles, and so on. Normally the `-l' switch or
245: `-f' switch will be used as well, to invoke a Lisp program to do
246: the batch processing.
247:
248: `-batch' implies `-q' (do not load an init file). It also causes
249: Emacs to exit after all command switches have been processed. In
250: addition, auto-saving is not done except in buffers for which it
251: has been explicitly requested.
252:
253: `-q'
254: `-no-init-file'
255: Do not load your Emacs init file `~/.emacs'.
256:
257: `-u USER'
258: `-user USER'
259: Load USER's Emacs init file `~USER/.emacs' instead of your own.
260:
261: With X Windows, you can use these additional options to specify how
262: to display the window. Each option has a corresponding resource name
263: (used with `emacs' unless you specify another name with `-rn NAME'),
264: listed with the option, which lets you specify the same parameter using
265: the usual X Windows defaulting mechanism. The corresponding generic
266: resource name (used with `Emacs') is usually made by capitalizing the
267: first letter of the individual resource name, but in some cases it is a
268: completely different string (which is listed below).
269:
270: `-rn NAME'
271: Use NAME instead of `emacs' when looking for X resources.
272:
273: `-font FONTNAME'
274: `-fn FONTNAME'
275: Use font FONTNAME.
276: (Resource `font'.)
277:
278: `-wn NAME'
279: Name the window NAME.
280: (Resource `title'.)
281:
282: `-i'
283: Use a bitmap icon (showing the kitchen sink) rather than a textual
284: icon.
285: (Resource `bitmapIcon'.)
286:
287: `-in NAME'
288: Name the icon NAME. (Resource `iconName'; `Title').
289:
290: `-geometry COORDS'
291: `-w COORDS'
292: Specify the shape and optionally the position of the Emacs window
293: in the usual X way.
294: (Resource `geometry'.)
295:
296: `-b WIDTH'
297: Specify that the window border is WIDTH pixels thick.
298: (Resource `borderWidth'.)
299:
300: `-ib WIDTH'
301: Leave WIDTH blank pixels between the border and the window
302: contents.
303: (Resource `internalBorder'; `BorderWidth'.)
304:
305: `-r'
306: Use reverse video.
307: (Resource `reverseVideo'.)
308:
309: `-fg COLOR'
310: Use color COLOR for text in the window.
311: (Resource `foreground'.)
312:
313: `-bg COLOR'
314: Use the color COLOR for the background of the window.
315: (Resource `background'.)
316:
317: `-bd COLOR'
318: Use color COLOR for the window border.
319: (Resource `borderColor'.)
320:
321: `-cr COLOR'
322: Specify the color, COLOR, to use for the cursor.
323: (Resource `cursorColor'; `Foreground'.)
324:
325: `-ms COLOR'
326: Use color COLOR for the mouse cursor.
327: (Resource `pointerColor'; `Foreground'.)
328:
329: The init file can get access to the command line argument values as
330: the elements of a list in the variable `command-line-args'. (The
331: arguments in the second table above will already have been processed and
332: will not be in the list.) The init file can override the normal
333: processing of the other arguments by setting this variable.
334:
335: One way to use command arguments is to visit many files
336: automatically:
337:
338: emacs *.c
339:
340: passes each `.c' file as a separate argument to Emacs, so that Emacs
341: visits each file (*note Visiting::.).
342:
343: Here is an advanced example that assumes you have a Lisp program
344: file called `hack-c-program.el' which, when loaded, performs some
345: useful operation on current buffer, expected to be a C program.
346:
347: emacs -batch foo.c -l hack-c-program -f save-buffer -kill > log
348:
349: This says to visit `foo.c', load `hack-c-program.el' (which makes
350: changes in the visited file), save `foo.c' (note that `save-buffer' is
351: the function that `C-x C-s' is bound to), and then exit to the shell
352: that this command was done with. `-batch' guarantees there will be no
353: problem redirecting output to `log', because Emacs will not assume that
354: it has a display terminal to work with.
355:
356:
357: File: emacs, Node: Basic, Next: Undo, Prev: Command Switches, Up: Top
358:
359: Basic Editing Commands
360: **********************
361:
362: We now give the basics of how to enter text, make corrections, and
363: save the text in a file. If this material is new to you, you might
364: learn it more easily by running the Emacs learn-by-doing tutorial. To
365: do this, type `Control-h t' (`help-with-tutorial').
366:
367: Inserting Text
368: ==============
369:
370: To insert printing characters into the text you are editing, just
371: type them. This inserts the character into the buffer at the cursor
372: (that is, at "point"; *note Point::.). The cursor moves forward. Any
373: characters after the cursor move forward too. If the text in the
374: buffer is `FOOBAR', with the cursor before the `B', then if you type
375: `XX', you get `FOOXXBAR', with the cursor still before the `B'.
376:
377: To "delete" text you have just inserted, use DEL. DEL deletes the
378: character BEFORE the cursor (not the one that the cursor is on top of
379: or under; that is the character AFTER the cursor). The cursor and all
380: characters after it move backwards. Therefore, if you type a printing
381: character and then type DEL, they cancel out.
382:
383: To end a line and start typing a new one, type RET. This inserts a
384: newline character in the buffer. If point is in the middle of a line,
385: RET splits the line. Typing DEL when the cursor is at the beginning of
386: a line rubs out the newline before the line, thus joining the line with
387: the preceding line.
388:
389: Emacs will split lines automatically when they become too long, if
390: you turn on a special mode called "Auto Fill" mode. *Note Filling::,
391: for how to use Auto Fill mode.
392:
393: Customization information: DEL in most modes runs the command named
394: `delete-backward-char'; RET runs the command `newline', and
395: self-inserting printing characters run the command `self-insert', which
396: inserts whatever character was typed to invoke it. Some major modes
397: rebind DEL to other commands.
398:
399: Direct insertion works for printing characters and SPC, but other
400: characters act as editing commands and do not insert themselves. If you
401: need to insert a control character or a character whose code is above
402: 200 octal, you must "quote" it by typing the character `control-q'
403: (`quoted-insert') first. There are two ways to use `C-q':
404:
405: * `Control-q' followed by any non-graphic character (even `C-g')
406: inserts that character.
407:
408: * `Control-q' followed by three octal digits inserts the character
409: with the specified character code.
410:
411: A numeric argument to `C-q' specifies how many copies of the quoted
412: character should be inserted (*note Arguments::.).
413:
414: If you prefer to have text characters replace (overwrite) existing
415: text rather than shove it to the right, you can enable Overwrite mode,
416: a minor mode. *Note Minor Modes::.
417:
418: Changing the Location of Point
419: ==============================
420:
421: To do more than insert characters, you have to know how to move
422: point (*note Point::.). Here are a few of the commands for doing that.
423:
424: `C-a'
425: Move to the beginning of the line (`beginning-of-line').
426:
427: `C-e'
428: Move to the end of the line (`end-of-line').
429:
430: `C-f'
431: Move forward one character (`forward-char').
432:
433: `C-b'
434: Move backward one character (`backward-char').
435:
436: `M-f'
437: Move forward one word (`forward-word').
438:
439: `M-b'
440: Move backward one word (`backward-word').
441:
442: `C-n'
443: Move down one line, vertically (`next-line'). This command
444: attempts to keep the horizontal position unchanged, so if you
445: start in the middle of one line, you end in the middle of the
446: next. When on the last line of text, `C-n' creates a new line and
447: moves onto it.
448:
449: `C-p'
450: Move up one line, vertically (`previous-line').
451:
452: `C-l'
453: Clear the screen and reprint everything (`recenter'). Text moves
454: on the screen to bring point to the center of the window.
455:
456: `M-r'
457: Move point to left margin on the line halfway down the screen or
458: window (`move-to-window-line'). Text does not move on the screen.
459: A numeric argument says how many screen lines down from the top
460: of the window (zero for the top). A negative argument counts from
461: the bottom (-1 for the bottom).
462:
463: `C-t'
464: Transpose two characters, the ones before and after the cursor
465: (`transpose-chars').
466:
467: `M-<'
468: Move to the top of the buffer (`beginning-of-buffer'). With
469: numeric argument N, move to N/10 of the way from the top. *Note
470: Arguments::, for more information on numeric arguments.
471:
472: `M->'
473: Move to the end of the buffer (`end-of-buffer').
474:
475: `M-x goto-char'
476: Read a number N and move cursor to character number N. Position 1
477: is the beginning of the buffer.
478:
479: `M-x goto-line'
480: Read a number N and move cursor to line number N. Line 1 is the
481: beginning of the buffer.
482:
483: `C-x C-n'
484: Use the current column of point as the "semipermanent goal column"
485: for `C-n' and `C-p' (`set-goal-column'). Henceforth, those
486: commands always move to this column in each line moved into, or as
487: close as possible given the contents of the line. This goal
488: column remains in effect until canceled.
489:
490: `C-u C-x C-n'
491: Cancel the goal column. Henceforth, `C-n' and `C-p' once again
492: try to avoid changing the horizontal position, as usual.
493:
494: If you set the variable `track-eol' to a non-`nil' value, then `C-n'
495: and `C-p' when at the end of the starting line move to the end of the
496: line. Normally, `track-eol' is `nil'.
497:
498: Erasing Text
499: ============
500:
501: `DEL'
502: Delete the character before the cursor (`delete-backward-char').
503:
504: `C-d'
505: Delete the character after the cursor (`delete-char').
506:
507: `C-k'
508: Kill to the end of the line (`kill-line').
509:
510: `M-d'
511: Kill forward to the end of the next word (`kill-word').
512:
513: `M-DEL'
514: Kill back to the beginning of the previous word
515: (`backward-kill-word').
516:
517: You already know about the DEL key which deletes the character
518: before the cursor. Another key, `Control-d', deletes the character
519: after the cursor, causing the rest of the text on the line to shift
520: left. If `Control-d' is typed at the end of a line, that line and the
521: next line are joined together.
522:
523: To erase a larger amount of text, use the `Control-k' key, which
524: kills a line at a time. If `C-k' is done at the beginning or middle of
525: a line, it kills all the text up to the end of the line. If `C-k' is
526: done at the end of a line, it joins that line and the next line.
527:
528: *Note Killing::, for more flexible ways of killing text.
529:
530: Files
531: =====
532:
533: The commands above are sufficient for creating and altering text in
534: an Emacs buffer; the more advanced Emacs commands just make things
535: easier. But to keep any text permanently you must put it in a "file".
536: Files are named units of text which are stored by the operating system
537: for you to retrieve later by name. To look at or use the contents of a
538: file in any way, including editing the file with Emacs, you must
539: specify the file name.
540:
541: Consider a file named `/usr/rms/foo.c'. In Emacs, to begin editing
542: this file, type
543:
544: C-x C-f /usr/rms/foo.c RET
545:
546: Here the file name is given as an "argument" to the command `C-x C-f'
547: (`find-file'). That command uses the "minibuffer" to read the
548: argument, and you type RET to terminate the argument (*note
549: Minibuffer::.).
550:
551: Emacs obeys the command by "visiting" the file: creating a buffer,
552: copying the contents of the file into the buffer, and then displaying
553: the buffer for you to edit. You can make changes in it, and then "save"
554: the file by typing `C-x C-s' (`save-buffer'). This makes the changes
555: permanent by copying the altered contents of the buffer back into the
556: file `/usr/rms/foo.c'. Until then, the changes are only inside your
557: Emacs, and the file `foo.c' is not changed.
558:
559: To create a file, just visit the file with `C-x C-f' as if it already
560: existed. Emacs will make an empty buffer in which you can insert the
561: text you want to put in the file. When you save your text with `C-x
562: C-s', the file will be created.
563:
564: Of course, there is a lot more to learn about using files. *Note
565: Files::.
566:
567: Help
568: ====
569:
570: If you forget what a key does, you can find out with the Help
571: character, which is `C-h'. Type `C-h k' followed by the key you want
572: to know about; for example, `C-h k C-n' tells you all about what `C-n'
573: does. `C-h' is a prefix key; `C-h k' is just one of its subcommands
574: (the command `describe-key'). The other subcommands of `C-h' provide
575: different kinds of help. Type `C-h' three times to get a description
576: of all the help facilities. *Note Help::.
577:
578: * Menu:
579:
580: * Blank Lines:: Commands to make or delete blank lines.
581: * Continuation Lines:: Lines too wide for the screen.
582: * Position Info:: What page, line, row, or column is point on?
583: * Arguments:: Numeric arguments for repeating a command.
584:
585:
586: File: emacs, Node: Blank Lines, Next: Continuation Lines, Prev: Basic, Up: Basic
587:
588: Blank Lines
589: ===========
590:
591: Here are special commands and techniques for putting in and taking
592: out blank lines.
593:
594: `C-o'
595: Insert one or more blank lines after the cursor (`open-line').
596:
597: `C-x C-o'
598: Delete all but one of many consecutive blank lines
599: (`delete-blank-lines').
600:
601: When you want to insert a new line of text before an existing line,
602: you can do it by typing the new line of text, followed by RET. However,
603: it may be easier to see what you are doing if you first make a blank
604: line and then insert the desired text into it. This is easy to do
605: using the key `C-o' (`open-line'), which inserts a newline after point
606: but leaves point in front of the newline. After `C-o', type the text
607: for the new line. `C-o F O O' has the same effect as `F O O RET',
608: except for the final location of point.
609:
610: You can make several blank lines by typing `C-o' several times, or by
611: giving it an argument to tell it how many blank lines to make. *Note
612: Arguments::, for how.
613:
614: If you have many blank lines in a row and want to get rid of them,
615: use `C-x C-o' (`delete-blank-lines'). When point is on a blank line
616: which is adjacent to at least one other blank line, `C-x C-o' deletes
617: all but one of the consecutive blank lines, leaving exactly one. With
618: point on a blank line with no other blank line adjacent to it, the sole
619: blank line is deleted, leaving none. When point is on a nonblank line,
620: `C-x C-o' deletes any blank lines following that nonblank line.
621:
622:
623: File: emacs, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic
624:
625: Continuation Lines
626: ==================
627:
628: If you add too many characters to one line, without breaking it with
629: a RET, the line will grow to occupy two (or more) lines on the screen,
630: with a `\' at the extreme right margin of all but the last of them. The
631: `\' says that the following screen line is not really a distinct line
632: in the text, but just the "continuation" of a line too long to fit the
633: screen. Sometimes it is nice to have Emacs insert newlines
634: automatically when a line gets too long; for this, use Auto Fill mode
635: (*note Filling::.).
636:
637: Instead of continuation, long lines can be displayed by "truncation".
638: This means that all the characters that do not fit in the width of the
639: screen or window do not appear at all. They remain in the buffer,
640: temporarily invisible. `$' is used in the last column instead of `\'
641: to inform you that truncation is in effect.
642:
643: Continuation can be turned off for a particular buffer by setting the
644: variable `truncate-lines' to non-`nil' in that buffer. Truncation
645: instead of continuation also happens whenever horizontal scrolling is
646: in use, and optionally whenever side-by-side windows are in use (*note
647: Windows::.). Altering the value of `truncate-lines' makes it local to
648: the current buffer; until that time, the default value is in effect.
649: The default is initially `nil'. *Note Locals::.
650:
651:
652: File: emacs, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic
653:
654: Cursor Position Information
655: ===========================
656:
657: If you are accustomed to other display editors, you may be surprised
658: that Emacs does not always display the page number or line number of
659: point in the mode line. This is because the text is stored in a way
660: that makes it difficult to compute this information. Displaying them
661: all the time would be intolerably slow. They are not needed very often
662: in Emacs anyway, but there are commands to compute them and print them.
663:
664: `M-x what-page'
665: Print page number of point, and line number within page.
666:
667: `M-x what-line'
668: Print line number of point in the buffer.
669:
670: `M-='
671: Print number of lines in the current region (`count-lines-region').
672:
673: `C-x ='
674: Print character code of character after point, character position
675: of point, and column of point (`what-cursor-position').
676:
677: There are two commands for printing line numbers. `M-x what-line'
678: counts lines from the beginning of the file and prints the line number
679: point is on. The first line of the file is line number 1. These
680: numbers can be used as arguments to `M-x goto-line'. By contrast, `M-x
681: what-page' counts pages from the beginning of the file, and counts lines
682: within the page, printing both of them. *Note Pages::.
683:
684: While on this subject, we might as well mention `M-='
685: (`count-lines-region'), which prints the number of lines in the region
686: (*note Mark::.). *Note Pages::, for the command `C-x l' which counts
687: the lines in the current page.
688:
689: The command `C-x =' (`what-cursor-position') can be used to find out
690: the column that the cursor is in, and other miscellaneous information
691: about point. It prints a line in the echo area that looks like this:
692:
693: Char: x (0170) point=65986 of 563027(12%) x=44
694:
695: (In fact, this is the output produced when point is before the `x=44'
696: in the example.)
697:
698: The two values after `Char:' describe the character following point,
699: first by showing it and second by giving its octal character code.
700:
701: `point=' is followed by the position of point expressed as a
702: character count. The front of the buffer counts as position 1, one
703: character later as 2, and so on. The next, larger number is the total
704: number of characters in the buffer. Afterward in parentheses comes the
705: position expressed as a percentage of the total size.
706:
707: `x=' is followed by the horizontal position of point, in columns
708: from the left edge of the window.
709:
710: If the buffer has been narrowed, making some of the text at the
711: beginning and the end temporarily invisible, `C-x =' prints additional
712: text describing the current visible range. For example, it might say
713:
714: Char: x (0170) point=65986 of 563025(12%) <65102 - 68533> x=44
715:
716: where the two extra numbers give the smallest and largest character
717: position that point is allowed to assume. The characters between those
718: two positions are the visible ones. *Note Narrowing::.
719:
720: If point is at the end of the buffer (or the end of the visible
721: part), `C-x =' omits any description of the character after point. The
722: output looks like
723:
724: point=563026 of 563025(100%) x=0
725:
726:
727: File: emacs, Node: Arguments, Prev: Position Info, Up: Basic
728:
729: Numeric Arguments
730: =================
731:
732: Any Emacs command can be given a "numeric argument". Some commands
733: interpret the argument as a repetition count. For example, giving an
734: argument of ten to the key `C-f' (the command `forward-char', move
735: forward one character) moves forward ten characters. With these
736: commands, no argument is equivalent to an argument of one. Negative
737: arguments are allowed. Often they tell a command to move or act
738: backwards.
739:
740: If your terminal keyboard has a META key, the easiest way to specify
741: a numeric argument is to type digits and/or a minus sign while holding
742: down the META key. For example,
743: M-5 C-n
744:
745: would move down five lines. The characters `Meta-1', `Meta-2', and so
746: on, as well as `Meta--', do this because they are keys bound to
747: commands (`digit-argument' and `negative-argument') that are defined to
748: contribute to an argument for the next command.
749:
750: Another way of specifying an argument is to use the `C-u'
751: (`universal-argument') command followed by the digits of the argument.
752: With `C-u', you can type the argument digits without holding down shift
753: keys. To type a negative argument, start with a minus sign. Just a
754: minus sign normally means -1. `C-u' works on all terminals.
755:
756: `C-u' followed by a character which is neither a digit nor a minus
757: sign has the special meaning of "multiply by four". It multiplies the
758: argument for the next command by four. `C-u' twice multiplies it by
759: sixteen. Thus, `C-u C-u C-f' moves forward sixteen characters. This
760: is a good way to move forward "fast", since it moves about 1/5 of a line
761: in the usual size screen. Other useful combinations are `C-u C-n',
762: `C-u C-u C-n' (move down a good fraction of a screen), `C-u C-u C-o'
763: (make "a lot" of blank lines), and `C-u C-k' (kill four lines).
764:
765: Some commands care only about whether there is an argument, and not
766: about its value. For example, the command `M-q' (`fill-paragraph') with
767: no argument fills text; with an argument, it justifies the text as well.
768: (*Note Filling::, for more information on `M-q'.) Just `C-u' is a
769: handy way of providing an argument for such commands.
770:
771: Some commands use the value of the argument as a repeat count, but do
772: something peculiar when there is no argument. For example, the command
773: `C-k' (`kill-line') with argument N kills N lines, including their
774: terminating newlines. But `C-k' with no argument is special: it kills
775: the text up to the next newline, or, if point is right at the end of
776: the line, it kills the newline itself. Thus, two `C-k' commands with
777: no arguments can kill a nonblank line, just like `C-k' with an argument
778: of one. (*Note Killing::, for more information on `C-k'.)
779:
780: A few commands treat a plain `C-u' differently from an ordinary
781: argument. A few others may treat an argument of just a minus sign
782: differently from an argument of -1. These unusual cases will be
783: described when they come up; they are always for reasons of convenience
784: of use of the individual command.
785:
786: To insert multiple copies of a digit, you can type `C-u COUNT C-u
787: DIGIT'. The second `C-u' ends the numeric argument, so that the
788: following character always acts a key sequence to be executed.
789:
790:
791: File: emacs, Node: Undo, Next: Minibuffer, Prev: Basic, Up: Top
792:
793: Undoing Changes
794: ***************
795:
796: Emacs allows all changes made in the text of a buffer to be undone,
797: up to a certain amount of change (8000 characters). Each buffer records
798: changes individually, and the undo command always applies to the
799: current buffer. Usually each editing command makes a separate entry in
800: the undo records, but some commands such as `query-replace' make many
801: entries, and very simple commands such as self-inserting characters are
802: often grouped to make undoing less tedious.
803:
804: `C-x u'
805: Undo one batch of changes (usually, one command worth) (`undo').
806:
807: `C-_'
808: The same.
809:
810: The command `C-x u' or `C-_' is how you undo. The first time you
811: give this command, it undoes the last change. Point moves to the text
812: affected by the undo, so you can see what was undone.
813:
814: Consecutive repetitions of the `C-_' or `C-x u' commands undo earlier
815: and earlier changes, back to the limit of what has been recorded. If
816: all recorded changes have already been undone, the undo command prints
817: an error message and does nothing.
818:
819: Any command other than an undo command breaks the sequence of undo
820: commands. Starting at this moment, the previous undo commands are
821: considered ordinary changes that can themselves be undone. Thus, to
822: redo changes you have undone, type `C-f' or any other command that will
823: have no important effect, and then give more undo commands.
824:
825: If you notice that a buffer has been modified accidentally, the
826: easiest way to recover is to type `C-_' repeatedly until the stars
827: disappear from the front of the mode line. At this time, all the
828: modifications you made have been cancelled. If you do not remember
829: whether you changed the buffer deliberately, type `C-_' once, and when
830: you see the last change you made undone, you will remember why you made
831: it. If it was an accident, leave it undone. If it was deliberate,
832: redo the change as described in the preceding paragraph.
833:
834: Whenever an undo command makes the stars disappear from the mode
835: line, it means that the buffer contents are the same as they were when
836: the file was last read in or saved.
837:
838: Not all buffers record undo information. Buffers whose names start
839: with spaces don't; these buffers are used internally by Emacs and its
840: extensions to hold text that users don't normally look at or edit.
841: Also, minibuffers, help buffers and documentation buffers don't record
842: undo information. Use the command `buffer-enable-undo' to enable
843: recording undo information in the current buffer.
844:
845: As editing continues, undo lists get longer and longer. To prevent
846: them from using up all available memory space, garbage collection trims
847: back their sizes to thresholds you can set. (For this purpose, the
848: "size" of an undo list measures the cons cells that make up the list,
849: plus the strings of deleted text.)
850:
851: Two variables control the range of acceptable sizes: `undo-limit'
852: and `undo-strong-limit'. Normally, the most recent changes are kept
853: until their size exceeds `undo-limit'; all older changes are discarded.
854: But if a change pushes the size above `undo-strong-limit', it is
855: discarded as well as all older changes. One exception: the most recent
856: set of changes is sacred; garbage collection never discards that. (In
857: Emacs versions 18.57 and 18.58, these variables are called
858: `undo-threshold' and `undo-high-threshold'.)
859:
860: The reason the `undo' command has two keys, `C-x u' and `C-_', set
861: up to run it is that it is worthy of a single-character key, but the
862: way to type `C-_' on some keyboards is not obvious. `C-x u' is an
863: alternative you can type in the same fashion on any terminal.
864:
865:
866: File: emacs, Node: Minibuffer, Next: M-x, Prev: Undo, Up: Top
867:
868: The Minibuffer
869: **************
870:
871: The "minibuffer" is the facility used by Emacs commands to read
872: arguments more complicated than a single number. Minibuffer arguments
873: can be file names, buffer names, Lisp function names, Emacs command
874: names, Lisp expressions, and many other things, depending on the
875: command reading the argument. The usual Emacs editing commands can be
876: used in the minibuffer to edit the argument.
877:
878: When the minibuffer is in use, it appears in the echo area, and the
879: terminal's cursor moves there. The beginning of the minibuffer line
880: displays a "prompt" which says what kind of input you should supply and
881: how it will be used. Often this prompt is derived from the name of the
882: command that the argument is for. The prompt normally ends with a
883: colon.
884:
885: Sometimes a "default argument" appears in parentheses after the
886: colon; it too is part of the prompt. The default will be used as the
887: argument value if you enter an empty argument (e.g., just type RET).
888: For example, commands that read buffer names always show a default,
889: which is the name of the buffer that will be used if you type just RET.
890:
891: The simplest way to give a minibuffer argument is to type the text
892: you want, terminated by RET which exits the minibuffer. You can get out
893: of the minibuffer, canceling the command that it was for, by typing
894: `C-g'.
895:
896: Since the minibuffer uses the screen space of the echo area, it can
897: conflict with other ways Emacs customarily uses the echo area. Here is
898: how Emacs handles such conflicts:
899:
900: * If a command gets an error while you are in the minibuffer, this
901: does not cancel the minibuffer. However, the echo area is needed
902: for the error message and therefore the minibuffer itself is
903: hidden for a while. It comes back after a few seconds, or as soon
904: as you type anything.
905:
906: * If in the minibuffer you use a command whose purpose is to print a
907: message in the echo area, such as `C-x =', the message is printed
908: normally, and the minibuffer is hidden for a while. It comes back
909: after a few seconds, or as soon as you type anything.
910:
911: * Echoing of keystrokes does not take place while the minibuffer is
912: in use.
913:
914: * Menu:
915:
916: * File: Minibuffer File. Entering file names with the minibuffer.
917: * Edit: Minibuffer Edit. How to edit in the minibuffer.
918: * Completion:: An abbreviation facility for minibuffer input.
919: * Repetition:: Re-executing commands that used the minibuffer.
920:
921:
922: File: emacs, Node: Minibuffer File, Next: Minibuffer Edit, Prev: Minibuffer, Up: Minibuffer
923:
924: Minibuffers for File Names
925: ==========================
926:
927: Sometimes the minibuffer starts out with text in it. For example,
928: when you are supposed to give a file name, the minibuffer starts out
929: containing the "default directory", which ends with a slash. This is
930: to inform you which directory the file will be found in if you do not
931: specify a directory. For example, the minibuffer might start out with
932:
933: Find File: /u2/emacs/src/
934:
935: where `Find File: ' is the prompt. Typing `buffer.c' specifies the
936: file `/u2/emacs/src/buffer.c'. To find files in nearby directories,
937: use `..'; thus, if you type `../lisp/simple.el', the file that you
938: visit will be the one named `/u2/emacs/lisp/simple.el'. Alternatively,
939: you can kill with `M-DEL' the directory names you don't want (*note
940: Words::.).
941:
942: You can also type an absolute file name, one starting with a slash
943: or a tilde, ignoring the default directory. For example, to find the
944: file `/etc/termcap', just type the name, giving
945:
946: Find File: /u2/emacs/src//etc/termcap
947:
948: Two slashes in a row are not normally meaningful in Unix file names, but
949: they are allowed in GNU Emacs. They mean, "ignore everything before the
950: second slash in the pair." Thus, `/u2/emacs/src/' is ignored, and you
951: get the file `/etc/termcap'.
952:
953: If you set `insert-default-directory' to `nil', the default directory
954: is not inserted in the minibuffer. This way, the minibuffer starts out
955: empty. But the name you type, if relative, is still interpreted with
956: respect to the same default directory.
957:
958:
959: File: emacs, Node: Minibuffer Edit, Next: Completion, Prev: Minibuffer File, Up: Minibuffer
960:
961: Editing in the Minibuffer
962: =========================
963:
964: The minibuffer is an Emacs buffer (albeit a peculiar one), and the
965: usual Emacs commands are available for editing the text of an argument
966: you are entering.
967:
968: Since RET in the minibuffer is defined to exit the minibuffer,
969: inserting a newline into the minibuffer must be done with `C-o' or with
970: `C-q LFD'. (Recall that a newline is really the LFD character.)
971:
972: The minibuffer has its own window which always has space on the
973: screen but acts as if it were not there when the minibuffer is not in
974: use. When the minibuffer is in use, its window is just like the
975: others; you can switch to another window with `C-x o', edit text in
976: other windows and perhaps even visit more files, before returning to
977: the minibuffer to submit the argument. You can kill text in another
978: window, return to the minibuffer window, and then yank the text to use
979: it in the argument. *Note Windows::.
980:
981: There are some restrictions on the use of the minibuffer window,
982: however. You cannot switch buffers in it--the minibuffer and its window
983: are permanently attached. Also, you cannot split or kill the minibuffer
984: window. But you can make it taller in the normal fashion with `C-x ^'
985: (*note Change Window::.).
986:
987: If while in the minibuffer you issue a command that displays help
988: text of any sort in another window, then that window is identified as
989: the one to scroll if you type `C-M-v' while in the minibuffer. This
990: lasts until you exit the minibuffer. This feature comes into play if a
991: completing minibuffer gives you a list of possible completions.
992:
993: Recursive use of the minibuffer is supported by Emacs. However, it
994: is easy to do this by accident (because of autorepeating keyboards, for
995: example) and get confused. Therefore, most Emacs commands that use the
996: minibuffer refuse to operate if the minibuffer window is selected. If
997: the minibuffer is active but you have switched to a different window,
998: recursive use of the minibuffer is allowed--if you know enough to try
999: to do this, you probably will not get confused.
1000:
1001: If you set the variable `enable-recursive-minibuffers' to be
1002: non-`nil', recursive use of the minibuffer is always allowed.
1003:
1004:
1005: File: emacs, Node: Completion, Next: Repetition, Prev: Minibuffer Edit, Up: Minibuffer
1006:
1007: Completion
1008: ==========
1009:
1010: When appropriate, the minibuffer provides a "completion" facility.
1011: This means that you type enough of the argument to determine the rest,
1012: based on Emacs's knowledge of which arguments make sense, and Emacs
1013: visibly fills in the rest, or as much as can be determined from the
1014: part you have typed.
1015:
1016: When completion is available, certain keys--TAB, RET, and SPC--are
1017: redefined to complete an abbreviation present in the minibuffer into a
1018: longer string that it stands for, by matching it against a set of
1019: "completion alternatives" provided by the command reading the argument.
1020: `?' is defined to display a list of possible completions of what you
1021: have inserted.
1022:
1023: For example, when the minibuffer is being used by `Meta-x' to read
1024: the name of a command, it is given a list of all available Emacs command
1025: names to complete against. The completion keys match the text in the
1026: minibuffer against all the command names, find any additional
1027: characters of the name that are implied by the ones already present in
1028: the minibuffer, and add those characters to the ones you have given.
1029:
1030: Case is normally significant in completion, because it is
1031: significant in most of the names that you can complete (buffer names,
1032: file names and command names). Thus, `fo' will not complete to `Foo'.
1033: When you are completing a name in which case does not matter, case may
1034: be ignored for completion's sake if the program said to do so.
1035:
1036: Completion Example
1037: ------------------
1038:
1039: A concrete example may help here. If you type `Meta-x au TAB', the
1040: TAB looks for alternatives (in this case, command names) that start
1041: with `au'. There are only two: `auto-fill-mode' and `auto-save-mode'.
1042: These are the same as far as `auto-', so the `au' in the minibuffer
1043: changes to `auto-'.
1044:
1045: If you type TAB again immediately, there are multiple possibilities
1046: for the very next character--it could be `s' or `f'--so no more
1047: characters are added; but a list of all possible completions is
1048: displayed in another window.
1049:
1050: If you go on to type `f TAB', this TAB sees `auto-f'. The only
1051: command name starting this way is `auto-fill-mode', so completion
1052: inserts the rest of that. You now have `auto-fill-mode' in the
1053: minibuffer after typing just `au TAB f TAB'. Note that TAB has this
1054: effect because in the minibuffer it is bound to the function
1055: `minibuffer-complete' when completion is supposed to be done.
1056:
1057: Completion Commands
1058: -------------------
1059:
1060: Here is a list of all the completion commands, defined in the
1061: minibuffer when completion is available.
1062:
1063: `TAB'
1064: Complete the text in the minibuffer as much as possible
1065: (`minibuffer-complete').
1066:
1067: `SPC'
1068: Complete the text in the minibuffer but don't add or fill out more
1069: than one word (`minibuffer-complete-word').
1070:
1071: `RET'
1072: Submit the text in the minibuffer as the argument, possibly
1073: completing first as described below
1074: (`minibuffer-complete-and-exit').
1075:
1076: `?'
1077: Print a list of all possible completions of the text in the
1078: minibuffer (`minibuffer-list-completions').
1079:
1080: SPC completes much like TAB, but never goes beyond the next hyphen
1081: or space. If you have `auto-f' in the minibuffer and type SPC, it
1082: finds that the completion is `auto-fill-mode', but it stops completing
1083: after `fill-'. This gives `auto-fill-'. Another SPC at this point
1084: completes all the way to `auto-fill-mode'. SPC in the minibuffer runs
1085: the function `minibuffer-complete-word' when completion is available.
1086:
1087: There are three different ways that RET can work in completing
1088: minibuffers, depending on how the argument will be used.
1089:
1090: * "Strict" completion is used when it is meaningless to give any
1091: argument except one of the known alternatives. For example, when
1092: `C-x k' reads the name of a buffer to kill, it is meaningless to
1093: give anything but the name of an existing buffer. In strict
1094: completion, RET refuses to exit if the text in the minibuffer does
1095: not complete to an exact match.
1096:
1097: * "Cautious" completion is similar to strict completion, except that
1098: RET exits only if the text was an exact match already, not needing
1099: completion. If the text is not an exact match, RET does not exit,
1100: but it does complete the text. If it completes to an exact match,
1101: a second RET will exit.
1102:
1103: Cautious completion is used for reading file names for files that
1104: must already exist.
1105:
1106: * "Permissive" completion is used when any string whatever is
1107: meaningful, and the list of completion alternatives is just a
1108: guide. For example, when `C-x C-f' reads the name of a file to
1109: visit, any file name is allowed, in case you want to create a
1110: file. In permissive completion, RET takes the text in the
1111: minibuffer exactly as given, without completing it.
1112:
1113: The completion commands display a list of all possible completions
1114: in a window whenever there is more than one possibility for the very
1115: next character. Also, typing `?' explicitly requests such a list. The
1116: list of completions counts as help text, so `C-M-v' typed in the
1117: minibuffer scrolls the list.
1118:
1119: When completion is done on file names, certain file names are usually
1120: ignored. The variable `completion-ignored-extensions' contains a list
1121: of strings; a file whose name ends in any of those strings is ignored
1122: as a possible completion. The standard value of this variable has
1123: several elements including `".o"', `".elc"', `".dvi"' and `"~"'. The
1124: effect is that, for example, `foo' can complete to `foo.c' even though
1125: `foo.o' exists as well. If the only possible completions are files
1126: that end in "ignored" strings, then they are not ignored.
1127:
1128: Normally, a completion command that finds the next character is
1129: undetermined automatically displays a list of all possible completions.
1130: If the variable `completion-auto-help' is set to `nil', this does not
1131: happen, and you must type `?' to display the possible completions.
1132:
1133:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.