Commit | Line | Data |
---|---|---|
6bf7aab6 DL |
1 | @c This is part of the Emacs manual. |
2 | @c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc. | |
3 | @c See file emacs.texi for copying conditions. | |
4 | @iftex | |
5 | @chapter Dealing with Common Problems | |
6 | ||
7 | If you type an Emacs command you did not intend, the results are often | |
8 | mysterious. This chapter tells what you can do to cancel your mistake or | |
9 | recover from a mysterious situation. Emacs bugs and system crashes are | |
10 | also considered. | |
11 | @end iftex | |
12 | ||
13 | @node Quitting, Lossage, Customization, Top | |
14 | @section Quitting and Aborting | |
15 | @cindex quitting | |
16 | ||
17 | @table @kbd | |
18 | @item C-g | |
48d86efe | 19 | @itemx C-@key{BREAK}@r{ (MS-DOS only)} |
e4afa558 | 20 | Quit (@code{keyboard-quit}): cancel running or partially typed command. |
6bf7aab6 DL |
21 | @item C-] |
22 | Abort innermost recursive editing level and cancel the command which | |
23 | invoked it (@code{abort-recursive-edit}). | |
24 | @item @key{ESC} @key{ESC} @key{ESC} | |
25 | Either quit or abort, whichever makes sense (@code{keyboard-escape-quit}). | |
26 | @item M-x top-level | |
27 | Abort all recursive editing levels that are currently executing. | |
28 | @item C-x u | |
29 | Cancel a previously made change in the buffer contents (@code{undo}). | |
30 | @end table | |
31 | ||
32 | There are two ways of canceling commands which are not finished | |
33 | executing: @dfn{quitting} with @kbd{C-g}, and @dfn{aborting} with | |
34 | @kbd{C-]} or @kbd{M-x top-level}. Quitting cancels a partially typed | |
35 | command or one which is already running. Aborting exits a recursive | |
36 | editing level and cancels the command that invoked the recursive edit. | |
37 | (@xref{Recursive Edit}.) | |
38 | ||
39 | @cindex quitting | |
48d86efe | 40 | @findex keyboard-quit |
6bf7aab6 DL |
41 | @kindex C-g |
42 | Quitting with @kbd{C-g} is used for getting rid of a partially typed | |
43 | command, or a numeric argument that you don't want. It also stops a | |
44 | running command in the middle in a relatively safe way, so you can use | |
45 | it if you accidentally give a command which takes a long time. In | |
46 | particular, it is safe to quit out of killing; either your text will | |
47 | @emph{all} still be in the buffer, or it will @emph{all} be in the kill | |
48 | ring (or maybe both). Quitting an incremental search does special | |
49 | things documented under searching; in general, it may take two | |
50 | successive @kbd{C-g} characters to get out of a search | |
51 | (@pxref{Incremental Search}). | |
52 | ||
53 | On MS-DOS, the character @kbd{C-@key{BREAK}} serves as a quit character | |
54 | like @kbd{C-g}. The reason is that it is not feasible, on MS-DOS, to | |
55 | recognize @kbd{C-g} while a command is running, between interactions | |
56 | with the user. By contrast, it @emph{is} feasible to recognize | |
57 | @kbd{C-@key{BREAK}} at all times. @xref{MS-DOS Input}. | |
58 | ||
59 | @kbd{C-g} works by setting the variable @code{quit-flag} to @code{t} | |
60 | the instant @kbd{C-g} is typed; Emacs Lisp checks this variable | |
61 | frequently and quits if it is non-@code{nil}. @kbd{C-g} is only | |
62 | actually executed as a command if you type it while Emacs is waiting for | |
63 | input. | |
64 | ||
65 | If you quit with @kbd{C-g} a second time before the first @kbd{C-g} is | |
66 | recognized, you activate the ``emergency escape'' feature and return to | |
67 | the shell. @xref{Emergency Escape}. | |
68 | ||
69 | @cindex NFS and quitting | |
70 | There may be times when you cannot quit. When Emacs is waiting for | |
71 | the operating system to do something, quitting is impossible unless | |
72 | special pains are taken for the particular system call within Emacs | |
73 | where the waiting occurs. We have done this for the system calls that | |
74 | users are likely to want to quit from, but it's possible you will find | |
75 | another. In one very common case---waiting for file input or output | |
76 | using NFS---Emacs itself knows how to quit, but most NFS implementations | |
77 | simply do not allow user programs to stop waiting for NFS when the NFS | |
78 | server is hung. | |
79 | ||
80 | @cindex aborting recursive edit | |
81 | @findex abort-recursive-edit | |
82 | @kindex C-] | |
83 | Aborting with @kbd{C-]} (@code{abort-recursive-edit}) is used to get | |
84 | out of a recursive editing level and cancel the command which invoked | |
85 | it. Quitting with @kbd{C-g} does not do this, and could not do this, | |
86 | because it is used to cancel a partially typed command @emph{within} the | |
87 | recursive editing level. Both operations are useful. For example, if | |
88 | you are in a recursive edit and type @kbd{C-u 8} to enter a numeric | |
89 | argument, you can cancel that argument with @kbd{C-g} and remain in the | |
90 | recursive edit. | |
91 | ||
92 | @findex keyboard-escape-quit | |
93 | @kindex ESC ESC ESC | |
94 | The command @kbd{@key{ESC} @key{ESC} @key{ESC}} | |
95 | (@code{keyboard-escape-quit}) can either quit or abort. This key was | |
96 | defined because @key{ESC} is used to ``get out'' in many PC programs. | |
97 | It can cancel a prefix argument, clear a selected region, or get out of | |
98 | a Query Replace, like @kbd{C-g}. It can get out of the minibuffer or a | |
99 | recursive edit, like @kbd{C-]}. It can also get out of splitting the | |
100 | frame into multiple windows, like @kbd{C-x 1}. One thing it cannot do, | |
101 | however, is stop a command that is running. That's because it executes | |
102 | as an ordinary command, and Emacs doesn't notice it until it is ready | |
103 | for a command. | |
104 | ||
105 | @findex top-level | |
106 | The command @kbd{M-x top-level} is equivalent to ``enough'' @kbd{C-]} | |
107 | commands to get you out of all the levels of recursive edits that you | |
108 | are in. @kbd{C-]} gets you out one level at a time, but @kbd{M-x | |
109 | top-level} goes out all levels at once. Both @kbd{C-]} and @kbd{M-x | |
110 | top-level} are like all other commands, and unlike @kbd{C-g}, in that | |
111 | they take effect only when Emacs is ready for a command. @kbd{C-]} is | |
112 | an ordinary key and has its meaning only because of its binding in the | |
113 | keymap. @xref{Recursive Edit}. | |
114 | ||
115 | @kbd{C-x u} (@code{undo}) is not strictly speaking a way of canceling | |
116 | a command, but you can think of it as canceling a command that already | |
117 | finished executing. @xref{Undo}. | |
118 | ||
119 | @node Lossage, Bugs, Quitting, Top | |
120 | @section Dealing with Emacs Trouble | |
121 | ||
122 | This section describes various conditions in which Emacs fails to work | |
123 | normally, and how to recognize them and correct them. | |
124 | ||
125 | @menu | |
126 | * DEL Gets Help:: What to do if @key{DEL} doesn't delete. | |
127 | * Stuck Recursive:: `[...]' in mode line around the parentheses. | |
128 | * Screen Garbled:: Garbage on the screen. | |
129 | * Text Garbled:: Garbage in the text. | |
130 | * Unasked-for Search:: Spontaneous entry to incremental search. | |
131 | * Memory Full:: How to cope when you run out of memory. | |
132 | * After a Crash:: Recovering editing in an Emacs session that crashed. | |
133 | * Emergency Escape:: Emergency escape--- | |
134 | What to do if Emacs stops responding. | |
135 | * Total Frustration:: When you are at your wits' end. | |
136 | @end menu | |
137 | ||
138 | @node DEL Gets Help | |
139 | @subsection If @key{DEL} Fails to Delete | |
140 | ||
141 | If you find that @key{DEL} enters Help like @kbd{Control-h} instead of | |
142 | deleting a character, your terminal is sending the wrong code for | |
143 | @key{DEL}. You can work around this problem by changing the keyboard | |
144 | translation table (@pxref{Keyboard Translations}). | |
145 | ||
146 | @node Stuck Recursive | |
147 | @subsection Recursive Editing Levels | |
148 | ||
149 | Recursive editing levels are important and useful features of Emacs, but | |
150 | they can seem like malfunctions to the user who does not understand them. | |
151 | ||
152 | If the mode line has square brackets @samp{[@dots{}]} around the parentheses | |
153 | that contain the names of the major and minor modes, you have entered a | |
154 | recursive editing level. If you did not do this on purpose, or if you | |
155 | don't understand what that means, you should just get out of the recursive | |
156 | editing level. To do so, type @kbd{M-x top-level}. This is called getting | |
157 | back to top level. @xref{Recursive Edit}. | |
158 | ||
159 | @node Screen Garbled | |
160 | @subsection Garbage on the Screen | |
161 | ||
162 | If the data on the screen looks wrong, the first thing to do is see | |
163 | whether the text is really wrong. Type @kbd{C-l}, to redisplay the | |
164 | entire screen. If the screen appears correct after this, the problem | |
165 | was entirely in the previous screen update. (Otherwise, see @ref{Text | |
166 | Garbled}.) | |
167 | ||
168 | Display updating problems often result from an incorrect termcap entry | |
169 | for the terminal you are using. The file @file{etc/TERMS} in the Emacs | |
170 | distribution gives the fixes for known problems of this sort. | |
171 | @file{INSTALL} contains general advice for these problems in one of its | |
172 | sections. Very likely there is simply insufficient padding for certain | |
173 | display operations. To investigate the possibility that you have this sort | |
174 | of problem, try Emacs on another terminal made by a different manufacturer. | |
175 | If problems happen frequently on one kind of terminal but not another kind, | |
176 | it is likely to be a bad termcap entry, though it could also be due to a | |
177 | bug in Emacs that appears for terminals that have or that lack specific | |
178 | features. | |
179 | ||
180 | @node Text Garbled | |
181 | @subsection Garbage in the Text | |
182 | ||
183 | If @kbd{C-l} shows that the text is wrong, try undoing the changes to it | |
184 | using @kbd{C-x u} until it gets back to a state you consider correct. Also | |
185 | try @kbd{C-h l} to find out what command you typed to produce the observed | |
186 | results. | |
187 | ||
188 | If a large portion of text appears to be missing at the beginning or | |
189 | end of the buffer, check for the word @samp{Narrow} in the mode line. | |
190 | If it appears, the text you don't see is probably still present, but | |
191 | temporarily off-limits. To make it accessible again, type @kbd{C-x n | |
192 | w}. @xref{Narrowing}. | |
193 | ||
194 | @node Unasked-for Search | |
195 | @subsection Spontaneous Entry to Incremental Search | |
196 | ||
197 | If Emacs spontaneously displays @samp{I-search:} at the bottom of the | |
198 | screen, it means that the terminal is sending @kbd{C-s} and @kbd{C-q} | |
199 | according to the poorly designed xon/xoff ``flow control'' protocol. | |
200 | ||
201 | If this happens to you, your best recourse is to put the terminal in a | |
202 | mode where it will not use flow control, or give it so much padding that | |
203 | it will never send a @kbd{C-s}. (One way to increase the amount of | |
204 | padding is to set the variable @code{baud-rate} to a larger value. Its | |
205 | value is the terminal output speed, measured in the conventional units | |
206 | of baud.) | |
207 | ||
208 | @cindex flow control | |
209 | @cindex xon-xoff | |
210 | @findex enable-flow-control | |
211 | If you don't succeed in turning off flow control, the next best thing | |
212 | is to tell Emacs to cope with it. To do this, call the function | |
213 | @code{enable-flow-control}. | |
214 | ||
215 | @findex enable-flow-control-on | |
216 | Typically there are particular terminal types with which you must use | |
217 | flow control. You can conveniently ask for flow control on those | |
218 | terminal types only, using @code{enable-flow-control-on}. For example, | |
219 | if you find you must use flow control on VT-100 and H19 terminals, put | |
220 | the following in your @file{.emacs} file: | |
221 | ||
222 | @example | |
223 | (enable-flow-control-on "vt100" "h19") | |
224 | @end example | |
225 | ||
226 | When flow control is enabled, you must type @kbd{C-\} to get the | |
227 | effect of a @kbd{C-s}, and type @kbd{C-^} to get the effect of a | |
228 | @kbd{C-q}. (These aliases work by means of keyboard translations; see | |
229 | @ref{Keyboard Translations}.) | |
230 | ||
231 | @node Memory Full | |
232 | @subsection Running out of Memory | |
233 | @cindex memory full | |
234 | @cindex out of memory | |
235 | ||
236 | If you get the error message @samp{Virtual memory exceeded}, save your | |
237 | modified buffers with @kbd{C-x s}. This method of saving them has the | |
238 | smallest need for additional memory. Emacs keeps a reserve of memory | |
239 | which it makes available when this error happens; that should be enough | |
240 | to enable @kbd{C-x s} to complete its work. | |
241 | ||
242 | Once you have saved your modified buffers, you can exit this Emacs job | |
243 | and start another, or you can use @kbd{M-x kill-some-buffers} to free | |
244 | space in the current Emacs job. If you kill buffers containing a | |
245 | substantial amount of text, you can safely go on editing. Emacs refills | |
246 | its memory reserve automatically when it sees sufficient free space | |
247 | available, in case you run out of memory another time. | |
248 | ||
249 | Do not use @kbd{M-x buffer-menu} to save or kill buffers when you run | |
250 | out of memory, because the buffer menu needs a fair amount memory | |
251 | itself, and the reserve supply may not be enough. | |
252 | ||
253 | @node After a Crash | |
254 | @subsection Recovery After a Crash | |
255 | ||
256 | If Emacs or the computer crashes, you can recover the files you were | |
257 | editing at the time of the crash from their auto-save files. To do | |
258 | this, start Emacs again and type the command @kbd{M-x recover-session}. | |
259 | ||
260 | This command initially displays a buffer which lists interrupted | |
261 | session files, each with its date. You must choose which session to | |
262 | recover from. Typically the one you want is the most recent one. Move | |
263 | point to the one you choose, and type @kbd{C-c C-c}. | |
264 | ||
265 | Then @code{recover-session} asks about each of the files that you were | |
266 | editing during that session; it asks whether to recover that file. If | |
267 | you answer @kbd{y} for a file, it shows the dates of that file and its | |
268 | auto-save file, then asks once again whether to recover that file. For | |
269 | the second question, you must confirm with @kbd{yes}. If you do, Emacs | |
270 | visits the file but gets the text from the auto-save file. | |
271 | ||
272 | When @code{recover-session} is done, the files you've chosen to | |
273 | recover are present in Emacs buffers. You should then save them. Only | |
274 | this---saving them---updates the files themselves. | |
275 | ||
276 | @node Emergency Escape | |
277 | @subsection Emergency Escape | |
278 | ||
279 | Because at times there have been bugs causing Emacs to loop without | |
280 | checking @code{quit-flag}, a special feature causes Emacs to be suspended | |
281 | immediately if you type a second @kbd{C-g} while the flag is already set, | |
282 | so you can always get out of GNU Emacs. Normally Emacs recognizes and | |
283 | clears @code{quit-flag} (and quits!) quickly enough to prevent this from | |
284 | happening. (On MS-DOS and compatible systems, type @kbd{C-@key{BREAK}} | |
285 | twice.) | |
286 | ||
287 | When you resume Emacs after a suspension caused by multiple @kbd{C-g}, it | |
288 | asks two questions before going back to what it had been doing: | |
289 | ||
290 | @example | |
291 | Auto-save? (y or n) | |
292 | Abort (and dump core)? (y or n) | |
293 | @end example | |
294 | ||
295 | @noindent | |
296 | Answer each one with @kbd{y} or @kbd{n} followed by @key{RET}. | |
297 | ||
298 | Saying @kbd{y} to @samp{Auto-save?} causes immediate auto-saving of all | |
299 | modified buffers in which auto-saving is enabled. | |
300 | ||
301 | Saying @kbd{y} to @samp{Abort (and dump core)?} causes an illegal instruction to be | |
302 | executed, dumping core. This is to enable a wizard to figure out why Emacs | |
303 | was failing to quit in the first place. Execution does not continue | |
304 | after a core dump. If you answer @kbd{n}, execution does continue. With | |
305 | luck, GNU Emacs will ultimately check @code{quit-flag} and quit normally. | |
306 | If not, and you type another @kbd{C-g}, it is suspended again. | |
307 | ||
308 | If Emacs is not really hung, just slow, you may invoke the double | |
309 | @kbd{C-g} feature without really meaning to. Then just resume and answer | |
310 | @kbd{n} to both questions, and you will arrive at your former state. | |
311 | Presumably the quit you requested will happen soon. | |
312 | ||
313 | The double-@kbd{C-g} feature is turned off when Emacs is running under | |
314 | the X Window System, since you can use the window manager to kill Emacs | |
315 | or to create another window and run another program. | |
316 | ||
317 | On MS-DOS and compatible systems, the emergency escape feature is | |
318 | sometimes unavailable, even if you press @kbd{C-@key{BREAK}} twice, when | |
319 | some system call (MS-DOS or BIOS) hangs, or when Emacs is stuck in a | |
320 | very tight endless loop (in C code, @strong{not} in Lisp code). | |
321 | ||
322 | @node Total Frustration | |
323 | @subsection Help for Total Frustration | |
324 | @cindex Eliza | |
325 | @cindex doctor | |
326 | ||
327 | If using Emacs (or something else) becomes terribly frustrating and none | |
328 | of the techniques described above solve the problem, Emacs can still help | |
329 | you. | |
330 | ||
331 | First, if the Emacs you are using is not responding to commands, type | |
332 | @kbd{C-g C-g} to get out of it and then start a new one. | |
333 | ||
334 | @findex doctor | |
335 | Second, type @kbd{M-x doctor @key{RET}}. | |
336 | ||
337 | The doctor will help you feel better. Each time you say something to | |
338 | the doctor, you must end it by typing @key{RET} @key{RET}. This lets | |
339 | the doctor know you are finished. | |
340 | ||
341 | @node Bugs, Contributing, Lossage, Top | |
342 | @section Reporting Bugs | |
343 | ||
344 | @cindex bugs | |
345 | Sometimes you will encounter a bug in Emacs. Although we cannot | |
346 | promise we can or will fix the bug, and we might not even agree that it | |
347 | is a bug, we want to hear about problems you encounter. Often we agree | |
348 | they are bugs and want to fix them. | |
349 | ||
350 | To make it possible for us to fix a bug, you must report it. In order | |
351 | to do so effectively, you must know when and how to do it. | |
352 | ||
353 | @menu | |
354 | * Criteria: Bug Criteria. Have you really found a bug? | |
355 | * Understanding Bug Reporting:: How to report a bug effectively. | |
356 | * Checklist:: Steps to follow for a good bug report. | |
357 | * Sending Patches:: How to send a patch for GNU Emacs. | |
358 | @end menu | |
359 | ||
360 | @node Bug Criteria | |
361 | @subsection When Is There a Bug | |
362 | ||
363 | If Emacs executes an illegal instruction, or dies with an operating | |
364 | system error message that indicates a problem in the program (as opposed to | |
365 | something like ``disk full''), then it is certainly a bug. | |
366 | ||
367 | If Emacs updates the display in a way that does not correspond to what is | |
368 | in the buffer, then it is certainly a bug. If a command seems to do the | |
369 | wrong thing but the problem corrects itself if you type @kbd{C-l}, it is a | |
370 | case of incorrect display updating. | |
371 | ||
372 | Taking forever to complete a command can be a bug, but you must make | |
373 | certain that it was really Emacs's fault. Some commands simply take a | |
374 | long time. Type @kbd{C-g} (@kbd{C-@key{BREAK}} on MS-DOS) and then @kbd{C-h l} | |
375 | to see whether the input Emacs received was what you intended to type; | |
376 | if the input was such that you @emph{know} it should have been processed | |
377 | quickly, report a bug. If you don't know whether the command should | |
378 | take a long time, find out by looking in the manual or by asking for | |
379 | assistance. | |
380 | ||
381 | If a command you are familiar with causes an Emacs error message in a | |
382 | case where its usual definition ought to be reasonable, it is probably a | |
383 | bug. | |
384 | ||
385 | If a command does the wrong thing, that is a bug. But be sure you know | |
386 | for certain what it ought to have done. If you aren't familiar with the | |
387 | command, or don't know for certain how the command is supposed to work, | |
388 | then it might actually be working right. Rather than jumping to | |
389 | conclusions, show the problem to someone who knows for certain. | |
390 | ||
391 | Finally, a command's intended definition may not be best for editing | |
392 | with. This is a very important sort of problem, but it is also a matter of | |
393 | judgment. Also, it is easy to come to such a conclusion out of ignorance | |
394 | of some of the existing features. It is probably best not to complain | |
395 | about such a problem until you have checked the documentation in the usual | |
396 | ways, feel confident that you understand it, and know for certain that what | |
397 | you want is not available. If you are not sure what the command is | |
398 | supposed to do after a careful reading of the manual, check the index and | |
399 | glossary for any terms that may be unclear. | |
400 | ||
401 | If after careful rereading of the manual you still do not understand | |
402 | what the command should do, that indicates a bug in the manual, which | |
403 | you should report. The manual's job is to make everything clear to | |
404 | people who are not Emacs experts---including you. It is just as | |
405 | important to report documentation bugs as program bugs. | |
406 | ||
407 | If the on-line documentation string of a function or variable disagrees | |
408 | with the manual, one of them must be wrong; that is a bug. | |
409 | ||
410 | @node Understanding Bug Reporting | |
411 | @subsection Understanding Bug Reporting | |
412 | ||
413 | @findex emacs-version | |
414 | When you decide that there is a bug, it is important to report it and to | |
415 | report it in a way which is useful. What is most useful is an exact | |
416 | description of what commands you type, starting with the shell command to | |
417 | run Emacs, until the problem happens. | |
418 | ||
419 | The most important principle in reporting a bug is to report | |
420 | @emph{facts}. Hypotheses and verbal descriptions are no substitute for | |
421 | the detailed raw data. Reporting the facts is straightforward, but many | |
422 | people strain to posit explanations and report them instead of the | |
423 | facts. If the explanations are based on guesses about how Emacs is | |
424 | implemented, they will be useless; meanwhile, lacking the facts, we will | |
425 | have no real information about the bug. | |
426 | ||
427 | For example, suppose that you type @kbd{C-x C-f /glorp/baz.ugh | |
428 | @key{RET}}, visiting a file which (you know) happens to be rather large, | |
429 | and Emacs displayed @samp{I feel pretty today}. The best way to report | |
430 | the bug is with a sentence like the preceding one, because it gives all | |
431 | the facts. | |
432 | ||
433 | A bad way would be to assume that the problem is due to the size of | |
434 | the file and say, ``I visited a large file, and Emacs displayed @samp{I | |
435 | feel pretty today}.'' This is what we mean by ``guessing | |
436 | explanations.'' The problem is just as likely to be due to the fact | |
437 | that there is a @samp{z} in the file name. If this is so, then when we | |
438 | got your report, we would try out the problem with some ``large file,'' | |
439 | probably with no @samp{z} in its name, and not see any problem. There | |
440 | is no way in the world that we could guess that we should try visiting a | |
441 | file with a @samp{z} in its name. | |
442 | ||
443 | Alternatively, the problem might be due to the fact that the file starts | |
444 | with exactly 25 spaces. For this reason, you should make sure that you | |
445 | inform us of the exact contents of any file that is needed to reproduce the | |
446 | bug. What if the problem only occurs when you have typed the @kbd{C-x C-a} | |
447 | command previously? This is why we ask you to give the exact sequence of | |
448 | characters you typed since starting the Emacs session. | |
449 | ||
450 | You should not even say ``visit a file'' instead of @kbd{C-x C-f} unless | |
451 | you @emph{know} that it makes no difference which visiting command is used. | |
452 | Similarly, rather than saying ``if I have three characters on the line,'' | |
453 | say ``after I type @kbd{@key{RET} A B C @key{RET} C-p},'' if that is | |
454 | the way you entered the text.@refill | |
455 | ||
456 | So please don't guess any explanations when you report a bug. If you | |
457 | want to actually @emph{debug} the problem, and report explanations that | |
458 | are more than guesses, that is useful---but please include the facts as | |
459 | well. | |
460 | ||
461 | @node Checklist | |
462 | @subsection Checklist for Bug Reports | |
463 | ||
464 | @cindex reporting bugs | |
465 | The best way to send a bug report is to mail it electronically to the | |
f8b3de7e GM |
466 | Emacs maintainers at @samp{bug-gnu-emacs@@gnu.org}, or to |
467 | @samp{emacs-pretest-bug@@gnu.org} if you are pretesting an Emacs beta | |
468 | release. (If you want to suggest a change as an improvement, use the | |
469 | same address.) | |
6bf7aab6 DL |
470 | |
471 | If you'd like to read the bug reports, you can find them on the | |
472 | newsgroup @samp{gnu.emacs.bug}; keep in mind, however, that as a | |
473 | spectator you should not criticize anything about what you see there. | |
474 | The purpose of bug reports is to give information to the Emacs | |
475 | maintainers. Spectators are welcome only as long as they do not | |
476 | interfere with this. In particular, some bug reports contain large | |
477 | amounts of data; spectators should not complain about this. | |
478 | ||
479 | Please do not post bug reports using netnews; mail is more reliable | |
480 | than netnews about reporting your correct address, which we may need in | |
481 | order to ask you for more information. | |
482 | ||
483 | If you can't send electronic mail, then mail the bug report on paper | |
484 | or machine-readable media to this address: | |
485 | ||
486 | @format | |
487 | GNU Emacs Bugs | |
488 | Free Software Foundation | |
489 | 59 Temple Place, Suite 330 | |
490 | Boston, MA 02111-1307 USA | |
491 | @end format | |
492 | ||
493 | We do not promise to fix the bug; but if the bug is serious, | |
494 | or ugly, or easy to fix, chances are we will want to. | |
495 | ||
496 | @findex report-emacs-bug | |
497 | A convenient way to send a bug report for Emacs is to use the command | |
498 | @kbd{M-x report-emacs-bug}. This sets up a mail buffer (@pxref{Sending | |
499 | Mail}) and automatically inserts @emph{some} of the essential | |
500 | information. However, it cannot supply all the necessary information; | |
501 | you should still read and follow the guidelines below, so you can enter | |
502 | the other crucial information by hand before you send the message. | |
503 | ||
504 | To enable maintainers to investigate a bug, your report | |
505 | should include all these things: | |
506 | ||
507 | @itemize @bullet | |
508 | @item | |
509 | The version number of Emacs. Without this, we won't know whether there | |
510 | is any point in looking for the bug in the current version of GNU | |
511 | Emacs. | |
512 | ||
513 | You can get the version number by typing @kbd{M-x emacs-version | |
514 | @key{RET}}. If that command does not work, you probably have something | |
515 | other than GNU Emacs, so you will have to report the bug somewhere | |
516 | else. | |
517 | ||
518 | @item | |
519 | The type of machine you are using, and the operating system name and | |
520 | version number. @kbd{M-x emacs-version @key{RET}} provides this | |
521 | information too. Copy its output from the @samp{*Messages*} buffer, so | |
522 | that you get it all and get it accurately. | |
523 | ||
524 | @item | |
525 | The operands given to the @code{configure} command when Emacs was | |
526 | installed. | |
527 | ||
528 | @item | |
529 | A complete list of any modifications you have made to the Emacs source. | |
530 | (We may not have time to investigate the bug unless it happens in an | |
531 | unmodified Emacs. But if you've made modifications and you don't tell | |
532 | us, you are sending us on a wild goose chase.) | |
533 | ||
534 | Be precise about these changes. A description in English is not | |
535 | enough---send a context diff for them. | |
536 | ||
537 | Adding files of your own, or porting to another machine, is a | |
538 | modification of the source. | |
539 | ||
540 | @item | |
541 | Details of any other deviations from the standard procedure for installing | |
542 | GNU Emacs. | |
543 | ||
544 | @item | |
545 | The complete text of any files needed to reproduce the bug. | |
546 | ||
547 | If you can tell us a way to cause the problem without visiting any files, | |
548 | please do so. This makes it much easier to debug. If you do need files, | |
549 | make sure you arrange for us to see their exact contents. For example, it | |
550 | can often matter whether there are spaces at the ends of lines, or a | |
551 | newline after the last line in the buffer (nothing ought to care whether | |
552 | the last line is terminated, but try telling the bugs that). | |
553 | ||
554 | @item | |
555 | The precise commands we need to type to reproduce the bug. | |
556 | ||
557 | @findex open-dribble-file | |
558 | @cindex dribble file | |
559 | The easy way to record the input to Emacs precisely is to write a | |
560 | dribble file. To start the file, execute the Lisp expression | |
561 | ||
562 | @example | |
563 | (open-dribble-file "~/dribble") | |
564 | @end example | |
565 | ||
566 | @noindent | |
567 | using @kbd{M-:} or from the @samp{*scratch*} buffer just after | |
568 | starting Emacs. From then on, Emacs copies all your input to the | |
569 | specified dribble file until the Emacs process is killed. | |
570 | ||
571 | @item | |
572 | @findex open-termscript | |
573 | @cindex termscript file | |
60a96371 | 574 | @cindex @env{TERM} environment variable |
6bf7aab6 | 575 | For possible display bugs, the terminal type (the value of environment |
60a96371 | 576 | variable @env{TERM}), the complete termcap entry for the terminal from |
6bf7aab6 DL |
577 | @file{/etc/termcap} (since that file is not identical on all machines), |
578 | and the output that Emacs actually sent to the terminal. | |
579 | ||
580 | The way to collect the terminal output is to execute the Lisp expression | |
581 | ||
582 | @example | |
583 | (open-termscript "~/termscript") | |
584 | @end example | |
585 | ||
586 | @noindent | |
587 | using @kbd{M-:} or from the @samp{*scratch*} buffer just after | |
588 | starting Emacs. From then on, Emacs copies all terminal output to the | |
589 | specified termscript file as well, until the Emacs process is killed. | |
590 | If the problem happens when Emacs starts up, put this expression into | |
591 | your @file{.emacs} file so that the termscript file will be open when | |
592 | Emacs displays the screen for the first time. | |
593 | ||
594 | Be warned: it is often difficult, and sometimes impossible, to fix a | |
595 | terminal-dependent bug without access to a terminal of the type that | |
596 | stimulates the bug.@refill | |
597 | ||
598 | @item | |
599 | A description of what behavior you observe that you believe is | |
600 | incorrect. For example, ``The Emacs process gets a fatal signal,'' or, | |
601 | ``The resulting text is as follows, which I think is wrong.'' | |
602 | ||
603 | Of course, if the bug is that Emacs gets a fatal signal, then one can't | |
604 | miss it. But if the bug is incorrect text, the maintainer might fail to | |
605 | notice what is wrong. Why leave it to chance? | |
606 | ||
607 | Even if the problem you experience is a fatal signal, you should still | |
608 | say so explicitly. Suppose something strange is going on, such as, your | |
609 | copy of the source is out of sync, or you have encountered a bug in the | |
610 | C library on your system. (This has happened!) Your copy might crash | |
611 | and the copy here might not. If you @emph{said} to expect a crash, then | |
612 | when Emacs here fails to crash, we would know that the bug was not | |
613 | happening. If you don't say to expect a crash, then we would not know | |
614 | whether the bug was happening---we would not be able to draw any | |
615 | conclusion from our observations. | |
616 | ||
617 | @item | |
618 | If the manifestation of the bug is an Emacs error message, it is | |
619 | important to report the precise text of the error message, and a | |
620 | backtrace showing how the Lisp program in Emacs arrived at the error. | |
621 | ||
622 | To get the error message text accurately, copy it from the | |
623 | @samp{*Messages*} buffer into the bug report. Copy all of it, not just | |
624 | part. | |
625 | ||
626 | To make a backtrace for the error, evaluate the Lisp expression | |
627 | @code{(setq @w{debug-on-error t})} before the error happens (that is to | |
628 | say, you must execute that expression and then make the bug happen). | |
629 | This causes the error to run the Lisp debugger, which shows you a | |
630 | backtrace. Copy the text of the debugger's backtrace into the bug | |
631 | report. | |
632 | ||
633 | This use of the debugger is possible only if you know how to make the | |
634 | bug happen again. If you can't make it happen again, at least copy | |
635 | the whole error message. | |
636 | ||
637 | @item | |
638 | Check whether any programs you have loaded into the Lisp world, | |
639 | including your @file{.emacs} file, set any variables that may affect the | |
640 | functioning of Emacs. Also, see whether the problem happens in a | |
641 | freshly started Emacs without loading your @file{.emacs} file (start | |
642 | Emacs with the @code{-q} switch to prevent loading the init file). If | |
643 | the problem does @emph{not} occur then, you must report the precise | |
644 | contents of any programs that you must load into the Lisp world in order | |
645 | to cause the problem to occur. | |
646 | ||
647 | @item | |
648 | If the problem does depend on an init file or other Lisp programs that | |
649 | are not part of the standard Emacs system, then you should make sure it | |
650 | is not a bug in those programs by complaining to their maintainers | |
651 | first. After they verify that they are using Emacs in a way that is | |
652 | supposed to work, they should report the bug. | |
653 | ||
654 | @item | |
655 | If you wish to mention something in the GNU Emacs source, show the line | |
656 | of code with a few lines of context. Don't just give a line number. | |
657 | ||
658 | The line numbers in the development sources don't match those in your | |
659 | sources. It would take extra work for the maintainers to determine what | |
660 | code is in your version at a given line number, and we could not be | |
661 | certain. | |
662 | ||
663 | @item | |
664 | Additional information from a C debugger such as GDB might enable | |
665 | someone to find a problem on a machine which he does not have available. | |
666 | If you don't know how to use GDB, please read the GDB manual---it is not | |
667 | very long, and using GDB is easy. You can find the GDB distribution, | |
668 | including the GDB manual in online form, in most of the same places you | |
669 | can find the Emacs distribution. To run Emacs under GDB, you should | |
670 | switch to the @file{src} subdirectory in which Emacs was compiled, then | |
671 | do @samp{gdb emacs}. It is important for the directory @file{src} to be | |
672 | current so that GDB will read the @file{.gdbinit} file in this | |
673 | directory. | |
674 | ||
675 | However, you need to think when you collect the additional information | |
676 | if you want it to show what causes the bug. | |
677 | ||
678 | @cindex backtrace for bug reports | |
679 | For example, many people send just a backtrace, but that is not very | |
680 | useful by itself. A simple backtrace with arguments often conveys | |
681 | little about what is happening inside GNU Emacs, because most of the | |
682 | arguments listed in the backtrace are pointers to Lisp objects. The | |
683 | numeric values of these pointers have no significance whatever; all that | |
684 | matters is the contents of the objects they point to (and most of the | |
685 | contents are themselves pointers). | |
686 | ||
687 | @findex debug_print | |
688 | To provide useful information, you need to show the values of Lisp | |
689 | objects in Lisp notation. Do this for each variable which is a Lisp | |
690 | object, in several stack frames near the bottom of the stack. Look at | |
691 | the source to see which variables are Lisp objects, because the debugger | |
692 | thinks of them as integers. | |
693 | ||
694 | To show a variable's value in Lisp syntax, first print its value, then | |
695 | use the user-defined GDB command @code{pr} to print the Lisp object in | |
696 | Lisp syntax. (If you must use another debugger, call the function | |
697 | @code{debug_print} with the object as an argument.) The @code{pr} | |
698 | command is defined by the file @file{.gdbinit}, and it works only if you | |
699 | are debugging a running process (not with a core dump). | |
700 | ||
701 | To make Lisp errors stop Emacs and return to GDB, put a breakpoint at | |
702 | @code{Fsignal}. | |
703 | ||
8389e1e2 GM |
704 | For a short listing of Lisp functions running, type the GDB |
705 | command @code{xbacktrace}. | |
706 | ||
707 | If you want to examine Lisp function arguments, move up the stack, and | |
708 | each time you get to a frame for the function @code{Ffuncall}, type | |
709 | these GDB commands: | |
6bf7aab6 DL |
710 | |
711 | @example | |
712 | p *args | |
713 | pr | |
714 | @end example | |
715 | ||
716 | @noindent | |
717 | To print the first argument that the function received, use these | |
718 | commands: | |
719 | ||
720 | @example | |
721 | p args[1] | |
722 | pr | |
723 | @end example | |
724 | ||
725 | @noindent | |
726 | You can print the other arguments likewise. The argument @code{nargs} | |
727 | of @code{Ffuncall} says how many arguments @code{Ffuncall} received; | |
728 | these include the Lisp function itself and the arguments for that | |
729 | function. | |
730 | ||
731 | The file @file{.gdbinit} defines several other commands that are useful | |
732 | for examining the data types and contents of Lisp objects. Their names | |
733 | begin with @samp{x}. These commands work at a lower level than | |
734 | @code{pr}, and are less convenient, but they may work even when | |
735 | @code{pr} does not, such as when debugging a core dump or when Emacs has | |
736 | had a fatal signal. | |
737 | ||
738 | @item | |
739 | If the symptom of the bug is that Emacs fails to respond, don't assume | |
740 | Emacs is ``hung''---it may instead be in an infinite loop. To find out | |
741 | which, make the problem happen under GDB and stop Emacs once it is not | |
742 | responding. (If Emacs is using X Windows directly, you can stop Emacs | |
743 | by typing @kbd{C-z} at the GDB job.) Then try stepping with | |
744 | @samp{step}. If Emacs is hung, the @samp{step} command won't return. | |
745 | If it is looping, @samp{step} will return. | |
746 | ||
747 | If this shows Emacs is hung in a system call, stop it again and examine | |
748 | the arguments of the call. In your bug report, state exactly where in | |
749 | the source the system call is, and what the arguments are. | |
750 | ||
751 | If Emacs is in an infinite loop, please determine where the loop starts | |
752 | and ends. The easiest way to do this is to use the GDB command | |
753 | @samp{finish}. Each time you use it, Emacs resumes execution until it | |
754 | exits one stack frame. Keep typing @samp{finish} until it doesn't | |
755 | return---that means the infinite loop is in the stack frame which you | |
756 | just tried to finish. | |
757 | ||
758 | Stop Emacs again, and use @samp{finish} repeatedly again until you get | |
759 | @emph{back to} that frame. Then use @samp{next} to step through that | |
760 | frame. By stepping, you will see where the loop starts and ends. Also | |
761 | please examine the data being used in the loop and try to determine why | |
762 | the loop does not exit when it should. Include all of this information | |
763 | in your bug report. | |
764 | @end itemize | |
765 | ||
766 | Here are some things that are not necessary in a bug report: | |
767 | ||
768 | @itemize @bullet | |
769 | @item | |
770 | A description of the envelope of the bug---this is not necessary for a | |
771 | reproducible bug. | |
772 | ||
773 | Often people who encounter a bug spend a lot of time investigating | |
774 | which changes to the input file will make the bug go away and which | |
775 | changes will not affect it. | |
776 | ||
777 | This is often time-consuming and not very useful, because the way we | |
778 | will find the bug is by running a single example under the debugger with | |
779 | breakpoints, not by pure deduction from a series of examples. You might | |
780 | as well save time by not searching for additional examples. | |
781 | ||
782 | Of course, if you can find a simpler example to report @emph{instead} of | |
783 | the original one, that is a convenience. Errors in the output will be | |
784 | easier to spot, running under the debugger will take less time, etc. | |
785 | ||
786 | However, simplification is not vital; if you can't do this or don't have | |
787 | time to try, please report the bug with your original test case. | |
788 | ||
789 | @item | |
790 | A system-call trace of Emacs execution. | |
791 | ||
792 | System-call traces are very useful for certain special kinds of | |
793 | debugging, but in most cases they give little useful information. It is | |
794 | therefore strange that many people seem to think that @emph{the} way to | |
795 | report information about a crash is to send a system-call trace. Perhaps | |
796 | this is a habit formed from experience debugging programs that don't | |
797 | have source code or debugging symbols. | |
798 | ||
799 | In most programs, a backtrace is normally far, far more informative than | |
800 | a system-call trace. Even in Emacs, a simple backtrace is generally | |
801 | more informative, though to give full information you should supplement | |
802 | the backtrace by displaying variable values and printing them as Lisp | |
803 | objects with @code{pr} (see above). | |
804 | ||
805 | @item | |
806 | A patch for the bug. | |
807 | ||
808 | A patch for the bug is useful if it is a good one. But don't omit the | |
809 | other information that a bug report needs, such as the test case, on the | |
810 | assumption that a patch is sufficient. We might see problems with your | |
811 | patch and decide to fix the problem another way, or we might not | |
812 | understand it at all. And if we can't understand what bug you are | |
813 | trying to fix, or why your patch should be an improvement, we mustn't | |
814 | install it. | |
815 | ||
816 | @ifinfo | |
817 | @xref{Sending Patches}, for guidelines on how to make it easy for us to | |
818 | understand and install your patches. | |
819 | @end ifinfo | |
820 | ||
821 | @item | |
822 | A guess about what the bug is or what it depends on. | |
823 | ||
824 | Such guesses are usually wrong. Even experts can't guess right about | |
825 | such things without first using the debugger to find the facts. | |
826 | @end itemize | |
827 | ||
828 | @node Sending Patches | |
829 | @subsection Sending Patches for GNU Emacs | |
830 | ||
831 | @cindex sending patches for GNU Emacs | |
832 | @cindex patches, sending | |
833 | If you would like to write bug fixes or improvements for GNU Emacs, | |
834 | that is very helpful. When you send your changes, please follow these | |
835 | guidelines to make it easy for the maintainers to use them. If you | |
836 | don't follow these guidelines, your information might still be useful, | |
837 | but using it will take extra work. Maintaining GNU Emacs is a lot of | |
838 | work in the best of circumstances, and we can't keep up unless you do | |
839 | your best to help. | |
840 | ||
841 | @itemize @bullet | |
842 | @item | |
843 | Send an explanation with your changes of what problem they fix or what | |
844 | improvement they bring about. For a bug fix, just include a copy of the | |
845 | bug report, and explain why the change fixes the bug. | |
846 | ||
847 | (Referring to a bug report is not as good as including it, because then | |
848 | we will have to look it up, and we have probably already deleted it if | |
849 | we've already fixed the bug.) | |
850 | ||
851 | @item | |
852 | Always include a proper bug report for the problem you think you have | |
853 | fixed. We need to convince ourselves that the change is right before | |
854 | installing it. Even if it is correct, we might have trouble | |
855 | understanding it if we don't have a way to reproduce the problem. | |
856 | ||
857 | @item | |
858 | Include all the comments that are appropriate to help people reading the | |
859 | source in the future understand why this change was needed. | |
860 | ||
861 | @item | |
862 | Don't mix together changes made for different reasons. | |
863 | Send them @emph{individually}. | |
864 | ||
865 | If you make two changes for separate reasons, then we might not want to | |
866 | install them both. We might want to install just one. If you send them | |
867 | all jumbled together in a single set of diffs, we have to do extra work | |
868 | to disentangle them---to figure out which parts of the change serve | |
869 | which purpose. If we don't have time for this, we might have to ignore | |
870 | your changes entirely. | |
871 | ||
872 | If you send each change as soon as you have written it, with its own | |
873 | explanation, then two changes never get tangled up, and we can consider | |
874 | each one properly without any extra work to disentangle them. | |
875 | ||
876 | @item | |
877 | Send each change as soon as that change is finished. Sometimes people | |
878 | think they are helping us by accumulating many changes to send them all | |
879 | together. As explained above, this is absolutely the worst thing you | |
880 | could do. | |
881 | ||
882 | Since you should send each change separately, you might as well send it | |
883 | right away. That gives us the option of installing it immediately if it | |
884 | is important. | |
885 | ||
886 | @item | |
887 | Use @samp{diff -c} to make your diffs. Diffs without context are hard | |
888 | to install reliably. More than that, they are hard to study; we must | |
889 | always study a patch to decide whether we want to install it. Unidiff | |
890 | format is better than contextless diffs, but not as easy to read as | |
891 | @samp{-c} format. | |
892 | ||
893 | If you have GNU diff, use @samp{diff -c -F'^[_a-zA-Z0-9$]+ *('} when | |
894 | making diffs of C code. This shows the name of the function that each | |
895 | change occurs in. | |
896 | ||
897 | @item | |
898 | Avoid any ambiguity as to which is the old version and which is the new. | |
899 | Please make the old version the first argument to diff, and the new | |
900 | version the second argument. And please give one version or the other a | |
901 | name that indicates whether it is the old version or your new changed | |
902 | one. | |
903 | ||
904 | @item | |
905 | Write the change log entries for your changes. This is both to save us | |
906 | the extra work of writing them, and to help explain your changes so we | |
907 | can understand them. | |
908 | ||
909 | The purpose of the change log is to show people where to find what was | |
910 | changed. So you need to be specific about what functions you changed; | |
911 | in large functions, it's often helpful to indicate where within the | |
912 | function the change was. | |
913 | ||
914 | On the other hand, once you have shown people where to find the change, | |
915 | you need not explain its purpose in the change log. Thus, if you add a | |
916 | new function, all you need to say about it is that it is new. If you | |
917 | feel that the purpose needs explaining, it probably does---but put the | |
918 | explanation in comments in the code. It will be more useful there. | |
919 | ||
920 | Please read the @file{ChangeLog} files in the @file{src} and @file{lisp} | |
921 | directories to see what sorts of information to put in, and to learn the | |
922 | style that we use. If you would like your name to appear in the header | |
923 | line, showing who made the change, send us the header line. | |
924 | @xref{Change Log}. | |
925 | ||
926 | @item | |
927 | When you write the fix, keep in mind that we can't install a change that | |
928 | would break other systems. Please think about what effect your change | |
929 | will have if compiled on another type of system. | |
930 | ||
931 | Sometimes people send fixes that @emph{might} be an improvement in | |
932 | general---but it is hard to be sure of this. It's hard to install | |
933 | such changes because we have to study them very carefully. Of course, | |
934 | a good explanation of the reasoning by which you concluded the change | |
935 | was correct can help convince us. | |
936 | ||
937 | The safest changes are changes to the configuration files for a | |
938 | particular machine. These are safe because they can't create new bugs | |
939 | on other machines. | |
940 | ||
941 | Please help us keep up with the workload by designing the patch in a | |
942 | form that is clearly safe to install. | |
943 | @end itemize | |
944 | ||
945 | @node Contributing, Service, Bugs, Top | |
946 | @section Contributing to Emacs Development | |
947 | ||
948 | If you would like to help pretest Emacs releases to assure they work | |
949 | well, or if you would like to work on improving Emacs, please contact | |
60a96371 | 950 | the maintainers at @email{bug-gnu-emacs@@gnu.org}. A pretester |
6bf7aab6 DL |
951 | should be prepared to investigate bugs as well as report them. If you'd |
952 | like to work on improving Emacs, please ask for suggested projects or | |
953 | suggest your own ideas. | |
954 | ||
955 | If you have already written an improvement, please tell us about it. If | |
956 | you have not yet started work, it is useful to contact | |
60a96371 | 957 | @email{bug-gnu-emacs@@gnu.org} before you start; it might be |
6bf7aab6 DL |
958 | possible to suggest ways to make your extension fit in better with the |
959 | rest of Emacs. | |
960 | ||
961 | @node Service, Command Arguments, Contributing, Top | |
962 | @section How To Get Help with GNU Emacs | |
963 | ||
964 | If you need help installing, using or changing GNU Emacs, there are two | |
965 | ways to find it: | |
966 | ||
967 | @itemize @bullet | |
968 | @item | |
969 | Send a message to the mailing list | |
60a96371 | 970 | @email{help-gnu-emacs@@gnu.org}, or post your request on |
6bf7aab6 DL |
971 | newsgroup @code{gnu.emacs.help}. (This mailing list and newsgroup |
972 | interconnect, so it does not matter which one you use.) | |
973 | ||
974 | @item | |
975 | Look in the service directory for someone who might help you for a fee. | |
976 | The service directory is found in the file named @file{etc/SERVICE} in the | |
977 | Emacs distribution. | |
978 | @end itemize |