![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-11 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info|
Return to emacs-11 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info |
1.1 root 1: Info file emacs, produced by texinfo-format-buffer -*-Text-*-
2: from file emacs.tex
3:
4: This file documents the GNU Emacs editor.
5:
6: Copyright (C) 1985, 1986 Richard M. Stallman.
7:
8: Permission is granted to make and distribute verbatim copies of
9: this manual provided the copyright notice and this permission notice
10: are preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of this
13: manual under the conditions for verbatim copying, provided also that the
14: sections entitled "The GNU Manifesto", "Distribution" and "GNU Emacs
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 manual
20: into another language, under the above conditions for modified versions,
21: except that the sections entitled "The GNU Manifesto", "Distribution"
22: and "GNU Emacs General Public License" may be included in a translation
23: approved by the author instead of in the original English.
24:
25:
26: File: emacs Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
27:
28: Altering Syntax Information
29: ---------------------------
30:
31: It is possible to alter a character's syntax table entry by storing a new
32: number in the appropriate element of the syntax table, but it would be hard
33: to determine what number to use. Therefore, Emacs provides a command that
34: allows you to specify the syntactic properties of a character in a
35: convenient way.
36:
37: `M-x modify-syntax-entry' is the command to change a character's
38: syntax. It can be used interactively, and is also the means used by major
39: modes to initialize their own syntax tables. Its first argument is the
40: character to change. The second argument is a string that specifies the
41: new syntax. When called from Lisp code, there is a third, optional
42: argument, which specifies the syntax table in which to make the change. If
43: not supplied, or if this command is called interactively, the third
44: argument defaults to the current buffer's syntax table.
45:
46: 1. The first character in the string specifies the syntactic class. It
47: is one of the characters in the previous table (*Note Syntax Entry::).
48:
49: 2. The second character is the matching delimiter. For a character that
50: is not an opening or closing delimiter, this should be a space, and may
51: be omitted if no following characters are needed.
52:
53: 3. The remaining characters are flags. The flag characters allowed are
54:
55: `1'
56: Flag this character as the first of a two-character comment starting sequence.
57: `2'
58: Flag this character as the second of a two-character comment starting sequence.
59: `3'
60: Flag this character as the first of a two-character comment ending sequence.
61: `4'
62: Flag this character as the second of a two-character comment ending sequence.
63:
64: A description of the contents of the current syntax table can be
65: displayed with `C-h s' (`describe-syntax'). The description of
66: each character includes both the string you would have to give to
67: `modify-syntax-entry' to set up that character's current syntax, and
68: some English to explain that string if necessary.
69:
70:
71: File: emacs Node: Init File, Prev: Syntax, Up: Customization
72:
73: The Init File, .emacs
74: =====================
75:
76: When Emacs is started, it normally loads the file `.emacs' in your
77: home directory. This file, if it exists, should contain Lisp code. It is
78: called your "init file". The command line switches `-q' and
79: `-u' can be used to tell Emacs whether to load an init file
80: (*Note Entering Emacs::).
81:
82: There can also be a "default init file", which is the library named
83: `default.el', found via the standard search path for libraries. The
84: Emacs distribution contains no such library; your site may create one for
85: local customizations. If this library exists, it is loaded whenever you
86: start Emacs. But your init file, if any, is loaded first; if it sets
87: `inhibit-default-init' non-`nil', then `default' is not
88: loaded.
89:
90: If you have a large amount of code in your `.emacs' file, you
91: should move it into another file named `SOMETHING.el',
92: byte-compile it (*Note Lisp Libraries::), and make your `.emacs'
93: file load the other file using `load'.
94:
95: * Menu:
96:
97: * Init Syntax:: Syntax of constants in Emacs Lisp.
98: * Init Examples:: How to do some things with an init file.
99: * Terminal Init:: Each terminal type can have an init file.
100:
101:
102: File: emacs Node: Init Syntax, Prev: Init File, Up: Init File, Next: Init Examples
103:
104: Init File Syntax
105: ----------------
106:
107: The `.emacs' file contains one or more Lisp function call
108: expressions. Each of these consists of a function name followed by
109: arguments, all surrounded by parentheses. For example, `(setq
110: fill-column 60)' represents a call to the function `setq' which is
111: used to set the variable `fill-column' (*Note Filling::) to 60.
112:
113: The second argument to `setq' is an expression for the new value of
114: the variable. This can be a constant, a variable, or a function call
115: expression. In `.emacs', constants are used most of the time. They can be:
116:
117: Numbers:
118: Numbers are written in decimal, with an optional initial minus sign.
119:
120: Strings:
121: Lisp string syntax is the same as C string syntax with a few extra
122: features. Use a double-quote character to begin and end a string constant.
123:
124: Newlines and special characters may be present literally in strings. They
125: can also be represented as backslash sequences: `\n' for newline,
126: `\b' for backspace, `\r' for carriage return, `\t' for tab,
127: `\f' for formfeed (control-l), `\e' for escape, `\\' for a
128: backslash, `\"' for a double-quote, or `\OOO' for the
129: character whose octal code is OOO. Backslash and double-quote are
130: the only characters for which backslash sequences are mandatory.
131:
132: `\C-' can be used as a prefix for a control character, as in `\C-s'
133: for ASCII Control-S, and `\M-' can be used as a prefix for a meta
134: character, as in `\M-a' for Meta-A or `\M-\C-a' for Control-Meta-A.
135:
136: Characters:
137: Lisp character constant syntax consists of a `?' followed by
138: either a character or an escape sequence starting with `\'.
139: Examples: `?x', `?\n', `?\"', `?\)'. Note that
140: strings and characters are not interchangeable in Lisp; some contexts
141: require one and some contexts require the other.
142:
143: True:
144: `t' stands for `true'.
145:
146: False:
147: `nil' stands for `false'.
148:
149: Other Lisp objects:
150: Write a single-quote (') followed by the Lisp object you want.
151:
152:
153: File: emacs Node: Init Examples, Prev: Init Syntax, Up: Init File, Next: Terminal Init
154:
155: Init File Examples
156: ------------------
157:
158: Here are some examples of doing certain commonly desired things with
159: Lisp expressions:
160:
161: * Make TAB in C mode just insert a tab if point is in the middle of a
162: line.
163:
164: (setq c-tab-always-indent nil)
165:
166: Here we have a variable whose value is normally `t' for `true'
167: and the alternative is `nil' for `false'.
168:
169: * Make searches case sensitive by default (in all buffers that do not
170: override this).
171:
172: (setq-default case-fold-search nil)
173:
174: This sets the default value, which is effective in all buffers that do
175: not have local values for the variable. Setting `case-fold-search'
176: with `setq' affects only the current buffer's local value, which
177: is not what you probably want to do in an init file.
178:
179: * Make Text mode the default mode for new buffers.
180:
181: (setq default-major-mode 'text-mode)
182:
183: Note that `text-mode' is used because it is the command for entering
184: the mode we want. A single-quote is written before it to make a symbol
185: constant; otherwise, `text-mode' would be treated as a variable name.
186:
187: * Turn on Auto Fill mode automatically in Text mode and related modes.
188:
189: (setq text-mode-hook
190: '(lambda () (auto-fill-mode 1)))
191:
192: Here we have a variable whose value should be a Lisp function. The
193: function we supply is a list starting with `lambda', and a single
194: quote is written in front of it to make it (for the purpose of this
195: `setq') a list constant rather than an expression. Lisp functions
196: are not explained here, but for mode hooks it is enough to know that
197: `(auto-fill-mode 1)' is an expression that will be executed when
198: Text mode is entered, and you could replace it with any other expression
199: that you like, or with several expressions in a row.
200:
201: (setq text-mode-hook 'turn-on-auto-fill)
202:
203: This is another way to accomplish the same result.
204: `turn-on-auto-fill' is a symbol whose function definition is
205: `(lambda () (auto-fill-mode 1))'.
206:
207: * Load the installed Lisp library named `foo' (actually a file
208: `foo.elc' or `foo.el' in a standard Emacs directory).
209:
210: (load "foo")
211:
212: When the argument to `load' is a relative pathname, not starting
213: with `/' or `~', `load' searches the directories in
214: `load-path' (*Note Loading::).
215:
216: * Load the compiled Lisp file `foo.elc' from your home directory.
217:
218: (load "~/foo.elc")
219:
220: Here an absolute file name is used, so no searching is done.
221:
222: * Rebind the key `C-x l' to run the function `make-symbolic-link'.
223:
224: (global-set-key "\C-xl" 'make-symbolic-link)
225:
226: or
227:
228: (define-key global-map "\C-xl" 'make-symbolic-link)
229:
230: Note once again the single-quote used to refer to the symbol
231: `make-symbolic-link' instead of its value as a variable.
232:
233: * Do the same thing for C mode only.
234:
235: (define-key c-mode-map "\C-xl" 'make-symbolic-link)
236:
237: * Redefine all keys which now run `next-line' in Fundamental mode
238: so that they run `forward-line' instead.
239:
240: (substitute-key-definition 'next-line 'forward-line
241: global-map)
242:
243: * Make `C-x C-v' undefined.
244:
245: (global-unset-key "\C-x\C-v")
246:
247: One reason to undefine a key is so that you can make it a prefix.
248: Simply defining `C-x C-v ANYTHING' would make `C-x C-v'
249: a prefix, but `C-x C-v' must be freed of any non-prefix definition
250: first.
251:
252: * Make `$' have the syntax of punctuation in Text mode.
253: Note the use of a character constant for `$'.
254:
255: (modify-syntax-entry ?\$ "." text-mode-syntax-table)
256:
257: * Enable the use of the command `eval-expression' without confirmation.
258:
259: (put 'eval-expression 'disabled nil)
260:
261:
262: File: emacs Node: Terminal Init, Prev: Init Examples, Up: Init File
263:
264: Terminal-specific Initialization
265: --------------------------------
266:
267: Each terminal type can have a Lisp library to be loaded into Emacs when
268: it is run on that type of terminal. For a terminal type named TERMTYPE,
269: the library is called `term/TERMTYPE' and it is found by searching the
270: directories `load-path' as usual and trying the suffixes `.elc' and `.el'.
271: Normally it appears in the subdirectory `term' of the directory where most
272: Emacs libraries are kept.
273:
274: The usual purpose of the terminal-specific library is to define the
275: escape sequences used by the terminal's function keys using the library
276: `keypad.el'. See the file `term/vt100.el' for an example of how this is
277: done.
278:
279: When the terminal type contains a hyphen, only the part of the name
280: before the first hyphen is significant in choosing the library name. Thus,
281: terminal types `aaa-48' and `aaa-30-rv' both use the library `term/aaa'.
282: The code in the library can use `(getenv "TERM")' to find the full terminal
283: type name.
284:
285: The library's name is constructed by concatenating the value of the
286: variable `term-file-prefix' and the terminal type. Your `.emacs'
287: file can prevent the loading of the terminal-specific library by setting
288: `term-file-prefix' to `nil'.
289:
290: The value of the variable `term-setup-hook', if not `nil', is called as a
291: function of no arguments at the end of Emacs initialization, after both
292: your `.emacs' file and any terminal-specific library have been read in.
293: You can set the value in the `.emacs' file to override part of any of the
294: terminal-specific libraries and to define initializations for terminals
295: that do not have a library.
296:
297:
298:
299: File: emacs Node: Quitting, Prev: Customization, Up: Top, Next: Lossage
300:
301: Quitting and Aborting
302: =====================
303:
304: `C-g'
305: Quit. Cancel running or partially typed command.
306: `C-]'
307: Abort innermost recursive editing level and cancel the command which
308: invoked it (`abort-recursive-edit').
309: `M-x top-level'
310: Abort all recursive editing levels that are currently executing.
311: `C-x u'
312: Cancel an already-executed command, usually (`undo').
313:
314: There are two ways of cancelling commands which are not finished
315: executing: "quitting" with `C-g', and "aborting" with `C-]'
316: or `M-x top-level'. Quitting is cancelling a partially typed command
317: or one which is already running. Aborting is getting out of a recursive
318: editing level and cancelling the command that invoked the recursive edit.
319:
320: Quitting with `C-g' is used for getting rid of a partially typed
321: command, or a numeric argument that you don't want. It also stops a
322: running command in the middle in a relatively safe way, so you can use it
323: if you accidentally give a command which takes a long time. In particular,
324: it is safe to quit out of killing; either your text will ALL still be
325: there, or it will ALL be in the kill ring (or maybe both). Quitting
326: an incremental search does special things documented under searching; in
327: general, it may take two successive `C-g' characters to get out of a
328: search. `C-g' works by setting the variable `quit-flag' to
329: `t' the instant `C-g' is typed; Emacs Lisp checks this variable
330: frequently and quits if it is non-`nil'. `C-g' is only actually
331: executed as a command if it is typed while Emacs is waiting for input.
332:
333: If you quit twice in a row before the first `C-g' is recognized, you
334: activate the "emergency escape" feature and return to the shell.
335: *Note Emergency Escape::.
336:
337: Aborting with `C-]' (`abort-recursive-edit') is used to get out
338: of a recursive editing level and cancel the command which invoked it.
339: Quitting with `C-g' does not do this, and could not do this, because it
340: is used to cancel a partially typed command within the recursive
341: editing level. Both operations are useful. For example, if you are in the
342: Emacs debugger (*Note Lisp Debug::) and have typed `C-u 8' to enter a
343: numeric argument, you can cancel that argument with `C-g' and remain in
344: the debugger.
345:
346: The command `M-x top-level' is equivalent to "enough" `C-]'
347: commands to get you out of all the levels of recursive edits that you are
348: in. `C-]' gets you out one level at a time, but `M-x top-level'
349: goes out all levels at once. Both `C-]' and `M-x top-level' are
350: like all other commands, and unlike `C-g', in that they are effective
351: only when Emacs is ready for a command. `C-]' is an ordinary key and
352: has its meaning only because of its binding in the keymap.
353: *Note Recursive Edit::.
354:
355: `C-x u' (`undo') is not strictly speaking a way of cancelling a
356: command, but you can think of it as cancelling a command already finished
357: executing. *Note Undo::.
358:
359:
360: File: emacs Node: Lossage, Prev: Quitting, Up: Top, Next: Bugs
361:
362: Dealing with Emacs Trouble
363: ==========================
364:
365: This section describes various conditions in which Emacs fails to work,
366: and how to recognize them and correct them.
367:
368: * Menu:
369:
370: * Stuck Recursive:: `[...]' in mode line around the parentheses
371: * Screen Garbled:: Garbage on the screen
372: * Text Garbled:: Garbage in the text
373: * Unasked-for Search:: Spontaneous entry to incremental search
374: * Emergency Escape:: Emergency escape---
375: What to do if Emacs stops responding
376: * Total Frustration:: When you are at your wits' end.
377:
378:
379: File: emacs Node: Stuck Recursive, Prev: Lossage, Up: Lossage, Next: Screen Garbled
380:
381: Recursive Editing Levels
382: ------------------------
383:
384: Recursive editing levels are important and useful features of Emacs, but
385: they can seem like malfunctions to the user who does not understand them.
386:
387: If the mode line has square brackets `[...]' around the parentheses
388: that contain the names of the major and minor modes, you have entered a
389: recursive editing level. If you did not do this on purpose, or if you
390: don't understand what that means, you should just get out of the recursive
391: editing level. To do so, type `M-x top-level'. This is called getting
392: back to top level. *Note Recursive Edit::.
393:
394:
395: File: emacs Node: Screen Garbled, Prev: Stuck Recursive, Up: Lossage, Next: Text Garbled
396:
397: Garbage on the Screen
398: ---------------------
399:
400: If the data on the screen looks wrong, the first thing to do is see
401: whether the text is really wrong. Type `C-l', to redisplay the entire
402: screen. If it appears correct after this, the problem was entirely in the
403: previous screen update.
404:
405: Display updating problems often result from an incorrect termcap entry
406: for the terminal you are using. The file `etc/TERMS' in the Emacs
407: distribution gives the fixes for known problems of this sort.
408: `INSTALL' contains general advice for these problems in one of its
409: sections. Very likely there is simply insufficient padding for certain
410: display operations. To investigate the possibility that you have this sort
411: of problem, try Emacs on another terminal made by a different manufacturer.
412: If problems happen frequently on one kind of terminal but not another kind,
413: it is likely to be a bad termcap entry, though it could also be due to a
414: bug in Emacs that appears for terminals that have or that lack specific
415: features.
416:
417:
418: File: emacs Node: Text Garbled, Prev: Screen Garbled, Up: Lossage, Next: Unasked-for Search
419:
420: Garbage in the Text
421: -------------------
422:
423: If `C-l' shows that the text is wrong, try undoing the changes to it
424: using `C-x u' until it gets back to a state you consider correct. Also
425: try `C-h l' to find out what command you typed to produce the observed
426: results.
427:
428: If a large portion of text appears to be missing at the beginning or
429: end of the buffer, check for the word `Narrow' in the mode line.
430: If it appears, the text is still present, but marked off-limits.
431: To make it visible again, type `C-x w'. *Note Narrowing::.
432:
433:
434: File: emacs Node: Unasked-for Search, Prev: Text Garbled, Up: Lossage, Next: Emergency Escape
435:
436: Spontaneous Entry to Incremental Search
437: ---------------------------------------
438:
439: If Emacs spontaneously displays `I-search:' at the bottom of the
440: screen, it means that the terminal is sending `C-s' and `C-q'
441: according to the poorly designed xon/xoff "flow control" protocol. You
442: should try to prevent this by putting the terminal in a mode where it will
443: not use flow control or giving it enough padding that it will never send a
444: `C-s'. If that cannot be done, you must tell Emacs to expect flow
445: control to be used, until you can get a properly designed terminal.
446:
447: Information on how to do these things can be found in the file
448: `INSTALL' in the Emacs distribution.
449:
450:
451: File: emacs Node: Emergency Escape, Prev: Unasked-for Search, Up: Lossage, Next: Total Frustration
452:
453: Emergency Escape
454: ----------------
455:
456: Because at times there have been bugs causing Emacs to loop without
457: checking `quit-flag', a special feature causes Emacs to be suspended
458: immediately if you type a second `C-g' while the flag is already set,
459: so you can always get out of GNU Emacs. Normally Emacs recognizes and
460: clears `quit-flag' (and quits!) quickly enough to prevent this from
461: happening.
462:
463: When you resume Emacs after a suspension caused by multiple `C-g', it
464: asks two questions before going back to what it had been doing:
465:
466: Auto-save? (y or n)
467: Abort (and dump core)? (y or n)
468:
469: Answer each one with `y' or `n' followed by RET.
470:
471: Saying `y' to `Auto-save?' causes immediate auto-saving of all
472: modified buffers in which auto-saving is enabled.
473:
474: Saying `y' to `Abort (and dump core)?' causes an illegal instruction to be
475: executed, dumping core. This is to enable a wizard to figure out why Emacs
476: was failing to quit in the first place. Execution does not continue
477: after a core dump. If you answer `n', execution does continue. With
478: luck, GNU Emacs will ultimately check `quit-flag' and quit normally.
479: If not, and you type another `C-g', it is suspended again.
480:
481: If Emacs is not really hung, just slow, you may invoke the double
482: `C-g' feature without really meaning to. Then just resume and answer
483: `n' to both questions, and you will arrive at your former state.
484: Presumably the quit you requested will happen soon.
485:
486: The double-`C-g' feature may be turned off when Emacs is running under
487: a window system, since the window system always enables you to kill Emacs
488: or to create another window and run another program.
489:
490:
491: File: emacs Node: Total Frustration, Prev: Emergency Escape, Up: Lossage
492:
493: Help for Total Frustration
494: --------------------------
495:
496: If using Emacs (or something else) becomes terribly frustrating and none
497: of the techniques described above solve the problem, Emacs can still help
498: you.
499:
500: First, if the Emacs you are using is not responding to commands, type
501: `C-g C-g' to get out of it and then start a new one.
502:
503: Second, type `M-x doctor RET'.
504:
505: The doctor will make you feel better. Each time you say something to
506: the doctor, you must end it by typing RET RET. This lets the
507: doctor know you are finished.
508:
509:
510: File: emacs Node: Bugs, Prev: Lossage, Up: Top, Next: Manifesto
511:
512: Reporting Bugs
513: ==============
514:
515: Sometimes you will encounter a bug in Emacs. Although we cannot promise
516: we can or will fix the bug, and we might not even agree that it is a bug,
517: we want to hear about bugs you encounter in case we do want to fix them.
518:
519: To make it possible for us to fix a bug, you must report it. In order
520: to do so effectively, you must know when and how to do it.
521:
522:
523: When Is There a Bug
524: -------------------
525:
526: If Emacs executes an illegal instruction, or dies with an operating
527: system error message that indicates a problem in the program (as opposed to
528: something like "disk full"), then it is certainly a bug.
529:
530: If Emacs updates the display in a way that does not correspond to what is
531: in the buffer, then it is certainly a bug. If a command seems to do the
532: wrong thing but the problem corrects itself if you type `C-l', it is a
533: case of incorrect display updating.
534:
535: Taking forever to complete a command can be a bug, but you must make
536: certain that it was really Emacs's fault. Some commands simply take a long
537: time. Type `C-g' and then `C-h l' to see whether the input Emacs
538: received was what you intended to type; if the input was such that you
539: KNOW it should have been processed quickly, report a bug. If you
540: don't know whether the command should take a long time, find out by looking
541: in the manual or by asking for assistance.
542:
543: If a command you are familiar with causes an Emacs error message in a
544: case where its usual definition ought to be reasonable, it is probably a
545: bug.
546:
547: If a command does the wrong thing, that is a bug. But be sure you know
548: for certain what it ought to have done. If you aren't familiar with the
549: command, or don't know for certain how the command is supposed to work,
550: then it might actually be working right. Rather than jumping to
551: conclusions, show the problem to someone who knows for certain.
552:
553: Finally, a command's intended definition may not be best for editing
554: with. This is a very important sort of problem, but it is also a matter of
555: judgment. Also, it is easy to come to such a conclusion out of ignorance
556: of some of the existing features. It is probably best not to complain
557: about such a problem until you have checked the documentation in the usual
558: ways, feel confident that you understand it, and know for certain that what
559: you want is not available. If you are not sure what the command is
560: supposed to do after a careful reading of the manual, check the index and
561: glossary for any terms that may be unclear. If you still do not
562: understand, this indicates a bug in the manual. The manual's job is to
563: make everything clear. It is just as important to report documentation
564: bugs as program bugs.
565:
566: If the on-line documentation string of a function or variable disagrees
567: with the manual, one of them must be wrong, so report the bug.
568:
569:
570: How to Report a Bug
571: -------------------
572:
573: When you decide that there is a bug, it is important to report it and to
574: report it in a way which is useful. What is most useful is an exact
575: description of what commands you type, starting with the shell command to
576: run Emacs, until the problem happens. Always include the version number
577: of Emacs that you are using; type `M-x emacs-version' to print this.
578:
579: The most important principle in reporting a bug is to report FACTS,
580: not hypotheses or categorizations. It is always easier to report the facts,
581: but people seem to prefer to strain to posit explanations and report
582: them instead. If the explanations are based on guesses about how Emacs is
583: implemented, they will be useless; we will have to try to figure out what
584: the facts must have been to lead to such speculations. Sometimes this is
585: impossible. But in any case, it is unnecessary work for us.
586:
587: For example, suppose that you type `C-x C-f /glorp/baz.ugh
588: RET', visiting a file which (you know) happens to be rather large,
589: and Emacs prints out `I feel pretty today'. The best way to report
590: the bug is with a sentence like the preceding one, because it gives all the
591: facts and nothing but the facts.
592:
593: Do not assume that the problem is due to the size of the file and say,
594: "When I visit a large file, Emacs prints out `I feel pretty today'."
595: This is what we mean by "guessing explanations". The problem is just as
596: likely to be due to the fact that there is a `z' in the file name. If
597: this is so, then when we got your report, we would try out the problem with
598: some "large file", probably with no `z' in its name, and not find
599: anything wrong. There is no way in the world that we could guess that we
600: should try visiting a file with a `z' in its name.
601:
602: Alternatively, the problem might be due to the fact that the file starts
603: with exactly 25 spaces. For this reason, you should make sure that you
604: inform us of the exact contents of any file that is needed to reproduce the
605: bug. What if the problem only occurs when you have typed the `C-x C-a'
606: command previously? This is why we ask you to give the exact sequence of
607: characters you typed since starting to use Emacs.
608:
609: You should not even say "visit a file" instead of `C-x C-f' unless you
610: know that it makes no difference which visiting command is used.
611: Similarly, rather than saying "if I have three characters on the line," say
612: "after I type `RET A B C RET C-p'," if that is the way you entered the
613: text.
614:
615: If you are not in Fundamental mode when the problem occurs, you should
616: say what mode you are in.
617:
618: If the manifestation of the bug is an Emacs error message, it is
619: important to report not just the text of the error message but a backtrace
620: showing how the Lisp program in Emacs arrived at the error. To make the
621: backtrace, you must execute the Lisp expression `(setq debug-on-error t)'
622: before the error happens (that is to say, you must execute that expression
623: and then make the bug happen). This causes the Lisp debugger to run
624: (*Note Lisp Debug::). The debugger's backtrace can be copied as text into
625: the bug report. This use of the debugger is possible only if you know how
626: to make the bug happen again. Do note the error message the first time the
627: bug happens, so if you can't make it happen again, you can report at least
628: that.
629:
630: Check whether any programs you have loaded into the Lisp world, including
631: your `.emacs' file, set any variables that may affect the functioning
632: of Emacs. Also, see whether the problem happens in a freshly started Emacs
633: without loading your `.emacs' file (start Emacs with the `-q' switch
634: to prevent loading the init file.) If the problem does NOT occur
635: then, it is essential that we know the contents of any programs that you
636: must load into the Lisp world in order to cause the problem to occur.
637:
638: If the problem does depend on an init file or other Lisp programs that
639: are not part of the standard Emacs system, then you should make sure it is
640: not a bug in those programs by complaining to their maintainers first.
641: After they verify that they are using Emacs in a way that is supposed to
642: work, they should report the bug.
643:
644: If you can tell us a way to cause the problem without visiting any files,
645: please do so. This makes it much easier to debug. If you do need files,
646: make sure you arrange for us to see their exact contents. For example, it
647: can often matter whether there are spaces at the ends of lines, or a
648: newline after the last line in the buffer (nothing ought to care whether
649: the last line is terminated, but tell that to the bugs).
650:
651: The easy way to record the input to Emacs precisely is to to write a
652: dribble file; execute the Lisp expression
653:
654: (open-dribble-file "~/dribble")
655:
656: using `Meta-ESC' or from the `*scratch*' buffer just after starting
657: Emacs. From then on, all Emacs input will be written in the specified
658: dribble file until the Emacs process is killed.
659:
660: For possible display bugs, it is important to report the terminal type
661: (the value of environment variable `TERM'), the complete termcap entry
662: for the terminal from `/etc/termcap' (since that file is not identical
663: on all machines), and the output that Emacs actually sent to the terminal.
664: The way to collect this output is to execute the Lisp expression
665:
666: (open-termscript "~/termscript")
667:
668: using `Meta-ESC' or from the `*scratch*' buffer just after starting Emacs.
669: From then on, all output from Emacs to the terminal will be written in the
670: specified termscript file as well, until the Emacs process is killed. If
671: the problem happens when Emacs starts up, put this expression into your
672: `.emacs' file so that the termscript file will be open when Emacs displays
673: the screen for the first time. Be warned: it is often difficult, and
674: sometimes impossible, to fix a terminal-dependent bug without access to a
675: terminal of the type that stimulates the bug.
676:
677: The address for reporting bugs is
678:
679: GNU Emacs Bugs
680: 545 Tech Sq, rm 703
681: Cambridge, MA 02139
682:
683: or send email to `mit-eddie!bug-gnu-emacs' (Usenet) or
684: `[email protected]' (Internet).
685:
686: Once again, we do not promise to fix the bug; but if the bug is serious,
687: or ugly, or easy to fix, chances are we will want to.
688:
689:
690:
691: File: emacs Node: Manifesto, Prev: Bugs, Up: Top
692:
693: The GNU Manifesto
694: *****************
695:
696:
697: What's GNU? Gnu's Not Unix!
698: ============================
699:
700: GNU, which stands for Gnu's Not Unix, is the name for the complete
701: Unix-compatible software system which I am writing so that I can give it
702: away free to everyone who can use it. Several other volunteers are helping
703: me. Contributions of time, money, programs and equipment are greatly
704: needed.
705:
706: So far we have an Emacs text editor with Lisp for writing editor commands,
707: a source level debugger, a yacc-compatible parser generator, a linker, and
708: around 35 utilities. A shell (command interpreter) is nearly completed. A
709: new portable optimizing C compiler has compiled itself and may be released
710: this year. An initial kernel exists but many more features are needed to
711: emulate Unix. When the kernel and compiler are finished, it will be
712: possible to distribute a GNU system suitable for program development. We
713: will use TeX as our text formatter, but an nroff is being worked on. We
714: will use the free, portable X window system as well. After this we will
715: add a portable Common Lisp, an Empire game, a spreadsheet, and hundreds of
716: other things, plus on-line documentation. We hope to supply, eventually,
717: everything useful that normally comes with a Unix system, and more.
718:
719: GNU will be able to run Unix programs, but will not be identical to Unix.
720: We will make all improvements that are convenient, based on our experience
721: with other operating systems. In particular, we plan to have longer
722: filenames, file version numbers, a crashproof file system, filename
723: completion perhaps, terminal-independent display support, and perhaps
724: eventually a Lisp-based window system through which several Lisp programs
725: and ordinary Unix programs can share a screen. Both C and Lisp will be
726: available as system programming languages. We will try to support UUCP,
727: MIT Chaosnet, and Internet protocols for communication.
728:
729: GNU is aimed initially at machines in the 68000/16000 class with virtual
730: memory, because they are the easiest machines to make it run on. The extra
731: effort to make it run on smaller machines will be left to someone who wants
732: to use it on them.
733:
734: To avoid horrible confusion, please pronounce the `G' in the word `GNU'
735: when it is the name of this project.
736:
737:
738: Why I Must Write GNU
739: ====================
740:
741: I consider that the golden rule requires that if I like a program I must
742: share it with other people who like it. Software sellers want to divide
743: the users and conquer them, making each user agree not to share with
744: others. I refuse to break solidarity with other users in this way. I
745: cannot in good conscience sign a nondisclosure agreement or a software
746: license agreement. For years I worked within the Artificial Intelligence
747: Lab to resist such tendencies and other inhospitalities, but eventually
748: they had gone too far: I could not remain in an institution where such
749: things are done for me against my will.
750:
751: So that I can continue to use computers without dishonor, I have decided to
752: put together a sufficient body of free software so that I will be able to
753: get along without any software that is not free. I have resigned from the
754: AI lab to deny MIT any legal excuse to prevent me from giving GNU away.
755:
756:
757: Why GNU Will Be Compatible with Unix
758: ====================================
759:
760: Unix is not my ideal system, but it is not too bad. The essential features
761: of Unix seem to be good ones, and I think I can fill in what Unix lacks
762: without spoiling them. And a system compatible with Unix would be
763: convenient for many other people to adopt.
764:
765:
766: How GNU Will Be Available
767: =========================
768:
769: GNU is not in the public domain. Everyone will be permitted to modify and
770: redistribute GNU, but no distributor will be allowed to restrict its
771: further redistribution. That is to say, proprietary modifications will not
772: be allowed. I want to make sure that all versions of GNU remain free.
773:
774:
775: Why Many Other Programmers Want to Help
776: =======================================
777:
778: I have found many other programmers who are excited about GNU and want to
779: help.
780:
781: Many programmers are unhappy about the commercialization of system
782: software. It may enable them to make more money, but it requires them to
783: feel in conflict with other programmers in general rather than feel as
784: comrades. The fundamental act of friendship among programmers is the
785: sharing of programs; marketing arrangements now typically used essentially
786: forbid programmers to treat others as friends. The purchaser of software
787: must choose between friendship and obeying the law. Naturally, many decide
788: that friendship is more important. But those who believe in law often do
789: not feel at ease with either choice. They become cynical and think that
790: programming is just a way of making money.
791:
792: By working on and using GNU rather than proprietary programs, we can be
793: hospitable to everyone and obey the law. In addition, GNU serves as an
794: example to inspire and a banner to rally others to join us in sharing.
795: This can give us a feeling of harmony which is impossible if we use
796: software that is not free. For about half the programmers I talk to, this
797: is an important happiness that money cannot replace.
798:
799:
800: How You Can Contribute
801: ======================
802:
803: I am asking computer manufacturers for donations of machines and money.
804: I'm asking individuals for donations of programs and work.
805:
806: One consequence you can expect if you donate machines is that GNU will run
807: on them at an early date. The machines should be complete, ready to use
808: systems, approved for use in a residential area, and not in need of
809: sophisticated cooling or power.
810:
811: I have found very many programmers eager to contribute part-time work for
812: GNU. For most projects, such part-time distributed work would be very hard
813: to coordinate; the independently-written parts would not work together.
814: But for the particular task of replacing Unix, this problem is absent. A
815: complete Unix system contains hundreds of utility programs, each of which
816: is documented separately. Most interface specifications are fixed by Unix
817: compatibility. If each contributor can write a compatible replacement for
818: a single Unix utility, and make it work properly in place of the original
819: on a Unix system, then these utilities will work right when put together.
820: Even allowing for Murphy to create a few unexpected problems, assembling
821: these components will be a feasible task. (The kernel will require closer
822: communication and will be worked on by a small, tight group.)
823:
824: If I get donations of money, I may be able to hire a few people full or
825: part time. The salary won't be high by programmers' standards, but I'm
826: looking for people for whom building community spirit is as important as
827: making money. I view this as a way of enabling dedicated people to devote
828: their full energies to working on GNU by sparing them the need to make a
829: living in another way.
830:
831:
832: Why All Computer Users Will Benefit
833: ===================================
834:
835: Once GNU is written, everyone will be able to obtain good system software
836: free, just like air.
837:
838: This means much more than just saving everyone the price of a Unix license.
839: It means that much wasteful duplication of system programming effort will
840: be avoided. This effort can go instead into advancing the state of the
841: art.
842:
843: Complete system sources will be available to everyone. As a result, a user
844: who needs changes in the system will always be free to make them himself,
845: or hire any available programmer or company to make them for him. Users
846: will no longer be at the mercy of one programmer or company which owns the
847: sources and is in sole position to make changes.
848:
849: Schools will be able to provide a much more educational environment by
850: encouraging all students to study and improve the system code. Harvard's
851: computer lab used to have the policy that no program could be installed on
852: the system if its sources were not on public display, and upheld it by
853: actually refusing to install certain programs. I was very much inspired by
854: this.
855:
856: Finally, the overhead of considering who owns the system software and what
857: one is or is not entitled to do with it will be lifted.
858:
859: Arrangements to make people pay for using a program, including licensing of
860: copies, always incur a tremendous cost to society through the cumbersome
861: mechanisms necessary to figure out how much (that is, which programs) a
862: person must pay for. And only a police state can force everyone to obey
863: them. Consider a space station where air must be manufactured at great
864: cost: charging each breather per liter of air may be fair, but wearing the
865: metered gas mask all day and all night is intolerable even if everyone can
866: afford to pay the air bill. And the TV cameras everywhere to see if you
867: ever take the mask off are outrageous. It's better to support the air
868: plant with a head tax and chuck the masks.
869:
870: Copying all or parts of a program is as natural to a programmer as
871: breathing, and as productive. It ought to be as free.
872:
873:
874: Some Easily Rebutted Objections to GNU's Goals
875: ==============================================
876:
877: "Nobody will use it if it is free, because that means they can't rely
878: on any support."
879:
880: "You have to charge for the program to pay for providing the
881: support."
882:
883: If people would rather pay for GNU plus service than get GNU free without
884: service, a company to provide just service to people who have obtained GNU
885: free ought to be profitable.
886:
887: We must distinguish between support in the form of real programming work
888: and mere handholding. The former is something one cannot rely on from a
889: software vendor. If your problem is not shared by enough people, the
890: vendor will tell you to get lost.
891:
892: If your business needs to be able to rely on support, the only way is to
893: have all the necessary sources and tools. Then you can hire any available
894: person to fix your problem; you are not at the mercy of any individual.
895: With Unix, the price of sources puts this out of consideration for most
896: businesses. With GNU this will be easy. It is still possible for there to
897: be no available competent person, but this problem cannot be blamed on
898: distibution arrangements. GNU does not eliminate all the world's problems,
899: only some of them.
900:
901: Meanwhile, the users who know nothing about computers need handholding:
902: doing things for them which they could easily do themselves but don't know
903: how.
904:
905: Such services could be provided by companies that sell just hand-holding
906: and repair service. If it is true that users would rather spend money and
907: get a product with service, they will also be willing to buy the service
908: having got the product free. The service companies will compete in quality
909: and price; users will not be tied to any particular one. Meanwhile, those
910: of us who don't need the service should be able to use the program without
911: paying for the service.
912:
913: "You cannot reach many people without advertising,
914: and you must charge for the program to support that."
915:
916: "It's no use advertising a program people can get free."
917:
918: There are various forms of free or very cheap publicity that can be used to
919: inform numbers of computer users about something like GNU. But it may be
920: true that one can reach more microcomputer users with advertising. If this
921: is really so, a business which advertises the service of copying and
922: mailing GNU for a fee ought to be successful enough to pay for its
923: advertising and more. This way, only the users who benefit from the
924: advertising pay for it.
925:
926: On the other hand, if many people get GNU from their friends, and such
927: companies don't succeed, this will show that advertising was not really
928: necessary to spread GNU. Why is it that free market advocates don't want
929: to let the free market decide this?
930:
931: "My company needs a proprietary operating system
932: to get a competitive edge."
933:
934: GNU will remove operating system software from the realm of competition.
935: You will not be able to get an edge in this area, but neither will your
936: competitors be able to get an edge over you. You and they will compete in
937: other areas, while benefitting mutually in this one. If your business is
938: selling an operating system, you will not like GNU, but that's tough on
939: you. If your business is something else, GNU can save you from being
940: pushed into the expensive business of selling operating systems.
941:
942: I would like to see GNU development supported by gifts from many
943: manufacturers and users, reducing the cost to each.
944:
945: "Don't programmers deserve a reward for their creativity?"
946:
947: If anything deserves a reward, it is social contribution. Creativity can
948: be a social contribution, but only in so far as society is free to use the
949: results. If programmers deserve to be rewarded for creating innovative
950: programs, by the same token they deserve to be punished if they restrict
951: the use of these programs.
952:
953: "Shouldn't a programmer be able to ask for a reward for his creativity?"
954:
955: There is nothing wrong with wanting pay for work, or seeking to maximize
956: one's income, as long as one does not use means that are destructive. But
957: the means customary in the field of software today are based on
958: destruction.
959:
960: Extracting money from users of a program by restricting their use of it is
961: destructive because the restrictions reduce the amount and the ways that
962: the program can be used. This reduces the amount of wealth that humanity
963: derives from the program. When there is a deliberate choice to restrict,
964: the harmful consequences are deliberate destruction.
965:
966: The reason a good citizen does not use such destructive means to become
967: wealthier is that, if everyone did so, we would all become poorer from the
968: mutual destructiveness. This is Kantian ethics; or, the Golden Rule.
969: Since I do not like the consequences that result if everyone hoards
970: information, I am required to consider it wrong for one to do so.
971: Specifically, the desire to be rewarded for one's creativity does not
972: justify depriving the world in general of all or part of that creativity.
973:
974: "Won't programmers starve?"
975:
976: I could answer that nobody is forced to be a programmer. Most of us cannot
977: manage to get any money for standing on the street and making faces. But
978: we are not, as a result, condemned to spend our lives standing on the
979: street making faces, and starving. We do something else.
980:
981: But that is the wrong answer because it accepts the questioner's implicit
982: assumption: that without ownership of software, programmers cannot possibly
983: be paid a cent. Supposedly it is all or nothing.
984:
985: The real reason programmers will not starve is that it will still be
986: possible for them to get paid for programming; just not paid as much as
987: now.
988:
989: Restricting copying is not the only basis for business in software. It is
990: the most common basis because it brings in the most money. If it were
991: prohibited, or rejected by the customer, software business would move to
992: other bases of organization which are now used less often. There are
993: always numerous ways to organize any kind of business.
994:
995: Probably programming will not be as lucrative on the new basis as it is
996: now. But that is not an argument against the change. It is not considered
997: an injustice that sales clerks make the salaries that they now do. If
998: programmers made the same, that would not be an injustice either. (In
999: practice they would still make considerably more than that.)
1000:
1001: "Don't people have a right to control how their creativity is used?"
1002:
1003: "Control over the use of one's ideas" really constitutes control over
1004: other people's lives; and it is usually used to make their lives more
1005: difficult.
1006:
1007: People who have studied the issue of intellectual property rights carefully
1008: (such as lawyers) say that there is no intrinsic right to intellectual
1009: property. The kinds of supposed intellectual property rights that the
1010: government recognizes were created by specific acts of legislation for
1011: specific purposes.
1012:
1013: For example, the patent system was established to encourage inventors to
1014: disclose the details of their inventions. Its purpose was to help society
1015: rather than to help inventors. At the time, the life span of 17 years for
1016: a patent was short compared with the rate of advance of the state of the
1017: art. Since patents are an issue only among manufacturers, for whom the
1018: cost and effort of a license agreement are small compared with setting up
1019: production, the patents often do not do much harm. They do not obstruct
1020: most individuals who use patented products.
1021:
1022: The idea of copyright did not exist in ancient times, when authors
1023: frequently copied other authors at length in works of non-fiction. This
1024: practice was useful, and is the only way many authors' works have survived
1025: even in part. The copyright system was created expressly for the purpose
1026: of encouraging authorship. In the domain for which it was
1027: invented---books, which could be copied economically only on a printing
1028: press---it did little harm, and did not obstruct most of the individuals
1029: who read the books.
1030:
1031: All intellectual property rights are just licenses granted by society
1032: because it was thought, rightly or wrongly, that society as a whole would
1033: benefit by granting them. But in any particular situation, we have to ask:
1034: are we really better off granting such license? What kind of act are we
1035: licensing a person to do?
1036:
1037: The case of programs today is very different from that of books a hundred
1038: years ago. The fact that the easiest way to copy a program is from one
1039: neighbor to another, the fact that a program has both source code and
1040: object code which are distinct, and the fact that a program is used rather
1041: than read and enjoyed, combine to create a situation in which a person who
1042: enforces a copyright is harming society as a whole both materially and
1043: spiritually; in which a person should not do so regardless of whether the
1044: law enables him to.
1045:
1046: "Competition makes things get done better."
1047:
1048: The paradigm of competition is a race: by rewarding the winner, we
1049: encourage everyone to run faster. When capitalism really works this way,
1050: it does a good job; but its defenders are wrong in assuming it always works
1051: this way. If the runners forget why the reward is offered and become
1052: intent on winning, no matter how, they may find other strategies---such as,
1053: attacking other runners. If the runners get into a fist fight, they will
1054: all finish late.
1055:
1056: Proprietary and secret software is the moral equivalent of runners in a
1057: fist fight. Sad to say, the only referee we've got does not seem to
1058: object to fights; he just regulates them ("For every ten yards you run,
1059: you can fire one shot"). He really ought to break them up, and penalize
1060: runners for even trying to fight.
1061:
1062: "Won't everyone stop programming without a monetary incentive?"
1063:
1064: Actually, many people will program with absolutely no monetary incentive.
1065: Programming has an irresistible fascination for some people, usually the
1066: people who are best at it. There is no shortage of professional musicians
1067: who keep at it even though they have no hope of making a living that way.
1068:
1069: But really this question, though commonly asked, is not appropriate to the
1070: situation. Pay for programmers will not disappear, only become less. So
1071: the right question is, will anyone program with a reduced monetary
1072: incentive? My experience shows that they will.
1073:
1074: For more than ten years, many of the world's best programmers worked at the
1075: Artificial Intelligence Lab for far less money than they could have had
1076: anywhere else. They got many kinds of non-monetary rewards: fame and
1077: appreciation, for example. And creativity is also fun, a reward in itself.
1078:
1079: Then most of them left when offered a chance to do the same interesting
1080: work for a lot of money.
1081:
1082: What the facts show is that people will program for reasons other than
1083: riches; but if given a chance to make a lot of money as well, they will
1084: come to expect and demand it. Low-paying organizations do poorly in
1085: competition with high-paying ones, but they do not have to do badly if the
1086: high-paying ones are banned.
1087:
1088: "We need the programmers desperately. If they demand that we
1089: stop helping our neighbors, we have to obey."
1090:
1091: You're never so desperate that you have to obey this sort of demand.
1092: Remember: millions for defense, but not a cent for tribute!
1093:
1094: "Programmers need to make a living somehow."
1095:
1096: In the short run, this is true. However, there are plenty of ways that
1097: programmers could make a living without selling the right to use a program.
1098: This way is customary now because it brings programmers and businessmen the
1099: most money, not because it is the only way to make a living. It is easy to
1100: find other ways if you want to find them. Here are a number of examples.
1101:
1102: A manufacturer introducing a new computer will pay for the porting of
1103: operating systems onto the new hardware.
1104:
1105: The sale of teaching, hand-holding and maintenance services could also
1106: employ programmers.
1107:
1108: People with new ideas could distribute programs as freeware, asking for
1109: donations from satisfied users, or selling hand-holding services. I have
1110: met people who are already working this way successfully.
1111:
1112: Users with related needs can form users' groups, and pay dues. A group
1113: would contract with programming companies to write programs that the
1114: group's members would like to use.
1115:
1116: All sorts of development can be funded with a Software Tax:
1117:
1118: Suppose everyone who buys a computer has to pay x percent of
1119: the price as a software tax. The government gives this to
1120: an agency like the NSF to spend on software development.
1121:
1122: But if the computer buyer makes a donation to software development
1123: himself, he can take a credit against the tax. He can donate to
1124: the project of his own choosing---often, chosen because he hopes to
1125: use the results when it is done. He can take a credit for any amount
1126: of donation up to the total tax he had to pay.
1127:
1128: The total tax rate could be decided by a vote of the payers of
1129: the tax, weighted according to the amount they will be taxed on.
1130:
1131: The consequences:
1132:
1133: * The computer-using community supports software development.
1134: * This community decides what level of support is needed.
1135: * Users who care which projects their share is spent on
1136: can choose this for themselves.
1137:
1138: In the long run, making programs free is a step toward the post-scarcity
1139: world, where nobody will have to work very hard just to make a living.
1140: People will be free to devote themselves to activities that are fun, such
1141: as programming, after spending the necessary ten hours a week on required
1142: tasks such as legislation, family counseling, robot repair and asteroid
1143: prospecting. There will be no need to be able to make a living from
1144: programming.
1145:
1146: We have already greatly reduced the amount of work that the whole society
1147: must do for its actual productivity, but only a little of this has
1148: translated itself into leisure for workers because much nonproductive
1149: activity is required to accompany productive activity. The main causes of
1150: this are bureaucracy and isometric struggles against competition. Free
1151: software will greatly reduce these drains in the area of software
1152: production. We must do this, in order for technical gains in productivity
1153: to translate into less work for us.
1154:
1155:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.