![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-8 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-8 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: Fortran Columns, Prev: Fortran Comments, Up: Fortran, Next: Fortran Abbrev
27:
28: Columns
29: -------
30:
31: `C-c C-r'
32: Displays a "column ruler" momentarily above the current line
33: (`fortran-column-ruler').
34: `C-c C-w'
35: Splits the current window horizontally so that it is 72 columns wide.
36: This may help you avoid going over that limit (`fortran-window-create').
37:
38: The command `C-c C-r' (`fortran-column-ruler') shows a column
39: ruler momentarily above the current line. The comment ruler is two lines
40: of text that show you the locations of columns with special significance
41: in Fortran programs. Square brackets show the limits of the columns for
42: line numbers, and curly brackets show the limits of the columns for the
43: statement body. Column numbers appear above them.
44:
45: Note that the column numbers count from zero, as always in GNU Emacs. As
46: a result, the numbers may not be those you are familiar with; but the
47: actual positions in the line are standard Fortran.
48:
49: The text used to display the column ruler is the value of the variable
50: `fortran-comment-ruler'. By changing this variable, you can change
51: the display.
52:
53: For even more help, use `C-c C-w' (`fortran-create-window'), a
54: command which splits the current window horizontally, making a window 72
55: columns wide. By editing in this window you can immediately see when you
56: make a line too wide to be correct Fortran.
57:
58:
59: File: emacs Node: Fortran Abbrev, Prev: Fortran Columns, Up: Fortran
60:
61: Fortran Keyword Abbrevs
62: -----------------------
63:
64: Fortran mode provides many built-in abbrevs for common keywords and
65: declarations. These are the same sort of abbrev that you can define
66: yourself. To use them, you must turn on Abbrev mode. *Note Abbrevs::.
67:
68: The built-in abbrevs are unusual in one way: they all start with a
69: semicolon. You cannot normally use semicolon in an abbrev, but Fortran
70: mode makes this possible by changing the syntax of semicolon to "word
71: constituent".
72:
73: For example, one built-in Fortran abbrev is `;c' for `continue'. If you
74: insert `;c' and then insert a punctuation character such as a space or a
75: newline, the `;c' will change automatically to `continue', provided Abbrev
76: mode is enabled.
77:
78: Type `;?' or `;C-h' to display a list of all the built-in
79: Fortran abbrevs and what they stand for.
80:
81:
82: File: emacs Node: Running, Prev: Programs, Up: Top, Next: Abbrevs
83:
84: Compiling and Testing Programs
85: ******************************
86:
87: The previous chapter discusses the Emacs commands that are useful for
88: making changes in programs. This chapter deals with commands that assist
89: in the larger process of developing and maintaining programs.
90:
91: * Menu:
92:
93: * Compilation:: Compiling programs in languages other than Lisp
94: (C, Pascal, etc.)
95: * Modes: Lisp Modes. Various modes for editing Lisp programs, with
96: different facilities for running the Lisp programs.
97: * Libraries: Lisp Libraries. Creating Lisp programs to run in Emacs.
98: * Interaction: Lisp Interaction. Executing Lisp in an Emacs buffer.
99: * Eval: Lisp Eval. Executing a single Lisp expression in Emacs.
100: * Debug: Lisp Debug. Debugging Lisp programs running in Emacs.
101: * External Lisp:: Communicating through Emacs with a separate Lisp.
102:
103:
104: File: emacs Node: Compilation, Prev: Running, Up: Running, Next: Lisp Modes
105:
106: Running `make', or Compilers Generally
107: ======================================
108:
109: Emacs can run compilers for noninteractive languages such as C and
110: Fortran as inferior processes, feeding the error log into an Emacs buffer.
111: It can also parse the error messages and visit the files in which errors
112: are found, moving point right to the line where the error occurred.
113:
114: `M-x compile'
115: Run a compiler asynchronously under Emacs, with error messages to
116: `*compilation*' buffer.
117: `M-x grep'
118: Run `grep' asynchronously under Emacs, with matching lines
119: listed in the buffer named `*compilation*'.
120: `M-x kill-compiler'
121: `M-x kill-grep'
122: Kill the running compilation or `grep' subprocess.
123: `C-x `'
124: Visit the locus of the next compiler error message or `grep' match.
125:
126: To run `make' or another compiler, do `M-x compile'. This command
127: reads a shell command line using the minibuffer, and then executes the
128: specified command line in an inferior shell with output going to the buffer
129: named `*compilation*'. The current buffer's default directory is used
130: as the working directory for the execution of the command; normally,
131: therefore, the makefile comes from this directory.
132:
133: When the shell command line is read, the minibuffer appears containing a
134: default command line, which is the command you used the last time you did
135: `M-x compile'. If you type just RET, the same command line is used
136: again. The first `M-x compile' provides `make -k' as the default.
137: The default is taken from the variable `compile-command'; if the
138: appropriate compilation command for a file is something other than
139: `make -k', it can be useful to have the file specify a local value for
140: `compile-command' (*Note File Variables::).
141:
142: Starting a compilation causes the buffer `*compilation*' to be
143: displayed in another window but not selected. Its mode line tells you
144: whether compilation is finished, with the word `run' or `exit' inside
145: the parentheses. You do not have to keep this buffer visible; compilation
146: continues in any case.
147:
148: To kill the compilation process, do `M-x kill-compilation'. You will see
149: that the mode line of the `*compilation*' buffer changes to say `signal'
150: instead of `run'. Starting a new compilation also kills any running
151: compilation, as only one can exist at any time. However, this requires
152: confirmation before actually killing a compilation that is running.
153:
154: To parse the compiler error messages, type `C-x `' (`next-error'). The
155: character following the `C-x' is the grave accent, not the single
156: quote. This command displays the buffer `*compilation*' in one window
157: and the buffer in which the next error occurred in another window. Point
158: in that buffer is moved to the line where the error was found. The
159: corresponding error message is scrolled to the top of the window in which
160: `*compilation*' is displayed.
161:
162: The first time `C-x `' is used after the start of a compilation, it
163: parses all the error messages, visits all the files that have error
164: messages, and makes markers pointing at the lines that the error messages
165: refer to. Then it moves to the first error message location. Subsequent
166: uses of `C-x `' advance down the data set up by the first use. When
167: the preparsed error messages are exhausted, the next `C-x `' checks for
168: any more error messages that have come in; this is useful if you start
169: editing the compiler errors while the compilation is still going on. If no
170: more error messages have come in, `C-x `' reports an error.
171:
172: `C-u C-x `' discards the preparsed error message data and parses the
173: `*compilation*' buffer over again, then displaying the first error.
174: This way, you can process the same set of errors again.
175:
176: Instead of running a compiler, you can run `grep' and see the lines
177: on which matches were found. To do this, type `M-x grep' with an argument
178: line that contains the same arguments you would give `grep' when running
179: it normally: a `grep'-style regexp (usually in singlequotes to quote
180: the shell's special characters) followed by filenames which may use wildcards.
181: The output from `grep' goes in the `*compilation*' buffer and the
182: lines that matched can be found with `C-x `' as if they were compilation
183: errors.
184:
185: Note: a shell is used to run the compile command, but the shell is told
186: that it should be noninteractive. This means in particular that the shell
187: starts up with no prompt. If you find your usual shell prompt making an
188: unsightly appearance in the `*compilation*' buffer, it means you have
189: made a mistake in your shell's init file (`.cshrc' or `.shrc' or
190: ...) by setting the prompt unconditionally. The shell init file should
191: set the prompt only if there already is a prompt. In `csh', here is
192: how to do it:
193:
194: if ($?prompt) set prompt = ...
195:
196:
197: File: emacs Node: Lisp Modes, Prev: Compilation, Up: Running, Next: Lisp Libraries
198:
199: Major Modes for Lisp
200: ====================
201:
202: Emacs has four different major modes for Lisp. They are the same in
203: terms of editing commands, but differ in the commands for executing Lisp
204: expressions.
205:
206: Emacs-Lisp mode
207: The mode for editing source files of programs to run in Emacs Lisp.
208: This mode defines `C-M-x' to evaluate the current defun.
209: *Note Lisp Libraries::.
210: Lisp Interaction mode
211: The mode for an interactive session with Emacs Lisp. It defines
212: LFD to evaluate the sexp before point and insert its value in the
213: buffer. *Note Lisp Interaction::.
214: Lisp mode
215: The mode for editing source files of programs that run in Lisps other
216: than Emacs Lisp. This mode defines `C-M-x' to send the current defun
217: to an inferior Lisp process. *Note External Lisp::.
218: Inferior Lisp mode
219: The mode for an interactive session with an inferior Lisp process.
220: This mode combines the special features of Lisp mode and Shell mode
221: (*Note Shell Mode::).
222: Scheme mode
223: Like Lisp mode but for Scheme programs.
224: Inferior Scheme mode
225: The mode for an interactive session with an inferior Scheme process.
226:
227:
228: File: emacs Node: Lisp Libraries, Prev: Lisp Modes, Up: Running, Next: Lisp Eval
229:
230: Libraries of Lisp Code for Emacs
231: ================================
232:
233: Lisp code for Emacs editing commands is stored in files whose names
234: conventionally end in `.el'. This ending tells Emacs to edit them in
235: Emacs-Lisp mode (*Note Lisp Modes::).
236:
237: * Menu:
238:
239: * Loading:: Loading libraries of Lisp code into Emacs for use.
240: * Compiling Libraries:: Compiling a library makes it load and run faster.
241: * Mocklisp:: Converting Mocklisp to Lisp so GNU Emacs can run it.
242:
243:
244: File: emacs Node: Loading, Prev: Lisp Libraries, Up: Lisp Libraries, Next: Compiling Libraries
245:
246: Loading Libraries
247: -----------------
248:
249: To execute a file of Emacs Lisp, use `M-x load-file'. This command
250: reads a file name using the minibuffer and then executes the contents of
251: that file as Lisp code. It is not necessary to visit the file first;
252: in any case, this command reads the file as found on disk, not text in
253: an Emacs buffer.
254:
255: Once a file of Lisp code is installed in the Emacs Lisp library
256: directories, users can load it using `M-x load-library'. Programs can
257: load it by calling `load-library', or with `load', a more primitive
258: function that is similar but accepts some additional arguments.
259:
260: `M-x load-library' differs from `M-x load-file' in that it
261: searches a sequence of directories and tries three file names in each
262: directory. The three names are, first, the specified name with `.elc'
263: appended; second, with `.el' appended; third, the specified
264: name alone. A `.elc' file would be the result of compiling the Lisp
265: file into byte code; it is loaded if possible in preference to the Lisp
266: file itself because the compiled file will load and run faster.
267:
268: Because the argument to `load-library' is usually not in itself
269: a valid file name, file name completion is not available. Indeed, when
270: using this command, you usually do not know exactly what file name
271: will be used.
272:
273: The sequence of directories searched by `M-x load-library' is
274: specified by the variable `load-path', a list of strings that are
275: directory names. The default value of the list contains the directory where
276: the Lisp code for Emacs itself is stored. If you have libraries of
277: your own, put them in a single directory and add that directory
278: to `load-path'. `nil' in this list stands for the current default
279: directory, but it is probably not a good idea to put `nil' in the
280: list. If you find yourself wishing that `nil' were in the list,
281: most likely what you really want to do is use `M-x load-file'
282: this once.
283:
284: Often you do not have to give any command to load a library, because the
285: commands defined in the library are set up to "autoload" that library.
286: Running any of those commands causes `load' to be called to load the
287: library; this replaces the autoload definitions with the real ones from the
288: library.
289:
290: If autoloading a file does not finish, either because of an error or
291: because of a `C-g' quit, all function definitions made by the file are
292: undone automatically. So are any calls to `provide'. As a consequence,
293: if you use one of the autoloadable commands again, the entire file will be
294: loaded a second time. This prevents problems where the command is no
295: longer autoloading but it works wrong because not all the file was loaded.
296: Function definitions are undone only for autoloading; explicit calls to
297: `load' do not undo anything if loading is not completed.
298:
299:
300: File: emacs Node: Compiling Libraries, Prev: Loading, Up: Lisp Libraries, Next: Mocklisp
301:
302: Compiling Libraries
303: -------------------
304:
305: Emacs Lisp code can be compiled into byte-code which loads faster,
306: takes up less space when loaded, and executes faster.
307:
308: The way to make a byte-code compiled file from an Emacs-Lisp source file
309: is with `M-x byte-compile-file'. The default argument for this
310: function is the file visited in the current buffer. It reads the specified
311: file, compiles it into byte code, and writes an output file whose name is
312: made by appending `c' to the input file name. Thus, the file
313: `rmail.el' would be compiled into `rmail.elc'.
314:
315: To recompile the changed Lisp files in a directory, use `M-x
316: byte-recompile-directory'. Specify just the directory name as an argument.
317: Each `.el' file that has been byte-compiled before is byte-compiled
318: again if it has changed since the previous compilation. A numeric argument
319: to this command tells it to offer to compile each `.el' file that has
320: not already been compiled. You must answer `y' or `n' to each
321: offer.
322:
323: Emacs can be invoked noninteractively from the shell to do byte compilation
324: with the aid of the function `batch-byte-compile'. In this case,
325: the files to be compiled are specified with command-line arguments.
326: Use a shell command of the form
327:
328: emacs -batch -f batch-byte-compile FILES...
329:
330: Directory names may also be given as arguments;
331: `byte-recompile-directory' is invoked (in effect) on each such directory.
332: `batch-byte-compile' uses all the remaining command-line arguments as
333: file or directory names, then kills the Emacs process.
334:
335: `M-x disassemble' explains the result of byte compilation. Its
336: argument is a function name. It displays the byte-compiled code in a help
337: window in symbolic form, one instruction per line. If the instruction
338: refers to a variable or constant, that is shown too.
339:
340:
341: File: emacs Node: Mocklisp, Prev: Compiling Libraries, Up: Lisp Libraries
342:
343: Converting Mocklisp to Lisp
344: ---------------------------
345:
346: GNU Emacs can run Mocklisp files by converting them to Emacs Lisp first.
347: To convert a Mocklisp file, visit it and then type `M-x
348: convert-mocklisp-buffer'. Then save the resulting buffer of Lisp file in a
349: file whose name ends in `.el' and use the new file as a Lisp library.
350:
351: It does not currently work to byte-compile converted Mocklisp code.
352: This is because converted Mocklisp code uses some special Lisp features
353: to deal with Mocklisp's incompatible ideas of how arguments are evaluated
354: and which values signify "true" or "false".
355:
356:
357: File: emacs Node: Lisp Eval, Prev: Lisp Libraries, Up: Running, Next: Lisp Debug
358:
359: Evaluating Emacs-Lisp Expressions
360: =================================
361:
362: Lisp programs intended to be run in Emacs should be edited in Emacs-Lisp
363: mode; this will happen automatically for file names ending in `.el'.
364: By contrast, Lisp mode itself is used for editing Lisp programs intended
365: for other Lisp systems. Emacs-Lisp mode can be selected with the command
366: `M-x emacs-lisp-mode'.
367:
368: For testing of Lisp programs to run in Emacs, it is useful to be able to
369: evaluate part of the program as it is found in the Emacs buffer. For
370: example, after changing the text of a Lisp function definition, evaluating
371: the definition installs the change for future calls to the function.
372: Evaluation of Lisp expressions is also useful in any kind of editing task
373: for invoking noninteractive functions (functions that are not commands).
374:
375: `M-ESC'
376: Read a Lisp expression in the minibuffer, evaluate it, and print the
377: value in the minibuffer (`eval-expression').
378: `C-x C-e'
379: Evaluate the Lisp expression before point, and print the value in the
380: minibuffer (`eval-last-sexp').
381: `C-M-x'
382: Evaluate the defun containing or after point, and print the value in
383: the minibuffer (`eval-defun').
384: `M-x eval-region'
385: Evaluate all the Lisp expressions in the region.
386: `M-x eval-current-buffer'
387: Evaluate all the Lisp expressions in the buffer.
388:
389: `M-ESC' (`eval-expression') is the most basic command for evaluating
390: a Lisp expression interactively. It reads the expression using the
391: minibuffer, so you can execute any expression on a buffer regardless of
392: what the buffer contains. When the expression is evaluated, the current
393: buffer is once again the buffer that was current when `M-ESC' was
394: typed.
395:
396: `M-ESC' can easily confuse users who do not understand it, especially on
397: keyboards with autorepeat where it can result from holding down the ESC key
398: for too long. Therefore, `eval-expression' is normally a disabled command.
399: Attempting to use this command asks for confirmation and gives you the
400: option of enabling it; once you enable the command, confirmation will no
401: longer be required for it. *Note Disabling::.
402:
403: In Emacs-Lisp mode, the key `C-M-x' is bound to the function `eval-defun',
404: which parses the defun containing or following point as a Lisp expression
405: and evaluates it. The value is printed in the echo area. This command is
406: convenient for installing in the Lisp environment changes that you have
407: just made in the text of a function definition.
408:
409: The command `C-x C-e' (`eval-last-sexp') performs a similar job
410: but is available in all major modes, not just Emacs-Lisp mode. It finds
411: the sexp before point, reads it as a Lisp expression, evaluates it, and
412: prints the value in the echo area. It is sometimes useful to type in an
413: expression and then, with point still after it, type `C-x C-e'.
414:
415: If `C-M-x' or `C-x C-e' is given a numeric argument, it prints the value
416: by insertion into the current buffer at point, rather than in the echo
417: area. The argument value does not matter.
418:
419: The most general command for evaluating Lisp expressions from a buffer is
420: `eval-region'. `M-x eval-region' parses the text of the region as one or
421: more Lisp expressions, evaluating them one by one. `M-x eval-current-buffer'
422: is similar but evaluates the entire buffer. This is a reasonable way to
423: install the contents of a file of Lisp code that you are just ready to
424: test. After finding and fixing a bug, use `C-M-x' on each function
425: that you change, to keep the Lisp world in step with the source file.
426:
427:
428: File: emacs Node: Lisp Debug, Prev: Lisp Eval, Up: Running, Next: Lisp Interaction
429:
430: The Emacs-Lisp Debugger
431: =======================
432:
433: GNU Emacs contains a debugger for Lisp programs executing inside it.
434: This debugger is normally not used; many commands frequently get Lisp
435: errors when invoked in inappropriate contexts (such as `C-f' at the end of
436: the buffer) and it would be very unpleasant for that to enter a special
437: debugging mode. When you want to make Lisp errors invoke the debugger, you
438: must set the variable `debug-on-error' to non-`nil'. Quitting with `C-g'
439: is not considered an error, and `debug-on-error' has no effect on the
440: handling of `C-g'. However, if you set `debug-on-quit' non-`nil', `C-g'
441: will invoke the debugger. This can be useful for debugging an infinite
442: loop; type `C-g' once the loop has had time to reach its steady state.
443: `debug-on-quit' has no effect on errors.
444:
445: You can also cause the debugger to be entered when a specified function
446: is called, or at a particular place in Lisp code. Use `M-x debug-on-entry'
447: with argument FUN-NAME to cause function FUN-NAME to enter the debugger as
448: soon as it is called. Use `M-x cancel-debug-on-entry' to make the function
449: stop entering the debugger when called. (Redefining the function also does
450: this.) To enter the debugger from some other place in Lisp code, you must
451: insert the expression `(debug)' there and install the changed code with
452: `C-M-x'. *Note Lisp Eval::.
453:
454: When the debugger is entered, it displays the previously selected buffer
455: in one window and a buffer named `*Backtrace*' in another window. The
456: backtrace buffer contains one line for each level of Lisp function
457: execution currently going on. At the beginning of this buffer is a message
458: describing the reason that the debugger was invoked (such as, what error
459: message if it was invoked due to an error).
460:
461: The backtrace buffer is read-only, and is in a special major mode,
462: Backtrace mode, in which letters are defined as debugger commands. The
463: usual Emacs editing commands are available; you can switch windows to
464: examine the buffer that was being edited at the time of the error, and you
465: can also switch buffers, visit files, and do any other sort of editing.
466: However, the debugger is a recursive editing level (*Note Recursive Edit::)
467: and it is wise to go back to the backtrace buffer and exit the debugger
468: officially when you don't want to use it any more. Exiting the debugger
469: kills the backtrace buffer.
470:
471: The contents of the backtrace buffer show you the functions that are
472: executing and the arguments that were given to them. It has the additional
473: purpose of allowing you to specify a stack frame by moving point to the line
474: describing that frame. The frame whose line point is on is considered the
475: "current frame". Some of the debugger commands operate on the current
476: frame. Debugger commands are mainly used for stepping through code an
477: expression at a time. Here is a list of them.
478:
479: `c'
480: Exit the debugger and continue execution. In most cases, execution of
481: the program continues as if the debugger had never been entered (aside
482: from the effect of any variables or data structures you may have
483: changed while inside the debugger). This includes entry to the
484: debugger due to function entry or exit, explicit invocation, quitting
485: or certain errors. Most errors cannot be continued; trying to
486: continue one of them causes the same error to occur again.
487: `d'
488: Continue execution, but enter the debugger the next time a Lisp
489: function is called. This allows you to step through the
490: subexpressions of an expression, seeing what values the subexpressions
491: compute and what else they do.
492:
493: The stack frame made for the function call which enters the debugger
494: in this way will be flagged automatically for the debugger to be called
495: when the frame is exited. You can use the `u' command to cancel
496: this flag.
497: `b'
498: Set up to enter the debugger when the current frame is exited. Frames
499: that will invoke the debugger on exit are flagged with stars.
500: `u'
501: Don't enter the debugger when the current frame is exited. This
502: cancels a `b' command on that frame.
503: `e'
504: Read a Lisp expression in the minibuffer, evaluate it, and print the
505: value in the echo area. This is the same as the command `M-ESC',
506: except that `e' is not normally disabled like `M-ESC'.
507: `q'
508: Terminate the program being debugged; return to top-level Emacs
509: command execution.
510:
511: If the debugger was entered due to a `C-g' but you really want
512: to quit, not to debug, use the `q' command.
513: `r'
514: Return a value from the debugger. The value is computed by reading an
515: expression with the minibuffer and evaluating it.
516:
517: The value returned by the debugger makes a difference when the debugger
518: was invoked due to exit from a Lisp call frame (as requested with `b');
519: then the value specified in the `r' command is used as the value of
520: that frame.
521:
522: The debugger's return value also matters with many errors. For example,
523: `wrong-type-argument' errors will use the debugger's return value
524: instead of the invalid argument; `no-catch' errors will use the
525: debugger value as a throw tag instead of the tag that was not found.
526: If an error was signaled by calling the Lisp function `signal',
527: the debugger's return value is returned as the value of `signal'.
528:
529:
530: File: emacs Node: Lisp Interaction, Prev: Lisp Debug, Up: Running, Next: External Lisp
531:
532: Lisp Interaction Buffers
533: ========================
534:
535: The buffer `*scratch*' which is selected when Emacs starts up is
536: provided for evaluating Lisp expressions interactively inside Emacs. Both
537: the expressions you evaluate and their output goes in the buffer.
538:
539: The `*scratch*' buffer's major mode is Lisp Interaction mode, which
540: is the same as Emacs-Lisp mode except for one command, LFD. In
541: Emacs-Lisp mode, LFD is an indentation command, as usual. In Lisp
542: Interaction mode, LFD is bound to `eval-print-last-sexp'. This
543: function reads the Lisp expression before point, evaluates it, and inserts
544: the value in printed representation before point.
545:
546: Thus, the way to use the `*scratch*' buffer is to insert Lisp expressions
547: at the end, ending each one with LFD so that it will be evaluated.
548: The result is a complete typescript of the expressions you have evaluated
549: and their values.
550:
551: The rationale for this feature is that Emacs must have a buffer when it
552: starts up, but that buffer is not useful for editing files since a new
553: buffer is made for every file that you visit. The Lisp interpreter
554: typescript is the most useful thing I can think of for the initial buffer
555: to do. `M-x lisp-interaction-mode' will put any buffer in Lisp
556: Interaction mode.
557:
558:
559: File: emacs Node: External Lisp, Prev: Lisp Interaction, Up: Running
560:
561: Running an External Lisp
562: ========================
563:
564: Emacs has facilities for running programs in other Lisp systems. You can
565: run a Lisp process as an inferior of Emacs, and pass expressions to it to
566: be evaluated. You can also pass changed function definitions directly from
567: the Emacs buffers in which you edit the Lisp programs to the inferior Lisp
568: process.
569:
570: To run an inferior Lisp process, type `M-x run-lisp'. This runs the
571: program named `lisp', the same program you would run by typing
572: `lisp' as a shell command, with both input and output going through an
573: Emacs buffer named `*lisp*'. That is to say, any "terminal output"
574: from Lisp will go into the buffer, advancing point, and any "terminal
575: input" for Lisp comes from text in the buffer. To give input to Lisp, go
576: to the end of the buffer and type the input, terminated by RET. The
577: `*lisp*' buffer is in Inferior Lisp mode, a mode which has all the
578: special characteristics of Lisp mode and Shell mode (*Note Shell Mode::).
579:
580: For the source files of programs to run in external Lisps, use Lisp mode.
581: This mode can be selected with `M-x lisp-mode', and is used automatically
582: for files whose names end in `.l' or `.lisp', as most Lisp
583: systems usually expect.
584:
585: When you edit a function in a Lisp program you are running, the easiest
586: way to send the changed definition to the inferior Lisp process is the key
587: `C-M-x'. In Lisp mode, this runs the function `lisp-send-defun',
588: which finds the defun around or following point and sends it as input to
589: the Lisp process. (Emacs can send input to any inferior process regardless
590: of what buffer is current.)
591:
592: Contrast the meanings of `C-M-x' in Lisp mode (for editing programs
593: to be run in another Lisp system) and Emacs-Lisp mode (for editing Lisp
594: programs to be run in Emacs): in both modes it has the effect of installing
595: the function definition that point is in, but the way of doing so is
596: different according to where the relevant Lisp environment is found.
597: *Note Lisp Modes::.
598:
599:
600: File: emacs Node: Abbrevs, Prev: Running, Up: Top, Next: Picture
601:
602: Abbrevs
603: *******
604:
605: An "abbrev" is a word which "expands", if you insert it, into some
606: different text. Abbrevs are defined by the user to expand in specific
607: ways. For example, you might define `foo' as an abbrev expanding to
608: `find outer otter'. With this abbrev defined, you would be able to
609: get `find outer otter ' into the buffer by typing `f o o SPC'.
610:
611: Abbrevs expand only when Abbrev mode (a minor mode) is enabled.
612: Disabling Abbrev mode does not cause abbrev definitions to be forgotten,
613: but they do not expand until Abbrev mode is enabled again. The command
614: `M-x abbrev-mode' toggles Abbrev mode; with a numeric argument, it
615: turns Abbrev mode on if the argument is positive, off otherwise.
616: *Note Minor Modes::. `abbrev-mode' is also a variable; Abbrev mode is
617: on when the variable is non-`nil'. The variable `abbrev-mode'
618: automatically becomes local to the current buffer when it is set.
619:
620: Abbrev definitions can be "mode-specific"---active only in one major
621: mode. Abbrevs can also have "global" definitions that are active in
622: all major modes. The same abbrev can have a global definition and various
623: mode-specific definitions for different major modes. A mode specific
624: definition for the current major mode overrides a global definition.
625:
626: Abbrevs can be defined interactively during the editing session. Lists
627: of abbrev definitions can also be saved in files and reloaded in later
628: sessions. Some users keep extensive lists of abbrevs that they load in
629: every session.
630:
631: A second kind of abbreviation facility is called the "dynamic
632: expansion". Dynamic abbrev expansion happens only when you give an
633: explicit command and the result of the expansion depends only on the
634: current contents of the buffer. *Note Dynamic Abbrevs::.
635:
636: * Menu:
637:
638: * Defining Abbrevs:: Defining an abbrev, so it will expand when typed.
639: * Expanding Abbrevs:: Controlling expansion: prefixes, canceling expansion.
640: * Editing Abbrevs:: Viewing or editing the entire list of defined abbrevs.
641: * Saving Abbrevs:: Saving the entire list of abbrevs for another session.
642: * Dynamic Abbrevs:: Abbreviations for words already in the buffer.
643:
644:
645: File: emacs Node: Defining Abbrevs, Prev: Abbrevs, Up: Abbrevs, Next: Expanding Abbrevs
646:
647: Defining Abbrevs
648: ================
649:
650: `C-x +'
651: Define an abbrev to expand into some text before point
652: (`add-global-abbrev').
653: `C-x C-a'
654: Similar, but define an abbrev available only in the current major mode
655: (`add-mode-abbrev').
656: `C-x -'
657: Define a word in the buffer as an abbrev (`inverse-add-global-abbrev').
658: `C-x C-h'
659: Define a word in the buffer as a mode-specific abbrev
660: (`inverse-add-mode-abbrev').
661: `M-x kill-all-abbrevs'
662: After this command, there are no abbrev definitions in effect.
663:
664: The usual way to define an abbrev is to enter the text you want the
665: abbrev to expand to, position point after it, and type `C-x +'
666: (`add-global-abbrev'). This reads the abbrev itself using the
667: minibuffer, and then defines it as an abbrev for one or more words before
668: point. Use a numeric argument to say how many words before point should be
669: taken as the expansion. For example, to define the abbrev `foo' as
670: mentioned above, insert the text `find outer otter' and then type
671: `C-u 3 C-x + f o o RET'.
672:
673: An argument of zero to `C-x +' means to use the contents of the
674: region as the expansion of the abbrev being defined.
675:
676: The command `C-x C-a' (`add-mode-abbrev') is similar, but
677: defines a mode-specific abbrev. Mode specific abbrevs are active only in a
678: particular major mode. `C-x C-a' defines an abbrev for the major mode
679: in effect at the time `C-x C-a' is typed. The arguments work the same
680: as for `C-x +'.
681:
682: If the text of the abbrev you want is already in the buffer instead of
683: the expansion, use command `C-x -' (`inverse-add-global-abbrev') instead of
684: `C-x +', or use `C-x C-h' (`inverse-add-mode-abbrev') instead of `C-x C-a'.
685: These commands are called "inverse" because they invert the meaning of the
686: argument found in the buffer and the argument read using the minibuffer.
687:
688: To change the definition of an abbrev, just add the new definition. You
689: will be asked to confirm if the abbrev has a prior definition. To remove
690: an abbrev definition, give a negative argument to `C-x +' or `C-x
691: C-a'. You must choose the command to specify whether to kill a global
692: definition or a mode-specific definition for the current mode, since those
693: two definitions are independent for one abbrev.
694:
695: `M-x kill-all-abbrevs' removes all the abbrev definitions there are.
696:
697:
698: File: emacs Node: Expanding Abbrevs, Prev: Defining Abbrevs, Up: Abbrevs, Next: Editing Abbrevs
699:
700: Controlling Abbrev Expansion
701: ============================
702:
703: An abbrev expands whenever it is present in the buffer just before point
704: and a self-inserting punctuation character (SPC, comma, etc.) is
705: typed. Most often the way an abbrev is used is to insert the abbrev
706: followed by punctuation.
707:
708: Abbrev expansion preserves case; thus, `foo' expands into `find outer
709: otter'; `Foo' into `Find outer otter', and `FOO' into `FIND OUTER OTTER' or
710: `Find Outer Otter' according to the variable `abbrev-all-caps' (a non-`nil'
711: value chooses the first of the two expansions).
712:
713: These two commands are used to control abbrev expansion:
714:
715: `M-''
716: Separate a prefix from a following abbrev to be expanded
717: (`abbrev-prefix-mark').
718: `C-x ''
719: Expand the abbrev before point (`expand-abbrev').
720: This is effective even when Abbrev mode is not enabled.
721: `M-x unexpand-abbrev'
722: Undo last abbrev expansion.
723: `M-x expand-region-abbrevs'
724: Expand some or all abbrevs found in the region.
725:
726: You may wish to expand an abbrev with a prefix attached; for example, if
727: `cnst' expands into `construction', you might want to use it to enter
728: `reconstruction'. It does not work to type `recnst', because that is not
729: necessarily a defined abbrev. What does work is to use the command `M-''
730: (`abbrev-prefix-mark') in between the prefix `re' and the abbrev `cnst'.
731: First, insert `re'. Then type `M-''; this inserts a minus sign in the
732: buffer to indicate that it has done its work. Then insert the abbrev
733: `cnst'; the buffer now contains `re-cnst'. Now insert a punctuation
734: character to expand the abbrev `cnst' into `construction'. The minus sign
735: is deleted at this point, because `M-'' left word for this to be done. The
736: resulting text is the desired `reconstruction'.
737:
738: If you actually want the text of the abbrev in the buffer, rather than
739: its expansion, you can accomplish this by inserting the following
740: punctuation with `C-q'. Thus, `foo C-q -' leaves `foo-' in the
741: buffer.
742:
743: If you expand an abbrev by mistake, you can undo the expansion (replace
744: the expansion by the original abbrev text) with `M-x unexpand-abbrev'.
745: `C-_' (`undo') can also be used to undo the expansion; but first
746: it will undo the insertion of the following punctuation character!
747:
748: `M-x expand-region-abbrevs' searches through the region for defined
749: abbrevs, and for each one found offers to replace it with its expansion.
750: This command is useful if you have typed in text using abbrevs but forgot
751: to turn on Abbrev mode first. It may also be useful together with a
752: special set of abbrev definitions for making several global replacements at
753: once. This command is effective even if Abbrev mode is not enabled.
754:
755:
756: File: emacs Node: Editing Abbrevs, Prev: Expanding Abbrevs, Up: Abbrevs, Next: Saving Abbrevs
757:
758: Examining and Editing Abbrevs
759: =============================
760:
761: `M-x list-abbrevs'
762: Print a list of all abbrev definitions.
763: `M-x edit-abbrevs'
764: Edit a list of abbrevs; you can add, alter or remove definitions.
765:
766: The output from `M-x list-abbrevs' looks like this:
767:
768: (lisp-mode-abbrev-table)
769: "dk" 0 "define-key"
770: (global-abbrev-table)
771: "dfn" 0 "definition"
772:
773: (Some blank lines of no semantic significance, and some other abbrev
774: tables, have been omitted.)
775:
776: A line containing a name in parentheses is the header for abbrevs in a
777: particular abbrev table; `global-abbrev-table' contains all the global
778: abbrevs, and the other abbrev tables that are named after major modes
779: contain the mode-specific abbrevs.
780:
781: Within each abbrev table, each nonblank line defines one abbrev. The
782: word at the beginning is the abbrev. The number that appears is the number
783: of times the abbrev has been expanded. Emacs keeps track of this to help
784: you see which abbrevs you actually use, in case you decide to eliminate
785: those that you don't use often. The string at the end of the line is the
786: expansion.
787:
788: `M-x edit-abbrevs' allows you to add, change or kill abbrev
789: definitions by editing a list of them in an Emacs buffer. The list has the
790: same format described above. The buffer of abbrevs is called `*Abbrevs*',
791: and is in Edit-Abbrevs mode. This mode redefines the key `C-c C-c' to
792: install the abbrev definitions as specified in the buffer. The command
793: that does this is `edit-abbrevs-redefine'. Any abbrevs not described
794: in the buffer are eliminated when this is done.
795:
796: `edit-abbrevs' is actually the same as `list-abbrevs' except
797: that it selects the buffer `*Abbrevs*' whereas `list-abbrevs'
798: merely displays it in another window.
799:
800:
801: File: emacs Node: Saving Abbrevs, Prev: Editing Abbrevs, Up: Abbrevs, Next: Dynamic Abbrevs
802:
803: Saving Abbrevs
804: ==============
805:
806: These commands allow you to keep abbrev definitions between editing
807: sessions.
808:
809: `M-x write-abbrev-file'
810: Write a file describing all defined abbrevs.
811: `M-x read-abbrev-file'
812: Read such a file and define abbrevs as specified there.
813: `M-x quietly-read-abbrev-file'
814: Similar but do not display a message about what is going on.
815: `M-x define-abbrevs'
816: Define abbrevs from buffer.
817: `M-x insert-abbrevs'
818: Insert all abbrevs and their expansions into the buffer.
819:
820: `M-x write-abbrev-file' reads a file name using the minibuffer and
821: writes a description of all current abbrev definitions into that file. The
822: text stored in the file looks like the output of `M-x list-abbrevs'.
823: This is used to save abbrev definitions for use in a later session.
824:
825: `M-x read-abbrev-file' reads a file name using the minibuffer and
826: reads the file, defining abbrevs according to the contents of the file.
827: `M-x quietly-read-abbrev-file' is the same except that it does not
828: display a message in the echo area saying that it is doing its work; it
829: is actually useful primarily in the `.emacs' file. If an empty
830: argument is given to either of these functions, the file name used is the
831: value of the variable `abbrev-file-name', which is by default
832: `"~/.abbrev_defs"'.
833:
834: Emacs will offer to save abbrevs automatically if you have changed any of
835: them, whenever it offers to save all files (for `C-x s' or `C-x
836: C-c'). This feature can be inhibited by setting the variable
837: `save-abbrevs' to `nil'.
838:
839: The commands `M-x insert-abbrevs' and `M-x define-abbrevs' are similar to
840: the previous commands but work on text in an Emacs buffer. `M-x
841: insert-abbrevs' inserts text into the current buffer before point,
842: describing all current abbrev definitions; `M-x define-abbrevs' parses the
843: entire current buffer and defines abbrevs accordingly.
844:
845:
846: File: emacs Node: Dynamic Abbrevs, Prev: Saving Abbrevs, Up: Abbrevs
847:
848: Dynamic Abbrev Expansion
849: ========================
850:
851: The abbrev facility described above operates automatically as you insert
852: text, but all abbrevs must be defined explicitly. By contrast,
853: "dynamic abbrevs" allow the meanings of abbrevs to be determined
854: automatically from the contents of the buffer, but dynamic abbrev expansion
855: happens only when you request it explicitly.
856:
857: `M-/'
858: Expand the word in the buffer before point as a "dynamic abbrev",
859: by searching in the buffer for words starting with that abbreviation
860: (`dabbrev-expand').
861:
862: For example, if the buffer contains `does this follow ' and you type
863: `f o M-/', the effect is to insert `follow' because that is the
864: last word in the buffer that starts with `fo'. A numeric argument to
865: `M-/' says to take the second, third, etc. distinct expansion found
866: looking backward from point. Repeating `M-/' searches for an
867: alternative expansion by looking farther back. After the entire buffer
868: before point has been considered, the buffer after point is searched.
869:
870: Dynamic abbrev expansion is completely independent of Abbrev mode; the
871: expansion of a word with `M-/' is completely independent of whether it
872: has a definition as an ordinary abbrev.
873:
874:
875: File: emacs Node: Picture, Prev: Abbrevs, Up: Top, Next: Sending Mail
876:
877: Editing Pictures
878: ****************
879:
880: If you want to create a picture made out of text characters (for example,
881: a picture of the division of a register into fields, as a comment in a
882: program), use the command `edit-picture' to enter Picture mode.
883:
884: In Picture mode, editing is based on the "quarter-plane" model of
885: text, according to which the text characters lie studded on an area that
886: stretches infinitely far to the right and downward. The concept of the end
887: of a line does not exist in this model; the most you can say is where the
888: last nonblank character on the line is found.
889:
890: Of course, Emacs really always considers text as a sequence of
891: characters, and lines really do have ends. But in Picture mode most
892: frequently-used keys are rebound to commands that simulate the
893: quarter-plane model of text. They do this by inserting spaces or by
894: converting tabs to spaces.
895:
896: Most of the basic editing commands of Emacs are redefined by Picture mode
897: to do essentially the same thing but in a quarter-plane way. In addition,
898: Picture mode defines various keys starting with the `C-c' prefix to
899: run special picture editing commands.
900:
901: One of these keys, `C-c C-c', is pretty important. Often a picture
902: is part of a larger file that is usually edited in some other major mode.
903: `M-x edit-picture' records the name of the previous major mode, and
904: then you can use the `C-c C-c' command (`picture-mode-exit') to
905: restore that mode. `C-c C-c' also deletes spaces from the ends of
906: lines, unless given a numeric argument.
907:
908: The commands used in Picture mode all work in other modes (provided the
909: `picture' library is loaded), but are not bound to keys except in
910: Picture mode. Note that the descriptions below talk of moving "one
911: column" and so on, but all the picture mode commands handle numeric
912: arguments as their normal equivalents do.
913:
914: Turning on Picture mode calls the value of the variable `picture-mode-hook'
915: as a function, with no arguments, if that value exists and is non-`nil'.
916:
917: * Menu:
918:
919: * Basic Picture:: Basic concepts and simple commands of Picture Mode.
920: * Insert in Picture:: Controlling direction of cursor motion
921: after "self-inserting" characters.
922: * Tabs in Picture:: Various features for tab stops and indentation.
923: * Rectangles in Picture:: Clearing and superimposing rectangles.
924:
925:
926: File: emacs Node: Basic Picture, Prev: Picture, Up: Picture, Next: Insert in Picture
927:
928: Basic Editing in Picture Mode
929: =============================
930:
931: Most keys do the same thing in Picture mode that they usually do, but do
932: it in a quarter-plane style. For example, `C-f' is rebound to run
933: `picture-forward-column', which is defined to move point one column to the
934: right, by inserting a space if necessary, so that the actual end of the
935: line makes no difference. `C-b' is rebound to run
936: `picture-backward-column', which always moves point left one column,
937: converting a tab to multiple spaces if necessary. `C-n' and `C-p' are
938: rebound to run `picture-move-down' and `picture-move-up', which can either
939: insert spaces or convert tabs as necessary to make sure that point stays in
940: exactly the same column. `C-e' runs `picture-end-of-line', which moves to
941: after the last nonblank character on the line. There is no need to change
942: `C-a', as the choice of screen model does not affect beginnings of lines.
943:
944: Insertion of text is adapted to the quarter-plane screen model through
945: the use of Overwrite mode (*Note Minor Modes::). Self-inserting characters
946: replace existing text, column by column, rather than pushing existing text
947: to the right. RET runs `picture-newline', which just moves to
948: the beginning of the following line so that new text will replace that
949: line.
950:
951: Deletion and killing of text are replaced with erasure. DEL
952: (`picture-backward-clear-column') replaces the preceding character with a
953: space rather than removing it. `C-d' (`picture-clear-column') does the
954: same thing in a forward direction. `C-k' (`picture-clear-line') really
955: kills the contents of lines, but does not ever remove the newlines from the
956: buffer.
957:
958: To do actual insertion, you must use special commands. `C-o'
959: (`picture-open-line') still creates a blank line, but does so after the
960: current line; it never splits a line. `C-M-o', `split-line', makes sense
961: in Picture mode, so it is not changed. LFD (`picture-duplicate-line')
962: inserts below the current line another line with the same contents.
963:
964: Real deletion can be done with `C-w', or with `C-c C-d' (which is
965: defined as `delete-char', as `C-d' is in other modes), or with one
966: of the picture rectangle commands (*Note Rectangles in Picture::).
967:
968:
969: File: emacs Node: Insert in Picture, Prev: Basic Picture, Up: Picture, Next: Tabs in Picture
970:
971: Controlling Motion after Insert
972: ===============================
973:
974: Since "self-inserting" characters in Picture mode just overwrite and
975: move point, there is no essential restriction on how point should be moved.
976: Normally point moves right, but you can specify any of the eight orthogonal
977: or diagonal directions for motion after a "self-inserting" character.
978: This is useful for drawing lines in the buffer.
979:
980: `C-c <'
981: Move left after insertion (`picture-movement-left').
982: `C-c >'
983: Move right after insertion (`picture-movement-right').
984: `C-c ^'
985: Move up after insertion (`picture-movement-up').
986: `C-c .'
987: Move down after insertion (`picture-movement-down').
988: `C-c `'
989: Move up and left ("northwest") after insertion (`picture-movement-nw').
990: `C-c ''
991: Move up and right ("northeast") after insertion
992: (`picture-movement-ne').
993: `C-c /'
994: Move down and left ("southwest") after insertion
995: (`picture-movement-sw').
996: `C-c \'
997: Move down and right ("southeast") after insertion
998: (`picture-movement-se').
999:
1000: Two motion commands move based on the current Picture insertion
1001: direction. The command `C-c C-f' (`picture-motion') moves in the
1002: same direction as motion after "insertion" currently does, while `C-c
1003: C-b' (`picture-motion-reverse') moves in the opposite direction.
1004:
1005:
1006: File: emacs Node: Tabs in Picture, Prev: Insert in Picture, Up: Picture, Next: Rectangles in Picture
1007:
1008: Picture Mode Tabs
1009: =================
1010:
1011: Two kinds of tab-like action are provided in Picture mode. Context-based
1012: tabbing is done with `M-TAB' (`picture-tab-search'). With no argument, it
1013: moves to a point underneath the next "interesting" character that follows
1014: whitespace in the previous nonblank line. "Next" here means "appearing at
1015: a horizontal position greater than the one point starts out at". With an
1016: argument, as in `C-u M-TAB', this command moves to the next such
1017: interesting character in the current line. `M-TAB' does not change the
1018: text; it only moves point. "Interesting" characters are defined by the
1019: variable `picture-tab-chars', which contains a string whose characters are
1020: all considered interesting. Its default value is `"!-~"'.
1021:
1022: TAB itself runs `picture-tab', which operates based on the
1023: current tab stop settings; it is the Picture mode equivalent of
1024: `tab-to-tab-stop'. Normally it just moves point, but with a numeric
1025: argument it clears the text that it moves over.
1026:
1027: The context-based and tab-stop-based forms of tabbing are brought
1028: together by the command `C-c TAB', `picture-set-tab-stops'.
1029: This command sets the tab stops to the positions which `M-TAB'
1030: would consider significant in the current line. The use of this command,
1031: together with TAB, can get the effect of context-based tabbing. But
1032: `M-TAB' is more convenient in the cases where it is sufficient.
1033:
1034:
1035: File: emacs Node: Rectangles in Picture, Prev: Tabs in Picture, Up: Picture
1036:
1037: Picture Mode Rectangle Commands
1038: ===============================
1039:
1040: Picture mode defines commands for working on rectangular pieces of the
1041: text in ways that fit with the quarter-plane model. The standard rectangle
1042: commands may also be useful (*Note Rectangles::).
1043:
1044: `C-c C-k'
1045: Clear out the region-rectangle (`picture-clear-rectangle'). With
1046: argument, kill it.
1047: `C-c C-w R'
1048: Similar but save rectangle contents in register R first
1049: (`picture-clear-rectangle-to-register').
1050: `C-c C-y'
1051: Copy last killed rectangle into the buffer by overwriting, with upper
1052: left corner at point (`picture-yank-rectangle'). With argument,
1053: insert instead.
1054: `C-c C-x R'
1055: Similar, but use the rectangle in register R
1056: (`picture-yank-rectangle-from-register').
1057:
1058: The picture rectangle commands `C-c C-k' (`picture-clear-rectangle') and
1059: `C-c C-w' (`picture-clear-rectangle-to-register') differ from the standard
1060: rectangle commands in that they normally clear the rectangle instead of
1061: deleting it; this is analogous with the way `C-d' is changed in Picture
1062: mode.
1063:
1064: However, deletion of rectangles can be useful in Picture mode, so these
1065: commands delete the rectangle if given a numeric argument.
1066:
1067: The Picture mode commands for yanking rectangles differ from the standard
1068: ones in overwriting instead of inserting. This is the same way that
1069: Picture mode insertion of other text is different from other modes.
1070: `C-c C-y' (`picture-yank-rectangle') inserts (by overwriting) the
1071: rectangle that was most recently killed, while `C-c C-x'
1072: (`picture-yank-rectangle-from-register') does likewise for the
1073: rectangle found in a specified register.
1074:
1075:
1076: File: emacs Node: Sending Mail, Prev: Picture, Up: Top, Next: Rmail
1077:
1078: Sending Mail
1079: ************
1080:
1081: To send a message in Emacs, you start by typing a command (`C-x m')
1082: to select and initialize the `*mail*' buffer. Then you edit the text
1083: and headers of the message in this buffer, and type another command
1084: (`C-c C-c') to send the message.
1085:
1086: `C-x m'
1087: Begin composing a message to send (`mail').
1088: `C-x 4 m'
1089: Likewise, but display the message in another window
1090: (`mail-other-window').
1091: `C-c C-c'
1092: In Mail mode, send the message and switch to another buffer
1093: (`mail-send-and-exit').
1094:
1095: The command `C-x m' (`mail') selects a buffer named `*mail*' and
1096: initializes it with the skeleton of an outgoing message. `C-x 4 m'
1097: (`mail-other-window') selects the `*mail*' buffer in a different window,
1098: leaving the previous current buffer visible.
1099:
1100: Because the mail composition buffer is an ordinary Emacs buffer, you can
1101: switch to other buffers while in the middle of composing mail, and switch
1102: back later (or never). If you use the `C-x m' command again when you
1103: have been composing another message but have not sent it, you are asked to
1104: confirm before the old message is erased. If you answer `n', the
1105: `*mail*' buffer is left selected with its old contents, so you can
1106: finish the old message and send it. `C-u C-x m' is another way to do
1107: this. Sending the message marks the `*mail*' buffer "unmodified",
1108: which avoids the need for confirmation when `C-x m' is next used.
1109:
1110: If you are composing a message in the `*mail*' buffer and want to
1111: send another message before finishing the first, rename the `*mail*'
1112: buffer using `M-x rename-buffer' (*Note Misc Buffer::).
1113:
1114: * Menu:
1115:
1116: * Format: Mail Format. Format of the mail being composed.
1117: * Headers: Mail Headers. Details of allowed mail header fields.
1118: * Mode: Mail Mode. Special commands for editing mail being composed.
1119:
1120:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.