![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-12 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-12 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: Init Examples, Next: Terminal Init, Prev: Init Syntax, Up: Init File
27:
28: Init File Examples
29: ------------------
30:
31: Here are some examples of doing certain commonly desired things with
32: Lisp expressions:
33:
34: * Make TAB in C mode just insert a tab if point is in the middle of a
35: line.
36:
37: (setq c-tab-always-indent nil)
38:
39: Here we have a variable whose value is normally `t' for `true' and
40: the alternative is `nil' for `false'.
41:
42: * Make searches case sensitive by default (in all buffers that do not
43: override this).
44:
45: (setq-default case-fold-search nil)
46:
47: This sets the default value, which is effective in all buffers
48: that do not have local values for the variable. Setting
49: `case-fold-search' with `setq' affects only the current buffer's
50: local value, which is not what you probably want to do in an init
51: file.
52:
53: * Make Text mode the default mode for new buffers.
54:
55: (setq default-major-mode 'text-mode)
56:
57: Note that `text-mode' is used because it is the command for
58: entering the mode we want. A single-quote is written before it to
59: make a symbol constant; otherwise, `text-mode' would be treated as
60: a variable name.
61:
62: * Turn on Auto Fill mode automatically in Text mode and related
63: modes.
64:
65: (setq text-mode-hook
66: '(lambda () (auto-fill-mode 1)))
67:
68: Here we have a variable whose value should be a Lisp function. The
69: function we supply is a list starting with `lambda', and a single
70: quote is written in front of it to make it (for the purpose of this
71: `setq') a list constant rather than an expression. Lisp functions
72: are not explained here, but for mode hooks it is enough to know
73: that `(auto-fill-mode 1)' is an expression that will be executed
74: when Text mode is entered, and you could replace it with any other
75: expression that you like, or with several expressions in a row.
76:
77: (setq text-mode-hook 'turn-on-auto-fill)
78:
79: This is another way to accomplish the same result.
80: `turn-on-auto-fill' is a symbol whose function definition is
81: `(lambda () (auto-fill-mode 1))'.
82:
83: * Load the installed Lisp library named `foo' (actually a file
84: `foo.elc' or `foo.el' in a standard Emacs directory).
85:
86: (load "foo")
87:
88: When the argument to `load' is a relative pathname, not starting
89: with `/' or `~', `load' searches the directories in `load-path'
90: (*note Loading::.).
91:
92: * Load the compiled Lisp file `foo.elc' from your home directory.
93:
94: (load "~/foo.elc")
95:
96: Here an absolute file name is used, so no searching is done.
97:
98: * Rebind the key `C-x l' to run the function `make-symbolic-link'.
99:
100: (global-set-key "\C-xl" 'make-symbolic-link)
101:
102: or
103:
104: (define-key global-map "\C-xl" 'make-symbolic-link)
105:
106: Note once again the single-quote used to refer to the symbol
107: `make-symbolic-link' instead of its value as a variable.
108:
109: * Do the same thing for C mode only.
110:
111: (define-key c-mode-map "\C-xl" 'make-symbolic-link)
112:
113: * Redefine all keys which now run `next-line' in Fundamental mode so
114: that they run `forward-line' instead.
115:
116: (substitute-key-definition 'next-line 'forward-line
117: global-map)
118:
119: * Make `C-x C-v' undefined.
120:
121: (global-unset-key "\C-x\C-v")
122:
123: One reason to undefine a key is so that you can make it a prefix.
124: Simply defining `C-x C-v ANYTHING' would make `C-x C-v' a prefix,
125: but `C-x C-v' must be freed of any non-prefix definition first.
126:
127: * Make `$' have the syntax of punctuation in Text mode. Note the use
128: of a character constant for `$'.
129:
130: (modify-syntax-entry ?\$ "." text-mode-syntax-table)
131:
132: * Enable the use of the command `eval-expression' without
133: confirmation.
134:
135: (put 'eval-expression 'disabled nil)
136:
137:
138: File: emacs, Node: Terminal Init, Next: Debugging Init, Prev: Init Examples, Up: Init File
139:
140: Terminal-specific Initialization
141: --------------------------------
142:
143: Each terminal type can have a Lisp library to be loaded into Emacs
144: when it is run on that type of terminal. For a terminal type named
145: TERMTYPE, the library is called `term/TERMTYPE' and it is found by
146: searching the directories `load-path' as usual and trying the suffixes
147: `.elc' and `.el'. Normally it appears in the subdirectory `term' of
148: the directory where most Emacs libraries are kept.
149:
150: The usual purpose of the terminal-specific library is to define the
151: escape sequences used by the terminal's function keys using the library
152: `keypad.el'. See the file `term/vt100.el' for an example of how this
153: is done.
154:
155: When the terminal type contains a hyphen, only the part of the name
156: before the first hyphen is significant in choosing the library name.
157: Thus, terminal types `aaa-48' and `aaa-30-rv' both use the library
158: `term/aaa'. The code in the library can use `(getenv "TERM")' to find
159: the full terminal type name.
160:
161: The library's name is constructed by concatenating the value of the
162: variable `term-file-prefix' and the terminal type. Your `.emacs' file
163: can prevent the loading of the terminal-specific library by setting
164: `term-file-prefix' to `nil'.
165:
166: The value of the variable `term-setup-hook', if not `nil', is called
167: as a function of no arguments at the end of Emacs initialization, after
168: both your `.emacs' file and any terminal-specific library have been
169: read in. You can set the value in the `.emacs' file to override part
170: of any of the terminal-specific libraries and to define initializations
171: for terminals that do not have a library.
172:
173:
174: File: emacs, Node: Debugging Init, Prev: Terminal Init, Up: Init File
175:
176: Debugging Your `.emacs' File
177: ----------------------------
178:
179: Ordinarily, Emacs traps errors that occur while reading `.emacs'.
180: This is convenient, most of the time, because it means you can still get
181: an Emacs in which you can edit. But it causes inconvenience because
182: there is no way to enter the debugger if there is an error.
183:
184: But you can run the `.emacs' file explicitly in an Emacs that is
185: already set up, and debug errors at that time.
186:
187: M-x set-variable
188: debug-on-error
189: t
190: M-x load-file
191: ~/.emacs
192:
193: In Emacs 19, use the `-debug-init' option if you want errors in
194: `.emacs' to enter the debugger.
195:
196:
197: File: emacs, Node: Quitting, Next: Lossage, Prev: Customization, Up: Top
198:
199: Quitting and Aborting
200: =====================
201:
202: `C-g'
203: Quit. Cancel running or partially typed command.
204:
205: `C-]'
206: Abort innermost recursive editing level and cancel the command
207: which invoked it (`abort-recursive-edit').
208:
209: `M-x top-level'
210: Abort all recursive editing levels that are currently executing.
211:
212: `C-x u'
213: Cancel an already-executed command, usually (`undo').
214:
215: There are two ways of cancelling commands which are not finished
216: executing: "quitting" with `C-g', and "aborting" with `C-]' or `M-x
217: top-level'. Quitting is cancelling a partially typed command or one
218: which is already running. Aborting is getting out of a recursive
219: editing level and cancelling the command that invoked the recursive
220: edit.
221:
222: Quitting with `C-g' is used for getting rid of a partially typed
223: command, or a numeric argument that you don't want. It also stops a
224: running command in the middle in a relatively safe way, so you can use
225: it if you accidentally give a command which takes a long time. In
226: particular, it is safe to quit out of killing; either your text will
227: ALL still be there, or it will ALL be in the kill ring (or maybe both).
228: Quitting an incremental search does special things documented under
229: searching; in general, it may take two successive `C-g' characters to
230: get out of a search. `C-g' works by setting the variable `quit-flag' to
231: `t' the instant `C-g' is typed; Emacs Lisp checks this variable
232: frequently and quits if it is non-`nil'. `C-g' is only actually
233: executed as a command if it is typed while Emacs is waiting for input.
234:
235: If you quit twice in a row before the first `C-g' is recognized, you
236: activate the "emergency escape" feature and return to the shell. *Note
237: Emergency Escape::.
238:
239: Aborting with `C-]' (`abort-recursive-edit') is used to get out of a
240: recursive editing level and cancel the command which invoked it.
241: Quitting with `C-g' does not do this, and could not do this, because it
242: is used to cancel a partially typed command within the recursive
243: editing level. Both operations are useful. For example, if you are in
244: the Emacs debugger (*note Lisp Debug::.) and have typed `C-u 8' to
245: enter a numeric argument, you can cancel that argument with `C-g' and
246: remain in the debugger.
247:
248: The command `M-x top-level' is equivalent to "enough" `C-]' commands
249: to get you out of all the levels of recursive edits that you are in.
250: `C-]' gets you out one level at a time, but `M-x top-level' goes out
251: all levels at once. Both `C-]' and `M-x top-level' are like all other
252: commands, and unlike `C-g', in that they are effective only when Emacs
253: is ready for a command. `C-]' is an ordinary key and has its meaning
254: only because of its binding in the keymap. *Note Recursive Edit::.
255:
256: `C-x u' (`undo') is not strictly speaking a way of cancelling a
257: command, but you can think of it as cancelling a command already
258: finished executing. *Note Undo::.
259:
260:
261: File: emacs, Node: Lossage, Next: Bugs, Prev: Quitting, Up: Top
262:
263: Dealing with Emacs Trouble
264: ==========================
265:
266: This section describes various conditions in which Emacs fails to
267: work, and how to recognize them and correct them.
268:
269: * Menu:
270:
271: * Stuck Recursive:: `[...]' in mode line around the parentheses
272: * Screen Garbled:: Garbage on the screen
273: * Text Garbled:: Garbage in the text
274: * Unasked-for Search:: Spontaneous entry to incremental search
275: * Emergency Escape:: Emergency escape--
276: What to do if Emacs stops responding
277: * Total Frustration:: When you are at your wits' end.
278:
279:
280: File: emacs, Node: Stuck Recursive, Next: Screen Garbled, Prev: Lossage, Up: Lossage
281:
282: Recursive Editing Levels
283: ------------------------
284:
285: Recursive editing levels are important and useful features of Emacs,
286: but they can seem like malfunctions to the user who does not understand
287: them.
288:
289: If the mode line has square brackets `[...]' around the parentheses
290: that contain the names of the major and minor modes, you have entered a
291: recursive editing level. If you did not do this on purpose, or if you
292: don't understand what that means, you should just get out of the
293: recursive editing level. To do so, type `M-x top-level'. This is
294: called getting back to top level. *Note Recursive Edit::.
295:
296:
297: File: emacs, Node: Screen Garbled, Next: Text Garbled, Prev: Stuck Recursive, Up: Lossage
298:
299: Garbage on the Screen
300: ---------------------
301:
302: If the data on the screen looks wrong, the first thing to do is see
303: whether the text is really wrong. Type `C-l', to redisplay the entire
304: screen. If it appears correct after this, the problem was entirely in
305: the previous screen update.
306:
307: Display updating problems often result from an incorrect termcap
308: entry for the terminal you are using. The file `etc/TERMS' in the Emacs
309: distribution gives the fixes for known problems of this sort. `INSTALL'
310: contains general advice for these problems in one of its sections.
311: Very likely there is simply insufficient padding for certain display
312: operations. To investigate the possibility that you have this sort of
313: problem, try Emacs on another terminal made by a different manufacturer.
314: If problems happen frequently on one kind of terminal but not another
315: kind, it is likely to be a bad termcap entry, though it could also be
316: due to a bug in Emacs that appears for terminals that have or that lack
317: specific features.
318:
319:
320: File: emacs, Node: Text Garbled, Next: Unasked-for Search, Prev: Screen Garbled, Up: Lossage
321:
322: Garbage in the Text
323: -------------------
324:
325: If `C-l' shows that the text is wrong, try undoing the changes to it
326: using `C-x u' until it gets back to a state you consider correct. Also
327: try `C-h l' to find out what command you typed to produce the observed
328: results.
329:
330: If a large portion of text appears to be missing at the beginning or
331: end of the buffer, check for the word `Narrow' in the mode line. If it
332: appears, the text is still present, but marked off-limits. To make it
333: visible again, type `C-x w'. *Note Narrowing::.
334:
335:
336: File: emacs, Node: Unasked-for Search, Next: Emergency Escape, Prev: Text Garbled, Up: Lossage
337:
338: Spontaneous Entry to Incremental Search
339: ---------------------------------------
340:
341: If Emacs spontaneously displays `I-search:' at the bottom of the
342: screen, it means that the terminal is sending `C-s' and `C-q' according
343: to the poorly designed `xon/xoff' "flow control" protocol. You should
344: try to prevent this by putting the terminal in a mode where it will not
345: use flow control or giving it enough padding that it will never send a
346: `C-s'. If that cannot be done, you must tell Emacs to expect flow
347: control to be used, until you can get a properly designed terminal.
348:
349: Information on how to do these things can be found in the file
350: `INSTALL' in the Emacs distribution.
351:
352:
353: File: emacs, Node: Emergency Escape, Next: Total Frustration, Prev: Unasked-for Search, Up: Lossage
354:
355: Emergency Escape
356: ----------------
357:
358: Because at times there have been bugs causing Emacs to loop without
359: checking `quit-flag', a special feature causes Emacs to be suspended
360: immediately if you type a second `C-g' while the flag is already set,
361: so you can always get out of GNU Emacs. Normally Emacs recognizes and
362: clears `quit-flag' (and quits!) quickly enough to prevent this from
363: happening.
364:
365: When you resume Emacs after a suspension caused by multiple `C-g', it
366: asks two questions before going back to what it had been doing:
367:
368: Auto-save? (y or n)
369: Abort (and dump core)? (y or n)
370:
371: Answer each one with `y' or `n' followed by RET.
372:
373: Saying `y' to `Auto-save?' causes immediate auto-saving of all
374: modified buffers in which auto-saving is enabled.
375:
376: Saying `y' to `Abort (and dump core)?' causes an illegal instruction
377: to be executed, dumping core. This is to enable a wizard to figure out
378: why Emacs was failing to quit in the first place. Execution does not
379: continue after a core dump. If you answer `n', execution does
380: continue. With luck, GNU Emacs will ultimately check `quit-flag' and
381: quit normally. If not, and you type another `C-g', it is suspended
382: again.
383:
384: If Emacs is not really hung, just slow, you may invoke the double
385: `C-g' feature without really meaning to. Then just resume and answer
386: `n' to both questions, and you will arrive at your former state.
387: Presumably the quit you requested will happen soon.
388:
389: The double-`C-g' feature may be turned off when Emacs is running
390: under a window system, since the window system always enables you to
391: kill Emacs or to create another window and run another program.
392:
393:
394: File: emacs, Node: Total Frustration, Prev: Emergency Escape, Up: Lossage
395:
396: Help for Total Frustration
397: --------------------------
398:
399: If using Emacs (or something else) becomes terribly frustrating and
400: none of the techniques described above solve the problem, Emacs can
401: still help you.
402:
403: First, if the Emacs you are using is not responding to commands, type
404: `C-g C-g' to get out of it and then start a new one.
405:
406: Second, type `M-x doctor RET'.
407:
408: The doctor will make you feel better. Each time you say something to
409: the doctor, you must end it by typing RET RET. This lets the doctor
410: know you are finished.
411:
412:
413: File: emacs, Node: Bugs, Next: Version 19, Prev: Lossage, Up: Top
414:
415: Reporting Bugs
416: ==============
417:
418: Sometimes you will encounter a bug in Emacs. Although we cannot
419: promise we can or will fix the bug, and we might not even agree that it
420: is a bug, we want to hear about bugs you encounter in case we do want
421: to fix them.
422:
423: To make it possible for us to fix a bug, you must report it. In
424: order to do so effectively, you must know when and how to do it.
425:
426: When Is There a Bug
427: -------------------
428:
429: If Emacs executes an illegal instruction, or dies with an operating
430: system error message that indicates a problem in the program (as
431: opposed to something like "disk full"), then it is certainly a bug.
432:
433: If Emacs updates the display in a way that does not correspond to
434: what is in the buffer, then it is certainly a bug. If a command seems
435: to do the wrong thing but the problem corrects itself if you type
436: `C-l', it is a case of incorrect display updating.
437:
438: Taking forever to complete a command can be a bug, but you must make
439: certain that it was really Emacs's fault. Some commands simply take a
440: long time. Type `C-g' and then `C-h l' to see whether the input Emacs
441: received was what you intended to type; if the input was such that you
442: KNOW it should have been processed quickly, report a bug. If you don't
443: know whether the command should take a long time, find out by looking
444: in the manual or by asking for assistance.
445:
446: If a command you are familiar with causes an Emacs error message in a
447: case where its usual definition ought to be reasonable, it is probably a
448: bug.
449:
450: If a command does the wrong thing, that is a bug. But be sure you
451: know for certain what it ought to have done. If you aren't familiar
452: with the command, or don't know for certain how the command is supposed
453: to work, then it might actually be working right. Rather than jumping
454: to conclusions, show the problem to someone who knows for certain.
455:
456: Finally, a command's intended definition may not be best for editing
457: with. This is a very important sort of problem, but it is also a
458: matter of judgment. Also, it is easy to come to such a conclusion out
459: of ignorance of some of the existing features. It is probably best not
460: to complain about such a problem until you have checked the
461: documentation in the usual ways, feel confident that you understand it,
462: and know for certain that what you want is not available. If you are
463: not sure what the command is supposed to do after a careful reading of
464: the manual, check the index and glossary for any terms that may be
465: unclear. If you still do not understand, this indicates a bug in the
466: manual. The manual's job is to make everything clear. It is just as
467: important to report documentation bugs as program bugs.
468:
469: If the on-line documentation string of a function or variable
470: disagrees with the manual, one of them must be wrong, so report the bug.
471:
472: How to Report a Bug
473: -------------------
474:
475: When you decide that there is a bug, it is important to report it
476: and to report it in a way which is useful. What is most useful is an
477: exact description of what commands you type, starting with the shell
478: command to run Emacs, until the problem happens. Always include the
479: version number of Emacs that you are using; type `M-x emacs-version' to
480: print this.
481:
482: The most important principle in reporting a bug is to report FACTS,
483: not hypotheses or categorizations. It is always easier to report the
484: facts, but people seem to prefer to strain to posit explanations and
485: report them instead. If the explanations are based on guesses about
486: how Emacs is implemented, they will be useless; we will have to try to
487: figure out what the facts must have been to lead to such speculations.
488: Sometimes this is impossible. But in any case, it is unnecessary work
489: for us.
490:
491: For example, suppose that you type `C-x C-f /glorp/baz.ugh RET',
492: visiting a file which (you know) happens to be rather large, and Emacs
493: prints out `I feel pretty today'. The best way to report the bug is
494: with a sentence like the preceding one, because it gives all the facts
495: and nothing but the facts.
496:
497: Do not assume that the problem is due to the size of the file and
498: say, "When I visit a large file, Emacs prints out `I feel pretty
499: today'." This is what we mean by "guessing explanations". The problem
500: is just as likely to be due to the fact that there is a `z' in the file
501: name. If this is so, then when we got your report, we would try out
502: the problem with some "large file", probably with no `z' in its name,
503: and not find anything wrong. There is no way in the world that we
504: could guess that we should try visiting a file with a `z' in its name.
505:
506: Alternatively, the problem might be due to the fact that the file
507: starts with exactly 25 spaces. For this reason, you should make sure
508: that you inform us of the exact contents of any file that is needed to
509: reproduce the bug. What if the problem only occurs when you have typed
510: the `C-x C-a' command previously? This is why we ask you to give the
511: exact sequence of characters you typed since starting to use Emacs.
512:
513: You should not even say "visit a file" instead of `C-x C-f' unless
514: you know that it makes no difference which visiting command is used.
515: Similarly, rather than saying "if I have three characters on the line,"
516: say "after I type `RET A B C' RET C-p," if that is the way you entered
517: the text.
518:
519: If you are not in Fundamental mode when the problem occurs, you
520: should say what mode you are in.
521:
522: If the manifestation of the bug is an Emacs error message, it is
523: important to report not just the text of the error message but a
524: backtrace showing how the Lisp program in Emacs arrived at the error.
525: To make the backtrace, you must execute the Lisp expression `(setq
526: debug-on-error t)' before the error happens (that is to say, you must
527: execute that expression and then make the bug happen). This causes the
528: Lisp debugger to run (*note Lisp Debug::.). The debugger's backtrace
529: can be copied as text into the bug report. This use of the debugger is
530: possible only if you know how to make the bug happen again. Do note
531: the error message the first time the bug happens, so if you can't make
532: it happen again, you can report at least that.
533:
534: Check whether any programs you have loaded into the Lisp world,
535: including your `.emacs' file, set any variables that may affect the
536: functioning of Emacs. Also, see whether the problem happens in a
537: freshly started Emacs without loading your `.emacs' file (start Emacs
538: with the `-q' switch to prevent loading the init file.) If the problem
539: does NOT occur then, it is essential that we know the contents of any
540: programs that you must load into the Lisp world in order to cause the
541: problem to occur.
542:
543: If the problem does depend on an init file or other Lisp programs
544: that are not part of the standard Emacs system, then you should make
545: sure it is not a bug in those programs by complaining to their
546: maintainers first. After they verify that they are using Emacs in a way
547: that is supposed to work, they should report the bug.
548:
549: If you can tell us a way to cause the problem without visiting any
550: files, please do so. This makes it much easier to debug. If you do
551: need files, make sure you arrange for us to see their exact contents.
552: For example, it can often matter whether there are spaces at the ends
553: of lines, or a newline after the last line in the buffer (nothing ought
554: to care whether the last line is terminated, but tell that to the bugs).
555:
556: The easy way to record the input to Emacs precisely is to write a
557: dribble file; execute the Lisp expression
558:
559: (open-dribble-file "~/dribble")
560:
561: using `Meta-ESC' or from the `*scratch*' buffer just after starting
562: Emacs. From then on, all Emacs input will be written in the specified
563: dribble file until the Emacs process is killed.
564:
565: For possible display bugs, it is important to report the terminal
566: type (the value of environment variable `TERM'), the complete termcap
567: entry for the terminal from `/etc/termcap' (since that file is not
568: identical on all machines), and the output that Emacs actually sent to
569: the terminal. The way to collect this output is to execute the Lisp
570: expression
571:
572: (open-termscript "~/termscript")
573:
574: using `Meta-ESC' or from the `*scratch*' buffer just after starting
575: Emacs. From then on, all output from Emacs to the terminal will be
576: written in the specified termscript file as well, until the Emacs
577: process is killed. If the problem happens when Emacs starts up, put
578: this expression into your `.emacs' file so that the termscript file will
579: be open when Emacs displays the screen for the first time. Be warned:
580: it is often difficult, and sometimes impossible, to fix a
581: terminal-dependent bug without access to a terminal of the type that
582: stimulates the bug.
583:
584: The address for reporting bugs is
585:
586: GNU Emacs Bugs
587: Free Software Foundation
588: 675 Mass Ave
589: Cambridge, MA 02139
590:
591: or send email either to `[email protected]' (Internet) or
592: to `uunet!prep.ai.mit.edu!bug-gnu-emacs' (Usenet).
593:
594: Once again, we do not promise to fix the bug; but if the bug is
595: serious, or ugly, or easy to fix, chances are we will want to.
596:
597:
598: File: emacs, Node: Version 19, Next: Manifesto, Prev: Bugs, Up: Top
599:
600: Version 19 Antenews
601: *******************
602:
603: This chapter prematurely describes new features of Emacs 19, in
604: anticipation of its release. We have included this so that the version
605: 18 manuals don't become obsolete as soon as Emacs 19 comes out. This
606: list mentions only features that would belong in `The GNU Emacs
607: Manual'; changes relevant to Emacs Lisp programming will be documented
608: in the next revision of `The GNU Emacs Lisp Manual'.
609:
610: * Menu:
611:
612: * Basic Changes:: Changes every user must know.
613: * New Facilities:: Changes every user will want to know.
614: * Binding Changes:: Ordinary commands that have been moved. Important!.
615: * Changed Commands:: Ordinary commands that have new features. Important!
616: * M-x Changes:: Changes in commands you run with `M-x'. Important!
617: * New Commands:: Commands that have been added
618: that we expect many users to want to use.
619: * Search Changes:: Changes in incremental search. Some are important.
620:
621: The rest of the changes you can pretty much ignore unless you are interested.
622:
623: * Filling Changes:: Changes in fill commands.
624: * TeX Mode Changes:: Changes in the commands for editing TeX files
625: and running TeX.
626: * Shell Changes:: Major changes in all the modes that run subprograms.
627: * Spell Changes:: These commands now use ispell instead of spell.
628: * Tags Changes:: Changes in Tags facility.
629: * Mail Changes:: Changes in both Sendmail mode and Rmail mode.
630: * Info Changes:: New commands in Info.
631: * Dired Changes:: Powerful new features in Dired.
632: * GNUS:: An alternative news reader.
633: * Calendar/Diary:: The calendar feature now lets you move to different
634: dates and convert to and from other calendars.
635: You can also display related entries from your diary
636: file.
637: * Version Control:: A convenient interface to RCS or SCCS.
638: * Emerge:: A new feature for merging files interactively.
639: * Debuggers:: Running debuggers (GDB, DBX, SDB) under Emacs.
640: * Other New Modes:: Miscellaneous new and changed major modes.
641: * Key Sequence Changes:: You can now bind key sequences that include function
642: keys and mouse clicks.
643: * Hook Changes:: Hook variables have been renamed more systematically.
644:
645:
646: File: emacs, Node: Basic Changes, Next: New Facilities, Up: Version 19
647:
648: Basic Changes
649: =============
650:
651: We have made changes to help Emacs use fewer resources and make it
652: less likely to become irreparably hung. While these changes don't
653: alter the commands of Emacs, they are important enough to be worth
654: mentioning.
655:
656: You can quit with `C-g' while Emacs is waiting to read or write a
657: file--provided the operating system will allow you to interrupt the
658: system call that is hung. (Unfortunately, most NFS implementations
659: won't allow interruption.)
660:
661: When you kill buffers, Emacs now returns memory to the operating
662: system, thus reducing the size of the Emacs process. The space that
663: you free up by killing buffers can now be reused for other buffers no
664: matter what their sizes, or reused by other processes if Emacs doesn't
665: need it.
666:
667: Multiple X Windows
668: ------------------
669:
670: When using X windows, you can now create more than one window at the
671: X level. Each X window displays a "frame" which can contain one or
672: several Emacs windows. Each frame has its own echo area and normally
673: its own minibuffer. (To avoid confusion, we reserve the word "window"
674: for the subdivisions that Emacs implements, and never use it to refer
675: to a frame.) The easiest way to create additional frames is with the
676: `C-x 5' prefix character (*note New Everyday Commands: New Commands.).
677:
678: Emacs windows can now have scroll bars; use the `scroll-bar-mode'
679: command to turn scroll bars on or off. With no argument, it toggles the
680: use of scroll bars. With an argument, it turns use of scroll bars on if
681: and only if the argument is positive. This command applies to all
682: frames, including frames yet to be created. (You can control scroll
683: bars on a frame by frame basis by writing a Lisp program.)
684:
685: Undo Improvements
686: -----------------
687:
688: Undoing a deletion now puts the cursor position where it was just
689: before the deletion.
690:
691: Auto Save Improvements
692: ----------------------
693:
694: Emacs now does garbage collection and auto saving while it is waiting
695: for input, which often avoids the need to do these things while you are
696: typing. The variable `auto-save-timeout' says how many seconds Emacs
697: should wait, after you stop typing, before it does an auto save and
698: perhaps also a garbage collection. (The actual time period varies also
699: according to the size of the buffer--longer for longer buffers, since
700: auto saving itself is slower for long buffers.) This way, Emacs does
701: not interrupt or delay your typing.
702:
703: In Emacs 18, when auto saving detects that a buffer has shrunk
704: greatly, it refrains from auto saving that buffer and displays a
705: warning. In version 19, it also turns off Auto Save mode in that
706: buffer, so that you won't get the same warning repeatedly. If you
707: reenable Auto Save mode in that buffer, Emacs will start saving it
708: again despite the shrinkage.
709:
710: In Emacs 19, `revert-buffer' no longer offers to revert from the
711: latest auto-save file. That option hasn't been very useful since the
712: change to keep more undo information.
713:
714: The command `recover-file' no longer turns off Auto Save mode.
715:
716: File Local Variables
717: --------------------
718:
719: The user option for controlling whether files can set local
720: variables is called `enable-local-variables' in Emacs 19, rather than
721: `inhibit-local-variables'. A value of `t' means local-variables lists
722: are obeyed; `nil' means they are ignored; anything else means query the
723: user.
724:
725:
726: File: emacs, Node: New Facilities, Next: Binding Changes, Prev: Basic Changes, Up: Version 19
727:
728: New Basic Facilities
729: ====================
730:
731: You can now get back recent minibuffer inputs conveniently. While in
732: the minibuffer, type `M-p' (`previous-history-element') to fetch the
733: next earlier minibuffer input, and use `M-n' (`next-history-element')
734: to fetch the next later input.
735:
736: There are also commands to search forward or backward through the
737: history. As of this writing, they search for history elements that
738: match a regular expression that you specify with the minibuffer. `M-r'
739: (`previous-matching-history-element') searches older elements in the
740: history, while `M-s' (`next-matching-history-element') searches newer
741: elements. By special dispensation, these commands can always use the
742: minibuffer to read their arguments even though you are already in the
743: minibuffer when you issue them.
744:
745: We may have changed the precise way these commands work by the time
746: you use Emacs 19. Perhaps they will search for a match for the string
747: given so far in the minibuffer; perhaps they will search for a literal
748: match rather than a regular expression match; perhaps they will only
749: accept matches at the beginning of a history element; perhaps they will
750: read the string to search for incrementally like `C-s'. We want to
751: choose an interface that is convenient, flexible and natural, and these
752: goals are somewhat contradictory. To find out what interface is
753: actually available, type `C-h f previous-matching-history-element'.
754:
755: The history feature is available for all uses of the minibuffer, but
756: there are separate history lists for different kinds of input. For
757: example, there is a list for file names, used by all the commands that
758: read file names. There is a list for arguments of commands like
759: `query-replace'. There are also very specific history lists, such as
760: the one that `compile' uses for compilation commands.
761:
762: Remote File Access
763: ------------------
764:
765: You can refer to files on other machines using a special file name
766: syntax:
767:
768: /HOST:FILENAME
769: /USER@HOST:FILENAME
770:
771: When you do this, Emacs uses the FTP program to read and write files
772: on the specified host. It logs in through FTP using your user name or
773: the name USER. It may ask you for a password from time to time; this
774: is used for logging in on HOST.
775:
776: Using Flow Control
777: ------------------
778:
779: There is now a convenient way to enable flow control when your
780: terminal or your connection won't work without it. Suppose you want to
781: do this on VT-100 and H19 terminals; put the following in your `.emacs'
782: file:
783:
784: (evade-flow-control-on "vt100" "h19")
785:
786: When flow control is enabled, you must type `C-\' to get the effect
787: of a `C-s', and type `C-^' to get the effect of a `C-q'.
788:
789: Controlling Backup File Names
790: -----------------------------
791:
792: The default setting of the Lisp variable `version-control' now comes
793: from the environment variable `VERSION_CONTROL'. Thus, you can select
794: a style of backup file naming for Emacs and other GNU utilities all
795: together.
796:
797:
798: File: emacs, Node: Binding Changes, Next: Changed Commands, Prev: New Facilities, Up: Version 19
799:
800: Changed Key Bindings
801: ====================
802:
803: `M-{'
804: This is the new key sequence for `backward-paragraph'. The old key
805: sequence for this, `M-[', is now undefined by default.
806:
807: The reason for this change is to avoid conflict with the sequences
808: that function keys send on most terminals.
809:
810: `M-}'
811: This is the new key sequence for `forward-paragraph'. The old key
812: sequence for this, `M-]', is now undefined by default.
813:
814: We changed this to go along with `M-{'.
815:
816: `C-x C-u'
817: `C-x C-l'
818: The two commands, `C-x C-u' (`upcase-region') and `C-x C-l'
819: (`downcase-region'), are now disabled by default; these keys seem
820: to be often hit by accident, and can be quite destructive if their
821: effects are not noticed immediately.
822:
823: `C-x 3'
824: `C-x 3' is now the key binding for `split-window-horizontally',
825: which splits a window into two side-by-side windows. This used to
826: be `C-x 5'.
827:
828: ``C-x 4 C-o''
829: This key now runs `display-buffer', which displays a specified
830: buffer in another window without selecting it.
831:
832: `M-g'
833: `M-g' is now undefined. It used to run the command `fill-region'.
834: This command used to be run more often by mistake than on purpose.
835:
836: `C-x a'
837: `C-x n'
838: `C-x r'
839: Three new prefix keys have been created to make many of the `C-x'
840: commands more systematic: `C-x a', `C-x n' and `C-x r'. `C-x a' is
841: used for abbreviation commands, `C-x n' for commands pertaining to
842: narrowing, and `C-x r' for register and rectangle commands. These
843: are the new bindings, in detail:
844:
845: `C-x a l'
846: `add-mode-abbrev' (previously `C-x C-a').
847:
848: `C-x a g'
849: `add-global-abbrev' (previously `C-x +').
850:
851: `C-x a i g'
852: `inverse-add-mode-abbrev' (previously `C-x C-h').
853:
854: `C-x a i l'
855: `inverse-add-global-abbrev' (previously `C-x -').
856:
857: `C-x a e'
858: `expand-abbrev' (previously `C-x '').
859:
860: `C-x n n'
861: `narrow-to-region' (previously `C-x n').
862:
863: `C-x n p'
864: `narrow-to-page' (previously `C-x p').
865:
866: `C-x n w'
867: `widen' (previously `C-x w').
868:
869: `C-x r C-SPC'
870: `point-to-register' (previously `C-x /').
871:
872: `C-x r SPC'
873: Also `point-to-register' (previously `C-x /').
874:
875: `C-x r j'
876: `jump-to-register' (previously `C-x j').
877:
878: `C-x r s'
879: `copy-to-register' (previously `C-x x').
880:
881: `C-x r i'
882: `insert-register' (previously `C-x g').
883:
884: `C-x r r'
885: `copy-rectangle-to-register' (previously `C-x r').
886:
887: `C-x r k'
888: `kill-rectangle' (no previous key binding).
889:
890: `C-x r y'
891: `yank-rectangle' (no previous key binding).
892:
893: `C-x r o'
894: `open-rectangle' (no previous key binding).
895:
896: `C-x r f'
897: `frame-configuration-to-register' (a new command) saves the
898: state of all windows in all frames. Use `C-x r j' to restore
899: the configuration.
900:
901: `C-x r w'
902: `window-configuration-to-register' (a new command) saves the
903: state of all windows in the selected frame. Use `C-x r j' to
904: restore the configuration.
905:
906: The old key bindings `C-x /', `C-x j', `C-x x' and `C-x g' have
907: not yet been removed. The other old key bindings listed have been
908: removed. The old key binding `C-x a', which was
909: `append-to-buffer', was removed to make way for a prefix key; now
910: `append-to-buffer' has no keybinding.
911:
912: `C-x v'
913: `C-x v' is a new prefix character, used for version control
914: commands. *Note Version Control::.
915:
916:
917: File: emacs, Node: Changed Commands, Next: M-x Changes, Prev: Binding Changes, Up: Version 19
918:
919: Changed Everyday Commands
920: =========================
921:
922: `C-o'
923: When you have a fill prefix, the command `C-o' inserts the prefix
924: on the newly created line.
925:
926: `M-^'
927: When you have a fill prefix, the command `M-^' deletes the prefix
928: (if it occurs) after the newline that it deletes.
929:
930: `M-z'
931: The `M-z' command (`zap-to-char') now kills through the target
932: character. In version 18, it killed up to but not including the
933: target character.
934:
935: `M-!'
936: The command `M-!' (`shell-command') now runs the specified shell
937: command asynchronously if it ends in `&', just as the shell does.
938:
939: `C-x 2'
940: The `C-x 2' command (`split-window-vertically') now tries to avoid
941: scrolling by putting point in whichever window happens to contain
942: the screen line the cursor is already on. If you don't like this,
943: you can turn it off by setting `split-window-keep-point' to `nil'.
944:
945: `C-x s'
946: The `C-x s' command (`save-some-buffers') now gives you more
947: options when it asks whether to save a particular buffer. The
948: options are analogous to those of `query-replace'. Here they are:
949:
950: `y'
951: Save this buffer and ask about the rest of the buffers.
952:
953: `n'
954: Don't save this buffer, but ask about the rest of the buffers.
955:
956: `!'
957: Save this buffer and all the rest with no more questions.
958:
959: `ESC'
960: Terminate `save-some-buffers' without any more saving.
961:
962: `.'
963: Save only this buffer, then exit `save-some-buffers' without
964: even asking about other buffers.
965:
966: `C-r'
967: View the buffer that you are currently being asked about.
968: When you exit View mode, you get back to `save-some-buffers',
969: which asks the question again.
970:
971: `C-h'
972: Display a help message about these options.
973:
974: `C-x C-v'
975: This command (`find-alternate-file') now inserts the entire current
976: file name in the minibuffer. This is convenient if you made a
977: small mistake in typing it. Point goes after the last slash,
978: before the last file name component, so if you want to replace it
979: entirely, you can use `C-k' right away to delete it.
980:
981: `C-M-f'
982: Expression and list commands such as `C-M-f' now ignore parentheses
983: within comments in Lisp mode.
984:
985:
986: File: emacs, Node: M-x Changes, Next: New Commands, Prev: Changed Commands, Up: Version 19
987:
988: Changes in Common `M-x' Commands
989: ================================
990:
991: `M-x make-symbolic-link'
992: This command now does not expand its second argument. This lets
993: you make a link with a target that is a relative file name.
994:
995: `M-x add-change-log-entry'
996: `C-x 4 a'
997: These commands now automatically insert the name of the file and
998: often the name of the function that you changed. They also handle
999: grouping of entries.
1000:
1001: There is now a special major mode for editing `ChangeLog' files.
1002: It makes filling work conveniently. Each bunch of grouped entries
1003: is one paragraph, and each collection of entries from one person
1004: on one day is considered a page.
1005:
1006: `M-x compare-windows'
1007: With a prefix argument, `compare-windows' ignores changes in
1008: whitespace. If the variable `compare-ignore-case' is non-`nil',
1009: it ignores differences in case as well.
1010:
1011: `M-x view-buffer'
1012: `M-x view-file'
1013: The View commands (such as `M-x view-buffer' and `M-x view-file')
1014: no longer use recursive edits; instead, they switch temporarily to
1015: a different major mode (View mode) specifically designed for
1016: moving around through a buffer without editing it.
1017:
1018: `M-x manual-entry'
1019: `M-x manual-entry' now uses View mode for the buffer showing the
1020: man page.
1021:
1022: `M-x compile'
1023: You can repeat any previous `compile' conveniently using the
1024: minibuffer history commands, while in the minibuffer entering the
1025: compilation command.
1026:
1027: While a compilation is going on, the string `Compiling' appears in
1028: the mode line. When this string disappears, the compilation is
1029: finished.
1030:
1031: The buffer of compiler messages is in Compilation mode. This mode
1032: provides the keys SPC and DEL to scroll by screenfuls, and `M-n'
1033: and `M-p' to move to the next or previous error message. You can
1034: also use `M-{' and `M-}' to move up or down to an error message
1035: for a different source file. Use `C-c C-c' on any error message
1036: to find the corresponding source code.
1037:
1038: Emacs 19 has a more general parser for compiler messages. For
1039: example, it can understand messages from lint, and from certain C
1040: compilers whose error message format is unusual.
1041:
1042:
1043: File: emacs, Node: New Commands, Next: Search Changes, Prev: M-x Changes, Up: Version 19
1044:
1045: New Everyday Commands
1046: =====================
1047:
1048: `C-z'
1049: When you are using X windows, `C-z' (`iconify-frame') now
1050: iconifies the current frame.
1051:
1052: `C-M-l'
1053: The `C-M-l' command (`reposition-window') scrolls the current
1054: window heuristically in a way designed to get useful information
1055: onto the screen. For example, in a Lisp file, this command tries
1056: to get the entire current defun onto the screen if possible.
1057:
1058: `C-M-r'
1059: The `C-M-r' key now runs the command `isearch-backward-regexp',
1060: which does reverse incremental regexp search.
1061:
1062: `C-x 5'
1063: The prefix key `C-x 5' is analogous to `C-x 4', with parallel
1064: subcommands. The difference is that `C-x 5' commands create a new
1065: frame rather than just a new window.
1066:
1067: `C-x 5 C-f'
1068: `C-x 5 b'
1069: These new commands switch to a specified file or buffer in a new
1070: frame (when using X windows). The commands' names are
1071: `find-file-other-frame' and `switch-to-buffer-other-frame'.
1072:
1073: `C-x 5 m'
1074: Start outgoing mail in another frame (`mail-other-frame').
1075:
1076: `C-x 5 .'
1077: Find a tag in another frame (`find-tag-other-frame').
1078:
1079: `C-x 4 r'
1080: This is now `find-file-read-only-other-window'.
1081:
1082: arrow keys
1083: The arrow keys now have default bindings to move in the appropriate
1084: directions.
1085:
1086: `C-h C-f'
1087: `C-h C-k'
1088: These new help commands enter Info and display the node for a given
1089: Emacs function name or key sequence, respectively.
1090:
1091: `M-a'
1092: `M-e'
1093: In C mode, `M-a' and `M-e' now move by complete C statements
1094: (`c-beginning-of-statement' and `c-end-of-statement').
1095:
1096: `M-q'
1097: `M-q' in C mode now runs `c-fill-paragraph', which is designed for
1098: filling C comments. (We assume you don't want to fill the actual C
1099: code in a C program.)
1100:
1101: `M-x c-up-conditional'
1102: In C mode, `c-up-conditional' moves back to the containing
1103: preprocessor conditional, setting the mark where point was
1104: previously.
1105:
1106: A prefix argument acts as a repeat count. With a negative
1107: argument, this command moves forward to the end of the containing
1108: preprocessor conditional. When going backwards, `#elif' acts like
1109: `#else' followed by `#if'. When going forwards, `#elif' is
1110: ignored.
1111:
1112: `M-x comment-region'
1113: The `comment-region' command adds comment delimiters to the lines
1114: that start in the region, thus commenting them out. With a
1115: negative argument, it deletes comment delimiters from the lines in
1116: the region--this is the inverse of the effect of `comment-region'
1117: without an argument.
1118:
1119: With a positive argument, `comment-region' adds comment delimiters
1120: but duplicates the last character of the comment start sequence as
1121: many times as the argument specifies. This is a way of calling
1122: attention to the comment. In Lisp, you should use an argument of
1123: at least two, because the indentation convention for single
1124: semicolon comments does not leave them at the beginning of a line.
1125:
1126: `M-x super-apropos'
1127: This command is like `apropos' except that it searches for a
1128: regular expression instead of merely a substring.
1129:
1130: If you use a prefix argument (regardless of its value) with
1131: `apropos' or `super-apropos', they also search documentation
1132: strings for matches as well as symbol names. The prefix argument
1133: also controls looking up and printing the key bindings of all
1134: commands.
1135:
1136: `M-x diff'
1137: This new command compares two files, displaying the differences in
1138: an Emacs buffer. The options for the `diff' program come from the
1139: variable `diff-switches', whose value should be a string.
1140:
1141: The buffer of differences has Compilation mode as its major mode,
1142: so you can use `C-x `' to visit successive changed locations in
1143: the two source files, or you can move to a particular hunk of
1144: changes and type `C-c C-c' to move to the corresponding source.
1145: You can also use the other special commands of Compilation mode:
1146: SPC and DEL for scrolling, and `M-p' and `M-n' for cursor motion.
1147:
1148: `M-x diff-backup'
1149: The command `diff-backup' compares a specified file with its most
1150: recent backup. If you specify the name of a backup file,
1151: `diff-backup' compares it with the source file that it is a backup
1152: of.
1153:
1154:
1155: File: emacs, Node: Search Changes, Next: Filling Changes, Prev: New Commands, Up: Version 19
1156:
1157: Changes in Incremental Search
1158: =============================
1159:
1160: The most important change in incremental search is that RET now
1161: terminates a search, and ESC does not. The other changes are useful,
1162: but not vital to know about.
1163:
1164: * The character to terminate an incremental search is now RET. This
1165: is for compatibility with the way most other arguments are read.
1166:
1167: To search for a newline in an incremental search, type LFD (also
1168: known as `C-j').
1169:
1170: (This change is somewhat of an experiment; it might be taken back
1171: by the time Emacs 19 is really released.)
1172:
1173: * Incremental search now maintains a ring of previous search
1174: strings. Use `M-p' and `M-n' to move through the ring to pick a
1175: search string to reuse. These commands leave the selected search
1176: ring element in the minibuffer, where you can edit it. Type RET
1177: to finish editing and search for the chosen string.
1178:
1179: * When there is an upper-case letter in the search string, then the
1180: search is case sensitive.
1181:
1182: * Incremental search is now implemented as a major mode. When you
1183: type `C-s', it switches temporarily to a different keymap which
1184: defines each key to do what it ought to do for incremental search.
1185: This has next to no effect on the user-visible behavior of
1186: searching, but makes it easier to customize that behavior.
1187:
1188:
1189: File: emacs, Node: Filling Changes, Next: TeX Mode Changes, Prev: Search Changes, Up: Version 19
1190:
1191: Changes in Fill Commands
1192: ========================
1193:
1194: * `fill-individual-paragraphs' now has two modes. Its default mode
1195: is that any change in indentation starts a new paragraph. The
1196: alternate mode is that only separator lines separate paragraphs;
1197: this can handle paragraphs with extra indentation on the first
1198: line. To select the alternate mode, set
1199: `fill-individual-varying-indent' to a non-`nil' value.
1200:
1201: * Filling is now partially controlled by a new minor mode, Adaptive
1202: Fill mode. When this mode is enabled (and it is enabled by
1203: default), if you use `fill-region-as-paragraph' on an indented
1204: paragraph and you don't have a fill prefix, it uses the
1205: indentation of the second line of the paragraph as the fill prefix.
1206:
1207: Adaptive Fill mode doesn't have much effect on `M-q' in most major
1208: modes, because an indented line will probably count as a paragraph
1209: starter and thus each line of an indented paragraph will be
1210: considered a paragraph of its own.
1211:
1212: * `M-q' in C mode now runs `c-fill-paragraph', which is designed for
1213: filling C comments. (We assume you don't want to fill the actual C
1214: code in a C program.)
1215:
1216:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.