Return to emacs-8 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info

Annotation of 43BSDReno/contrib/emacs-18.55/info/emacs-8, revision 1.1

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.