Return to emacs-12 CVS log

Up to [Apple XNU] / GNUtools / emacs / info

Annotation of GNUtools/emacs/info/emacs-12, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.