Return to emacs-3 CVS log

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

Annotation of GNUtools/emacs/info/emacs-3, 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: Repetition,  Prev: Completion,  Up: Minibuffer
        !            27: 
        !            28: Repeating Minibuffer Commands
        !            29: =============================
        !            30: 
        !            31:    Every command that uses the minibuffer at least once is recorded on a
        !            32: special history list, together with the values of the minibuffer
        !            33: arguments, so that you can repeat the command easily.  In particular,
        !            34: every use of `Meta-x' is recorded, since `M-x' uses the minibuffer to
        !            35: read the command name.
        !            36: 
        !            37: `C-x ESC'
        !            38:      Re-execute a recent minibuffer command `repeat-complex-command').
        !            39: 
        !            40: `M-p'
        !            41:      Within `C-x ESC', move to the previous recorded command
        !            42:      (`previous-complex-command').
        !            43: 
        !            44: `M-n'
        !            45:      Within `C-x ESC', move to the next (more recent) recorded command
        !            46:      (`next-complex-command').
        !            47: 
        !            48: `M-x list-command-history'
        !            49:      Display the entire command history, showing all the commands `C-x
        !            50:      ESC' can repeat, most recent first.
        !            51: 
        !            52:    `C-x ESC' is used to re-execute a recent minibuffer-using command. 
        !            53: With no argument, it repeats the last such command.  A numeric argument
        !            54: specifies which command to repeat; 1 means the last one, and larger
        !            55: numbers specify earlier ones.
        !            56: 
        !            57:    `C-x ESC' works by turning the previous command into a Lisp
        !            58: expression and then entering a minibuffer initialized with the text for
        !            59: that expression.  If you type just RET, the command is repeated as
        !            60: before.  You can also change the command by editing the Lisp expression.
        !            61: Whatever expression you finally submit is what will be executed.  The
        !            62: repeated command is added to the front of the command history unless it
        !            63: is identical to the most recently executed command already there.
        !            64: 
        !            65:    Even if you don't understand Lisp syntax, it will probably be obvious
        !            66: which command is displayed for repetition.  If you do not change the
        !            67: text, you can be sure it will repeat exactly as before.
        !            68: 
        !            69:    Once inside the minibuffer for `C-x ESC', if the command shown to
        !            70: you is not the one you want to repeat, you can move around the list of
        !            71: previous commands using `M-n' and `M-p'.  `M-p' replaces the contents
        !            72: of the minibuffer with the next earlier recorded command, and `M-n'
        !            73: replaces them with the next later command.  After finding the desired
        !            74: previous command, you can edit its expression as usual and then
        !            75: resubmit it by typing RET as usual.  Any editing you have done on the
        !            76: command to be repeated is lost if you use `M-n' or `M-p'.
        !            77: 
        !            78:    `M-p' is more useful than `M-n', since more often you will initially
        !            79: request to repeat the most recent command and then decide to repeat an
        !            80: older one instead.  These keys are specially defined within `C-x ESC'
        !            81: to run the commands `previous-complex-command' and
        !            82: `next-complex-command'.
        !            83: 
        !            84:    The list of previous minibuffer-using commands is stored as a Lisp
        !            85: list in the variable `command-history'.  Each element is a Lisp
        !            86: expression which describes one command and its arguments.  Lisp
        !            87: programs can reexecute a command by feeding the corresponding
        !            88: `command-history' element to `eval'.
        !            89: 
        !            90: 
        !            91: File: emacs,  Node: M-x,  Next: Help,  Prev: Minibuffer,  Up: Top
        !            92: 
        !            93: Running Commands by Name
        !            94: ************************
        !            95: 
        !            96:    The Emacs commands that are used often or that must be quick to type
        !            97: are bound to keys--short sequences of characters--for convenient use. 
        !            98: Other Emacs commands that do not need to be brief are not bound to
        !            99: keys; to run them, you must refer to them by name.
        !           100: 
        !           101:    A command name is, by convention, made up of one or more words,
        !           102: separated by hyphens; for example, `auto-fill-mode' or `manual-entry'. 
        !           103: The use of English words makes the command name easier to remember than
        !           104: a key made up of obscure characters, even though it is more characters
        !           105: to type. Any command can be run by name, even if it is also runnable by
        !           106: keys.
        !           107: 
        !           108:    The way to run a command by name is to start with `M-x', type the
        !           109: command name, and finish it with RET.  `M-x' uses the minibuffer to
        !           110: read the command name.  RET exits the minibuffer and runs the command.
        !           111: 
        !           112:    Emacs uses the minibuffer for reading input for many different
        !           113: purposes; on this occasion, the string `M-x' is displayed at the
        !           114: beginning of the minibuffer as a "prompt" to remind you that your input
        !           115: should be the name of a command to be run.  *Note Minibuffer::, for
        !           116: full information on the features of the minibuffer.
        !           117: 
        !           118:    You can use completion to enter the command name.  For example, the
        !           119: command `forward-char' can be invoked by name by typing
        !           120: 
        !           121:      M-x forward-char RET
        !           122: or
        !           123: 
        !           124:      M-x fo TAB c RET
        !           125: 
        !           126: Note that `forward-char' is the same command that you invoke with the
        !           127: key `C-f'.  Any command (interactively callable function) defined in
        !           128: Emacs can be called by its name using `M-x' whether or not any keys are
        !           129: bound to it.
        !           130: 
        !           131:    If you type `C-g' while the command name is being read, you cancel
        !           132: the `M-x' command and get out of the minibuffer, ending up at top level.
        !           133: 
        !           134:    To pass a numeric argument to the command you are invoking with
        !           135: `M-x', specify the numeric argument before the `M-x'.  `M-x' passes the
        !           136: argument along to the function which it calls.  The argument value
        !           137: appears in the prompt while the command name is being read.
        !           138: 
        !           139:    Normally, when describing a command that is run by name, we omit the
        !           140: RET that is needed to terminate the name.  Thus we might speak of `M-x
        !           141: auto-fill-mode' rather than `M-x auto-fill-mode RET'. We mention the
        !           142: RET only when there is a need to emphasize its presence, such as when
        !           143: describing a sequence of input that contains a command name and
        !           144: arguments that follow it.
        !           145: 
        !           146:    `M-x' is defined to run the command `execute-extended-command',
        !           147: which is responsible for reading the name of another command and
        !           148: invoking it.
        !           149: 
        !           150: 
        !           151: File: emacs,  Node: Help,  Next: Mark,  Prev: M-x,  Up: Top
        !           152: 
        !           153: Help
        !           154: ****
        !           155: 
        !           156:    Emacs provides extensive help features which revolve around a single
        !           157: character, `C-h'.  `C-h' is a prefix key that is used only for
        !           158: documentation-printing commands.  The characters that you can type after
        !           159: `C-h' are called "help options".  One help option is `C-h'; that is how
        !           160: you ask for help about using `C-h'.
        !           161: 
        !           162:    `C-h C-h' prints a list of the possible help options, and then asks
        !           163: you to go ahead and type the option.  It prompts with a string
        !           164: 
        !           165:      A B C F I K L M N S T V W C-c C-d C-n C-w.  Type C-h again for more help:
        !           166: 
        !           167: and you should type one of those characters.
        !           168: 
        !           169:    Typing a third `C-h' displays a description of what the options mean;
        !           170: it still waits for you to type an option.  To cancel, type `C-g'.
        !           171: 
        !           172:    Here is a summary of the defined help commands.
        !           173: 
        !           174: `C-h a STRING RET'
        !           175:      Display a list of commands whose names contain STRING
        !           176:      (`command-apropos').
        !           177: 
        !           178: `C-h b'
        !           179:      Display a table of all key bindings in effect now; local bindings
        !           180:      of the current major mode first, followed by all global bindings
        !           181:      (`describe-bindings').
        !           182: 
        !           183: `C-h c KEY'
        !           184:      Print the name of the command that KEY runs
        !           185:      (`describe-key-briefly'). `c' is for `character'.  For more
        !           186:      extensive information on KEY, use `C-h k'.
        !           187: 
        !           188: `C-h f FUNCTION RET'
        !           189:      Display documentation on the Lisp function named FUNCTION
        !           190:      (`describe-function').  Note that commands are Lisp functions, so
        !           191:      a command name may be used.
        !           192: 
        !           193: `C-h i'
        !           194:      Run Info, the program for browsing documentation files (`info').
        !           195:      The complete Emacs manual is available on-line in Info.
        !           196: 
        !           197: `C-h k KEY'
        !           198:      Display name and documentation of the command KEY runs
        !           199:      (`describe-key').
        !           200: 
        !           201: `C-h l'
        !           202:      Display a description of the last 100 characters you typed
        !           203:      (`view-lossage').
        !           204: 
        !           205: `C-h m'
        !           206:      Display documentation of the current major mode (`describe-mode').
        !           207: 
        !           208: `C-h n'
        !           209:      Display documentation of Emacs changes, most recent first
        !           210:      (`view-emacs-news').
        !           211: 
        !           212: `C-h s'
        !           213:      Display current contents of the syntax table, plus an explanation
        !           214:      of what they mean (`describe-syntax').
        !           215: 
        !           216: `C-h t'
        !           217:      Display the Emacs tutorial (`help-with-tutorial').
        !           218: 
        !           219: `C-h v VAR RET'
        !           220:      Display the documentation of the Lisp variable VAR
        !           221:      (`describe-variable').
        !           222: 
        !           223: `C-h w COMMAND RET'
        !           224:      Print which keys run the command named COMMAND (`where-is').
        !           225: 
        !           226: Documentation for a Key
        !           227: =======================
        !           228: 
        !           229:    The most basic `C-h' options are `C-h c' (`describe-key-briefly')
        !           230: and `C-h k' (`describe-key'). `C-h c KEY' prints in the echo area the
        !           231: name of the command that KEY is bound to.  For example, `C-h c C-f'
        !           232: prints `forward-char'.  Since command names are chosen to describe what
        !           233: the command does, this is a good way to get a very brief description of
        !           234: what KEY does.
        !           235: 
        !           236:    `C-h k KEY' is similar but gives more information.  It displays the
        !           237: documentation string of the command KEY is bound to as well as its
        !           238: name.  This is too big for the echo area, so a window is used for the
        !           239: display.
        !           240: 
        !           241: Help by Command or Variable Name
        !           242: ================================
        !           243: 
        !           244:    `C-h f' (`describe-function') reads the name of a Lisp function
        !           245: using the minibuffer, then displays that function's documentation string
        !           246: in a window.  Since commands are Lisp functions, you can use this to get
        !           247: the documentation of a command that is known by name.  For example,
        !           248: 
        !           249:      C-h f auto-fill-mode RET
        !           250: 
        !           251: displays the documentation of `auto-fill-mode'.  This is the only way
        !           252: to see the documentation of a command that is not bound to any key (one
        !           253: which you would normally call using `M-x').
        !           254: 
        !           255:    `C-h f' is also useful for Lisp functions that you are planning to
        !           256: use in a Lisp program.  For example, if you have just written the code
        !           257: `(make-vector len)' and want to be sure that you are using
        !           258: `make-vector' properly, type `C-h f make-vector RET'.  Because `C-h f'
        !           259: allows all function names, not just command names, you may find that
        !           260: some of your favorite abbreviations that work in `M-x' don't work in
        !           261: `C-h f'.  An abbreviation may be unique among command names yet fail to
        !           262: be unique when other function names are allowed.
        !           263: 
        !           264:    The function name for `C-h f' to describe has a default which is
        !           265: used if you type RET leaving the minibuffer empty.  The default is the
        !           266: function called by the innermost Lisp expression in the buffer around
        !           267: point, provided that is a valid, defined Lisp function name.  For
        !           268: example, if point is located following the text `(make-vector (car x)',
        !           269: the innermost list containing point is the one that starts with
        !           270: `(make-vector', so the default is to describe the function
        !           271: `make-vector'.
        !           272: 
        !           273:    `C-h f' is often useful just to verify that you have the right
        !           274: spelling for the function name.  If `C-h f' mentions a default in the
        !           275: prompt, you have typed the name of a defined Lisp function.  If that
        !           276: tells you what you want to know, just type `C-g' to cancel the `C-h f'
        !           277: command and go on editing.
        !           278: 
        !           279:    `C-h w COMMAND RET' tells you what keys are bound to COMMAND.  It
        !           280: prints a list of the keys in the echo area. Alternatively, it says that
        !           281: the command is not on any keys, which implies that you must use `M-x'
        !           282: to call it.
        !           283: 
        !           284:    `C-h v' (`describe-variable') is like `C-h f' but describes Lisp
        !           285: variables instead of Lisp functions.  Its default is the Lisp symbol
        !           286: around or before point, but only if that is the name of a known Lisp
        !           287: variable.  *Note Variables::.
        !           288: 
        !           289: Apropos
        !           290: =======
        !           291: 
        !           292:    A more sophisticated sort of question to ask is, "What are the
        !           293: commands for working with files?"  For this, type `C-h a file RET',
        !           294: which displays a list of all command names that contain `file', such as
        !           295: `copy-file', `find-file', and so on.  With each command name appears a
        !           296: brief description of how to use the command, and what keys you can
        !           297: currently invoke it with.  For example, it would say that you can
        !           298: invoke `find-file' by typing `C-x C-f'.  The `a' in `C-h a' stands for
        !           299: `Apropos'; `C-h a' runs the Lisp function `command-apropos'.
        !           300: 
        !           301:    Because `C-h a' looks only for functions whose names contain the
        !           302: string which you specify, you must use ingenuity in choosing the string.
        !           303: If you are looking for commands for killing backwards and `C-h a
        !           304: kill-backwards RET' doesn't reveal any, don't give up.  Try just
        !           305: `kill', or just `backwards', or just `back'.  Be persistent. Pretend
        !           306: you are playing Adventure.  Also note that you can use a regular
        !           307: expression as the argument (*note Regexps::.).
        !           308: 
        !           309:    Here is a set of arguments to give to `C-h a' that covers many
        !           310: classes of Emacs commands, since there are strong conventions for naming
        !           311: the standard Emacs commands.  By giving you a feel for the naming
        !           312: conventions, this set should also serve to aid you in developing a
        !           313: technique for picking `apropos' strings.
        !           314: 
        !           315:      char, line, word, sentence, paragraph, region, page, sexp, list,
        !           316:      defun, buffer, screen, window, file, dir, register, mode,
        !           317:      beginning, end, forward, backward, next, previous, up, down,
        !           318:      search, goto, kill, delete, mark, insert, yank, fill, indent, case,
        !           319:      change, set, what, list, find, view, describe.
        !           320: 
        !           321:    To list all Lisp symbols that contain a match for a regexp, not just
        !           322: the ones that are defined as commands, use the command `M-x apropos'
        !           323: instead of `C-h a'.
        !           324: 
        !           325: Other Help Commands
        !           326: ===================
        !           327: 
        !           328:    `C-h i' (`info') runs the Info program, which is used for browsing
        !           329: through structured documentation files.  The entire Emacs manual is
        !           330: available within Info.  Eventually all the documentation of the GNU
        !           331: system will be available.  Type `h' after entering Info to run a
        !           332: tutorial on using Info.
        !           333: 
        !           334:    If something surprising happens, and you are not sure what commands
        !           335: you typed, use `C-h l' (`view-lossage').  `C-h l' prints the last 100
        !           336: command characters you typed in.  If you see commands that you don't
        !           337: know, you can use `C-h c' to find out what they do.
        !           338: 
        !           339:    Emacs has several major modes, each of which redefines a few keys and
        !           340: makes a few other changes in how editing works.  `C-h m'
        !           341: (`describe-mode') prints documentation on the current major mode, which
        !           342: normally describes all the commands that are changed in this mode.
        !           343: 
        !           344:    `C-h b' (`describe-bindings') and `C-h s' (`describe-syntax')
        !           345: present other information about the current Emacs mode.  `C-h b'
        !           346: displays a list of all the key bindings now in effect; the local
        !           347: bindings of the current major mode first, followed by the global
        !           348: bindings (*note Key Bindings::.).  `C-h s' displays the contents of the
        !           349: syntax table, with explanations of each character's syntax (*note
        !           350: Syntax::.).
        !           351: 
        !           352:    The other `C-h' options display various files of useful information.
        !           353:  `C-h C-w' displays the full details on the complete absence of
        !           354: warranty for GNU Emacs.  `C-h n' (`view-emacs-news') displays the file
        !           355: `emacs/etc/NEWS', which contains documentation on Emacs changes
        !           356: arranged chronologically.  `C-h t' (`help-with-tutorial') displays the
        !           357: learn-by-doing Emacs tutorial. `C-h C-c' (`describe-copying') displays
        !           358: the file `emacs/etc/COPYING', which tells you the conditions you must
        !           359: obey in distributing copies of Emacs.  `C-h C-d'
        !           360: (`describe-distribution') displays another file named
        !           361: `emacs/etc/DISTRIB', which tells you how you can order a copy of the
        !           362: latest version of Emacs.
        !           363: 
        !           364: 
        !           365: File: emacs,  Node: Mark,  Next: Killing,  Prev: Help,  Up: Top
        !           366: 
        !           367: The Mark and the Region
        !           368: ***********************
        !           369: 
        !           370:    There are many Emacs commands which operate on an arbitrary
        !           371: contiguous part of the current buffer.  To specify the text for such a
        !           372: command to operate on, you set the "mark" at one end of it, and move
        !           373: point to the other end.  The text between point and the mark is called
        !           374: the "region". You can move point or the mark to adjust the boundaries
        !           375: of the region.  It doesn't matter which one is set first
        !           376: chronologically, or which one comes earlier in the text.
        !           377: 
        !           378:    Once the mark has been set, it remains until it is set again at
        !           379: another place.  The mark remains fixed with respect to the preceding
        !           380: character if text is inserted or deleted in the buffer.  Each Emacs
        !           381: buffer has its own mark, so that when you return to a buffer that had
        !           382: been selected previously, it has the same mark it had before.
        !           383: 
        !           384:    Many commands that insert text, such as `C-y' (`yank') and `M-x
        !           385: insert-buffer', position the mark at one end of the inserted text--the
        !           386: opposite end from where point is positioned, so that the region
        !           387: contains the text just inserted.
        !           388: 
        !           389:    Aside from delimiting the region, the mark is also useful for
        !           390: remembering a spot that you may want to go back to.  To make this
        !           391: feature more useful, Emacs remembers 16 previous locations of the mark,
        !           392: in the `mark ring'.
        !           393: 
        !           394: * Menu:
        !           395: 
        !           396: * Setting Mark::       Commands to set the mark.
        !           397: * Using Region::       Summary of ways to operate on contents of the region.
        !           398: * Marking Objects::    Commands to put region around textual units.
        !           399: * Mark Ring::   Previous mark positions saved so you can go back there.
        !           400: 
        !           401: 
        !           402: File: emacs,  Node: Setting Mark,  Next: Using Region,  Prev: Mark,  Up: Mark
        !           403: 
        !           404: Setting the Mark
        !           405: ================
        !           406: 
        !           407:    Here are some commands for setting the mark:
        !           408: 
        !           409: `C-SPC'
        !           410:      Set the mark where point is (`set-mark-command').
        !           411: 
        !           412: `C-@'
        !           413:      The same.
        !           414: 
        !           415: `C-x C-x'
        !           416:      Interchange mark and point (`exchange-point-and-mark').
        !           417: 
        !           418:    For example, if you wish to convert part of the buffer to all
        !           419: upper-case, you can use the `C-x C-u' (`upcase-region') command, which
        !           420: operates on the text in the region.  You can first go to the beginning
        !           421: of the text to be capitalized, type `C-SPC' to put the mark there, move
        !           422: to the end, and then type `C-x C-u'.  Or, you can set the mark at the
        !           423: end of the text, move to the beginning, and then type `C-x C-u'.  Most
        !           424: commands that operate on the text in the region have the word `region'
        !           425: in their names.
        !           426: 
        !           427:    The most common way to set the mark is with the `C-SPC' command
        !           428: (`set-mark-command').  This sets the mark where point is.  Then you can
        !           429: move point away, leaving the mark behind.  It is actually incorrect to
        !           430: speak of the character `C-SPC'; there is no such character.  When you
        !           431: type SPC while holding down CTRL, what you get on most terminals is the
        !           432: character `C-@'.  This is the key actually bound to `set-mark-command'.
        !           433:  But unless you are unlucky enough to have a terminal where typing
        !           434: `C-SPC' does not produce `C-@', you might as well think of this
        !           435: character as `C-SPC'.
        !           436: 
        !           437:    Since terminals have only one cursor, there is no way for Emacs to
        !           438: show you where the mark is located.  You have to remember.  The usual
        !           439: solution to this problem is to set the mark and then use it soon,
        !           440: before you forget where it is.  But you can see where the mark is with
        !           441: the command `C-x C-x' (`exchange-point-and-mark') which puts the mark
        !           442: where point was and point where the mark was.  The extent of the region
        !           443: is unchanged, but the cursor and point are now at the previous location
        !           444: of the mark.
        !           445: 
        !           446:    `C-x C-x' is also useful when you are satisfied with the location of
        !           447: point but want to move the mark; do `C-x C-x' to put point there and
        !           448: then you can move it.  A second use of `C-x C-x', if necessary, puts
        !           449: the mark at the new location with point back at its original location.
        !           450: 
        !           451: 
        !           452: File: emacs,  Node: Using Region,  Next: Marking Objects,  Prev: Setting Mark,  Up: Mark
        !           453: 
        !           454: Operating on the Region
        !           455: =======================
        !           456: 
        !           457:    Once you have created an active region, you can do many things to
        !           458: the text in it:
        !           459:    * Kill it with `C-w' (*note Killing::.).
        !           460: 
        !           461:    * Save it in a register with `C-x x' (*note Registers::.).
        !           462: 
        !           463:    * Save it in a buffer or a file (*note Accumulating Text::.).
        !           464: 
        !           465:    * Convert case with `C-x C-l' or `C-x C-u'
        !           466:      (*note Case::.).
        !           467: 
        !           468:    * Evaluate it as Lisp code with `M-x eval-region' (*note Lisp
        !           469:      Eval::.).
        !           470: 
        !           471:    * Fill it as text with `M-g' (*note Filling::.).
        !           472: 
        !           473:    * Print hardcopy with `M-x print-region' (*note Hardcopy::.).
        !           474: 
        !           475:    * Indent it with `C-x TAB' or `C-M-\'
        !           476:      (*note Indentation::.).
        !           477: 
        !           478: 
        !           479: File: emacs,  Node: Marking Objects,  Next: Mark Ring,  Prev: Using Region,  Up: Mark
        !           480: 
        !           481: Commands to Mark Textual Objects
        !           482: ================================
        !           483: 
        !           484:    There are commands for placing point and the mark around a textual
        !           485: object such as a word, list, paragraph or page.
        !           486: 
        !           487: `M-@'
        !           488:      Set mark after end of next word (`mark-word').  This command and
        !           489:      the following one do not move point.
        !           490: 
        !           491: `C-M-@'
        !           492:      Set mark after end of next Lisp expression (`mark-sexp').
        !           493: 
        !           494: `M-h'
        !           495:      Put region around current paragraph (`mark-paragraph').
        !           496: 
        !           497: `C-M-h'
        !           498:      Put region around current Lisp defun (`mark-defun').
        !           499: 
        !           500: `C-x h'
        !           501:      Put region around entire buffer (`mark-whole-buffer').
        !           502: 
        !           503: `C-x C-p'
        !           504:      Put region around current page (`mark-page').
        !           505: 
        !           506:    `M-@' (`mark-word') puts the mark at the end of the next word, while
        !           507: `C-M-@' (`mark-sexp') puts it at the end of the next Lisp expression. 
        !           508: These characters allow you to save a little typing or redisplay,
        !           509: sometimes.
        !           510: 
        !           511:    Other commands set both point and mark, to delimit an object in the
        !           512: buffer.  `M-h' (`mark-paragraph') moves point to the beginning of the
        !           513: paragraph that surrounds or follows point, and puts the mark at the end
        !           514: of that paragraph (*note Paragraphs::.).  `M-h' does all that's
        !           515: necessary if you wish to indent, case-convert, or kill a whole
        !           516: paragraph. `C-M-h' (`mark-defun') similarly puts point before and the
        !           517: mark after the current or following defun (*note Defuns::.).  `C-x C-p'
        !           518: (`mark-page') puts point before the current page (or the next or
        !           519: previous, according to the argument), and mark at the end (*note
        !           520: Pages::.). The mark goes after the terminating page delimiter (to
        !           521: include it), while point goes after the preceding page delimiter (to
        !           522: exclude it).  Finally, `C-x h' (`mark-whole-buffer') sets up the entire
        !           523: buffer as the region, by putting point at the beginning and the mark at
        !           524: the end.
        !           525: 
        !           526: 
        !           527: File: emacs,  Node: Mark Ring,  Prev: Marking Objects,  Up: Mark
        !           528: 
        !           529: The Mark Ring
        !           530: =============
        !           531: 
        !           532:    Aside from delimiting the region, the mark is also useful for
        !           533: remembering a spot that you may want to go back to.  To make this
        !           534: feature more useful, Emacs remembers 16 previous locations of the mark,
        !           535: in the "mark ring". Most commands that set the mark push the old mark
        !           536: onto this ring.  To return to a marked location, use `C-u C-SPC' (or
        !           537: `C-u C-@'); this is the command `set-mark-command' given a numeric
        !           538: argument.  It moves point to where the mark was, and restores the mark
        !           539: from the ring of former marks.  So repeated use of this command moves
        !           540: point to all of the old marks on the ring, one by one.  The marks you
        !           541: see go to the end of the ring, so no marks are lost.
        !           542: 
        !           543:    Each buffer has its own mark ring.  All editing commands use the
        !           544: current buffer's mark ring.  In particular, `C-u C-SPC' always stays in
        !           545: the same buffer.
        !           546: 
        !           547:    Many commands that can move long distances, such as `M-<'
        !           548: (`beginning-of-buffer'), start by setting the mark and saving the old
        !           549: mark on the mark ring.  This is to make it easier for you to move back
        !           550: later.  Searches do this except when they do not actually move point. 
        !           551: You can tell when a command sets the mark because `Mark Set' is printed
        !           552: in the echo area.
        !           553: 
        !           554:    Another way of remembering positions so you can go back to them is
        !           555: with registers (*note RegPos::.).
        !           556: 
        !           557:    The variable `mark-ring-max' is the maximum number of entries to
        !           558: keep in the mark ring.  If that many entries exist and another one is
        !           559: pushed, the last one in the list is discarded.  Repeating `C-u C-SPC'
        !           560: circulates through the limited number of entries that are currently in
        !           561: the ring.
        !           562: 
        !           563:    The variable `mark-ring' holds the mark ring itself, as a list of
        !           564: marker objects in the order most recent first.  This variable is local
        !           565: in every buffer.
        !           566: 
        !           567: 
        !           568: File: emacs,  Node: Killing,  Next: Yanking,  Prev: Mark,  Up: Top
        !           569: 
        !           570: Deletion and Killing
        !           571: ====================
        !           572: 
        !           573:    Most commands which erase text from the buffer save it so that you
        !           574: can get it back if you change your mind, or move or copy it to other
        !           575: parts of the buffer.  These commands are known as "kill" commands.  The
        !           576: rest of the commands that erase text do not save it; they are known as
        !           577: "delete" commands.  (This distinction is made only for erasure of text
        !           578: in the buffer.)
        !           579: 
        !           580:    The delete commands include `C-d' (`delete-char') and DEL
        !           581: (`delete-backward-char'), which delete only one character at a time,
        !           582: and those commands that delete only spaces or newlines.  Commands that
        !           583: can destroy significant amounts of nontrivial data generally kill. The
        !           584: commands' names and individual descriptions use the words `kill' and
        !           585: `delete' to say which they do.  If you do a kill or delete command by
        !           586: mistake, you can use the `C-x u' (`undo') command to undo it (*note
        !           587: Undo::.).
        !           588: 
        !           589: Deletion
        !           590: --------
        !           591: 
        !           592: `C-d'
        !           593:      Delete next character (`delete-char').
        !           594: 
        !           595: `DEL'
        !           596:      Delete previous character (`delete-backward-char').
        !           597: 
        !           598: `M-\'
        !           599:      Delete spaces and tabs around point (`delete-horizontal-space').
        !           600: 
        !           601: `M-SPC'
        !           602:      Delete spaces and tabs around point, leaving one space
        !           603:      (`just-one-space').
        !           604: 
        !           605: `C-x C-o'
        !           606:      Delete blank lines around the current line (`delete-blank-lines').
        !           607: 
        !           608: `M-^'
        !           609:      Join two lines by deleting the intervening newline, and any
        !           610:      indentation following it (`delete-indentation').
        !           611: 
        !           612:    The most basic delete commands are `C-d' (`delete-char') and DEL
        !           613: (`delete-backward-char').  `C-d' deletes the character after point, the
        !           614: one the cursor is "on top of".  Point doesn't move. DEL deletes the
        !           615: character before the cursor, and moves point back. Newlines can be
        !           616: deleted like any other characters in the buffer; deleting a newline
        !           617: joins two lines.  Actually, `C-d' and DEL aren't always delete
        !           618: commands; if given an argument, they kill instead, since they can erase
        !           619: more than one character this way.
        !           620: 
        !           621:    The other delete commands are those which delete only formatting
        !           622: characters: spaces, tabs and newlines.  `M-\'
        !           623: (`delete-horizontal-space') deletes all the spaces and tab characters
        !           624: before and after point. `M-SPC' (`just-one-space') does likewise but
        !           625: leaves a single space after point, regardless of the number of spaces
        !           626: that existed previously (even zero).
        !           627: 
        !           628:    `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
        !           629: current line, and if the current line is blank deletes all blank lines
        !           630: preceding the current line as well (leaving one blank line, the current
        !           631: line).  `M-^' (`delete-indentation') joins the current line and the
        !           632: previous line, or the current line and the next line if given an
        !           633: argument, by deleting a newline and all surrounding spaces, possibly
        !           634: leaving a single space.  *Note M-^: Indentation.
        !           635: 
        !           636: Killing by Lines
        !           637: ----------------
        !           638: 
        !           639: `C-k'
        !           640:      Kill rest of line or one or more lines (`kill-line').
        !           641: 
        !           642:    The simplest kill command is `C-k'.  If given at the beginning of a
        !           643: line, it kills all the text on the line, leaving it blank.  If given on
        !           644: a blank line, the blank line disappears.  As a consequence, if you go
        !           645: to the front of a non-blank line and type `C-k' twice, the line
        !           646: disappears completely.
        !           647: 
        !           648:    More generally, `C-k' kills from point up to the end of the line,
        !           649: unless it is at the end of a line.  In that case it kills the newline
        !           650: following the line, thus merging the next line into the current one.
        !           651: Invisible spaces and tabs at the end of the line are ignored when
        !           652: deciding which case applies, so if point appears to be at the end of
        !           653: the line, you can be sure the newline will be killed.
        !           654: 
        !           655:    If `C-k' is given a positive argument, it kills that many lines and
        !           656: the newlines that follow them (however, text on the current line before
        !           657: point is spared).  With a negative argument, it kills back to a number
        !           658: of line beginnings.  An argument of -2 means kill back to the second
        !           659: line beginning.  If point is at the beginning of a line, that line
        !           660: beginning doesn't count, so `C-u - 2 C-k' with point at the front of a
        !           661: line kills the two previous lines.
        !           662: 
        !           663:    `C-k' with an argument of zero kills all the text before point on the
        !           664: current line.
        !           665: 
        !           666: Other Kill Commands
        !           667: -------------------
        !           668: 
        !           669: `C-w'
        !           670:      Kill region (from point to the mark) (`kill-region'). *Note
        !           671:      Words::.
        !           672: 
        !           673: `M-d'
        !           674:      Kill word (`kill-word').
        !           675: 
        !           676: `M-DEL'
        !           677:      Kill word backwards (`backward-kill-word').
        !           678: 
        !           679: `C-x DEL'
        !           680:      Kill back to beginning of sentence (`backward-kill-sentence').
        !           681:      *Note Sentences::.
        !           682: 
        !           683: `M-k'
        !           684:      Kill to end of sentence (`kill-sentence').
        !           685: 
        !           686: `C-M-k'
        !           687:      Kill sexp (`kill-sexp').  *Note Lists::.
        !           688: 
        !           689: `M-z CHAR'
        !           690:      Kill up to next occurrence of CHAR (`zap-to-char').
        !           691: 
        !           692:    A kill command which is very general is `C-w' (`kill-region'), which
        !           693: kills everything between point and the mark.  With this command, you
        !           694: can kill any contiguous sequence of characters, if you first set the
        !           695: mark at one end of them and go to the other end.
        !           696: 
        !           697:    A convenient way of killing is combined with searching: `M-z'
        !           698: (`zap-to-char') reads a character and kills from point up to (but not
        !           699: including) the next occurrence of that character in the buffer.  If
        !           700: there is no next occurrence, killing goes to the end of the buffer.  A
        !           701: numeric argument acts as a repeat count.  A negative argument means to
        !           702: search backward and kill text before point.
        !           703: 
        !           704:    Other syntactic units can be killed: words, with `M-DEL' and `M-d'
        !           705: (*note Words::.); sexps, with `C-M-k' (*note Lists::.); and sentences,
        !           706: with `C-x DEL' and `M-k' (*note Sentences::.).
        !           707: 
        !           708: 
        !           709: File: emacs,  Node: Yanking,  Next: Accumulating Text,  Prev: Killing,  Up: Top
        !           710: 
        !           711: Yanking
        !           712: =======
        !           713: 
        !           714:    "Yanking" is getting back text which was killed.  This is what some
        !           715: systems call "pasting".  The usual way to move or copy text is to kill
        !           716: it and then yank it one or more times.
        !           717: 
        !           718: `C-y'
        !           719:      Yank last killed text (`yank').
        !           720: 
        !           721: `M-y'
        !           722:      Replace re-inserted killed text with the previously killed text
        !           723:      (`yank-pop').
        !           724: 
        !           725: `M-w'
        !           726:      Save region as last killed text without actually killing it
        !           727:      (`copy-region-as-kill').
        !           728: 
        !           729: `C-M-w'
        !           730:      Append next kill to last batch of killed text (`append-next-kill').
        !           731: 
        !           732: * Menu:
        !           733: 
        !           734: * Kill Ring::       Where killed text is stored.  Basic yanking.
        !           735: * Appending Kills:: Several kills in a row all yank together.
        !           736: * Earlier Kills::   Yanking something killed some time ago.
        !           737: 
        !           738: 
        !           739: File: emacs,  Node: Kill Ring,  Next: Appending Kills,  Prev: Yanking,  Up: Yanking
        !           740: 
        !           741: The Kill Ring
        !           742: -------------
        !           743: 
        !           744:    All killed text is recorded in the "kill ring", a list of blocks of
        !           745: text that have been killed.  There is only one kill ring, used in all
        !           746: buffers, so you can kill text in one buffer and yank it in another
        !           747: buffer. This is the usual way to move text from one file to another.
        !           748: (*Note Accumulating Text::, for some other ways.)
        !           749: 
        !           750:    The command `C-y' (`yank') reinserts the text of the most recent
        !           751: kill.  It leaves the cursor at the end of the text.  It sets the mark at
        !           752: the beginning of the text.  *Note Mark::.
        !           753: 
        !           754:    `C-u C-y' leaves the cursor in front of the text, and sets the mark
        !           755: after it.  This is only if the argument is specified with just a `C-u',
        !           756: precisely.  Any other sort of argument, including `C-u' and digits, has
        !           757: an effect described below (under "Yanking Earlier Kills").
        !           758: 
        !           759:    If you wish to copy a block of text, you might want to use `M-w'
        !           760: (`copy-region-as-kill'), which copies the region into the kill ring
        !           761: without removing it from the buffer.  This is approximately equivalent
        !           762: to `C-w' followed by `C-y', except that `M-w' does not mark the buffer
        !           763: as "modified" and does not temporarily change the screen.
        !           764: 
        !           765: 
        !           766: File: emacs,  Node: Appending Kills,  Next: Earlier Kills,  Prev: Kill Ring,  Up: Yanking
        !           767: 
        !           768: Appending Kills
        !           769: ---------------
        !           770: 
        !           771:    Normally, each kill command pushes a new block onto the kill ring.
        !           772: However, two or more kill commands in a row combine their text into a
        !           773: single entry, so that a single `C-y' gets it all back as it was before
        !           774: it was killed.  This means that you don't have to kill all the text in
        !           775: one command; you can keep killing line after line, or word after word,
        !           776: until you have killed it all, and you can still get it all back at
        !           777: once.  (Thus we join television in leading people to kill
        !           778: thoughtlessly.)
        !           779: 
        !           780:    Commands that kill forward from point add onto the end of the
        !           781: previous killed text.  Commands that kill backward from point add onto
        !           782: the beginning.  This way, any sequence of mixed forward and backward
        !           783: kill commands puts all the killed text into one entry without
        !           784: rearrangement. Numeric arguments do not break the sequence of appending
        !           785: kills.  For example, suppose the buffer contains
        !           786: 
        !           787:      This is the first
        !           788:      line of sample text
        !           789:      and here is the third.
        !           790: 
        !           791: with point at the beginning of the second line.  If you type `C-k C-u 2
        !           792: M-DEL C-k', the first `C-k' kills the text `line of sample text', `C-u
        !           793: 2 M-DEL' kills `the first' with the newline that followed it, and the
        !           794: second `C-k' kills the newline after the second line.  The result is
        !           795: that the buffer contains `This is and here is the third.' and a single
        !           796: kill entry contains `the firstRETline of sample textRET'--all the
        !           797: killed text, in its original order.
        !           798: 
        !           799:    If a kill command is separated from the last kill command by other
        !           800: commands (not just numeric arguments), it starts a new entry on the kill
        !           801: ring.  But you can force it to append by first typing the command
        !           802: `C-M-w' (`append-next-kill') in front of it.  The `C-M-w' tells the
        !           803: following command, if it is a kill command, to append the text it kills
        !           804: to the last killed text, instead of starting a new entry.  With
        !           805: `C-M-w', you can kill several separated pieces of text and accumulate
        !           806: them to be yanked back in one place.
        !           807: 
        !           808: 
        !           809: File: emacs,  Node: Earlier Kills,  Prev: Appending Kills,  Up: Yanking
        !           810: 
        !           811: Yanking Earlier Kills
        !           812: ---------------------
        !           813: 
        !           814:    To recover killed text that is no longer the most recent kill, you
        !           815: need the `Meta-y' (`yank-pop') command.  `M-y' can be used only after a
        !           816: `C-y' or another `M-y'.  It takes the text previously yanked and
        !           817: replaces it with the text from an earlier kill.  So, to recover the
        !           818: text of the next-to-the-last kill, you first use `C-y' to recover the
        !           819: last kill, and then use `M-y' to replace it with the previous kill.
        !           820: 
        !           821:    You can think in terms of a "last yank" pointer which points at an
        !           822: item in the kill ring.  Each time you kill, the "last yank" pointer
        !           823: moves to the newly made item at the front of the ring.  `C-y' yanks the
        !           824: item which the "last yank" pointer points to.  `M-y' moves the "last
        !           825: yank" pointer to a different item, and the text in the buffer changes to
        !           826: match.  Enough `M-y' commands can move the pointer to any item in the
        !           827: ring, so you can get any item into the buffer.  Eventually the pointer
        !           828: reaches the end of the ring; the next `M-y' moves it to the first item
        !           829: again.
        !           830: 
        !           831:    Yanking moves the "last yank" pointer around the ring, but it does
        !           832: not change the order of the entries in the ring, which always runs from
        !           833: the most recent kill at the front to the oldest one still remembered.
        !           834: 
        !           835:    `M-y' can take a numeric argument, which tells it how many items to
        !           836: advance the "last yank" pointer by.  A negative argument moves the
        !           837: pointer toward the front of the ring; from the front of the ring, it
        !           838: moves to the last entry and starts moving forward from there.
        !           839: 
        !           840:    Once the text you are looking for is brought into the buffer, you can
        !           841: stop doing `M-y' commands and it will stay there.  It's just a copy of
        !           842: the kill ring item, so editing it in the buffer does not change what's
        !           843: in the ring.  As long as no new killing is done, the "last yank" pointer
        !           844: remains at the same place in the kill ring, so repeating `C-y' will
        !           845: yank another copy of the same old kill.
        !           846: 
        !           847:    If you know how many `M-y' commands it would take to find the text
        !           848: you want, you can yank that text in one step using `C-y' with a numeric
        !           849: argument.  `C-y' with an argument greater than one restores the text
        !           850: the specified number of entries back in the kill ring.  Thus, `C-u 2
        !           851: C-y' gets the next to the last block of killed text.  It is equivalent
        !           852: to `C-y M-y'.  `C-y' with a numeric argument starts counting from the
        !           853: "last yank" pointer, and sets the "last yank" pointer to the entry that
        !           854: it yanks.
        !           855: 
        !           856:    The length of the kill ring is controlled by the variable
        !           857: `kill-ring-max'; no more than that many blocks of killed text are saved.
        !           858: 
        !           859: 
        !           860: File: emacs,  Node: Accumulating Text,  Next: Rectangles,  Prev: Yanking,  Up: Top
        !           861: 
        !           862: Accumulating Text
        !           863: =================
        !           864: 
        !           865:    Usually we copy or move text by killing it and yanking it, but there
        !           866: are other ways that are useful for copying one block of text in many
        !           867: places, or for copying many scattered blocks of text into one place.
        !           868: 
        !           869:    You can accumulate blocks of text from scattered locations either
        !           870: into a buffer or into a file if you like.  These commands are described
        !           871: here.  You can also use Emacs registers for storing and accumulating
        !           872: text. *Note Registers::.
        !           873: 
        !           874: `C-x a'
        !           875:      Append region to contents of specified buffer (`append-to-buffer').
        !           876: 
        !           877: `M-x prepend-to-buffer'
        !           878:      Prepend region to contents of specified buffer.
        !           879: 
        !           880: `M-x copy-to-buffer'
        !           881:      Copy region into specified buffer, deleting that buffer's old
        !           882:      contents.
        !           883: 
        !           884: `M-x insert-buffer'
        !           885:      Insert contents of specified buffer into current buffer at point.
        !           886: 
        !           887: `M-x append-to-file'
        !           888:      Append region to contents of specified file, at the end.
        !           889: 
        !           890:    To accumulate text into a buffer, use the command `C-x a BUFFERNAME'
        !           891: (`append-to-buffer'), which inserts a copy of the region into the
        !           892: buffer BUFFERNAME, at the location of point in that buffer.  If there
        !           893: is no buffer with that name, one is created.  If you append text into a
        !           894: buffer which has been used for editing, the copied text goes into the
        !           895: middle of the text of the buffer, wherever point happens to be in it.
        !           896: 
        !           897:    Point in that buffer is left at the end of the copied text, so
        !           898: successive uses of `C-x a' accumulate the text in the specified buffer
        !           899: in the same order as they were copied.  Strictly speaking, `C-x a' does
        !           900: not always append to the text already in the buffer; but if `C-x a' is
        !           901: the only command used to alter a buffer, it does always append to the
        !           902: existing text because point is always at the end.
        !           903: 
        !           904:    `M-x prepend-to-buffer' is just like `C-x a' except that point in
        !           905: the other buffer is left before the copied text, so successive
        !           906: prependings add text in reverse order.  `M-x copy-to-buffer' is similar
        !           907: except that any existing text in the other buffer is deleted, so the
        !           908: buffer is left containing just the text newly copied into it.
        !           909: 
        !           910:    You can retrieve the accumulated text from that buffer with `M-x
        !           911: insert-buffer'; this too takes BUFFERNAME as an argument.  It inserts a
        !           912: copy of the text in buffer BUFFERNAME into the selected buffer. You
        !           913: could alternatively select the other buffer for editing, perhaps moving
        !           914: text from it by killing or with `C-x a'.  *Note Buffers::, for
        !           915: background information on buffers.
        !           916: 
        !           917:    Instead of accumulating text within Emacs, in a buffer, you can
        !           918: append text directly into a file with `M-x append-to-file', which takes
        !           919: FILE-NAME as an argument.  It adds the text of the region to the end of
        !           920: the specified file.  The file is changed immediately on disk. This
        !           921: command is normally used with files that are not being visited in
        !           922: Emacs.  Using it on a file that Emacs is visiting can produce confusing
        !           923: results, because the text inside Emacs for that file will not change
        !           924: while the file itself changes.
        !           925: 
        !           926: 
        !           927: File: emacs,  Node: Rectangles,  Next: Registers,  Prev: Accumulating Text,  Up: Top
        !           928: 
        !           929: Rectangles
        !           930: ==========
        !           931: 
        !           932:    The rectangle commands affect rectangular areas of the text: all the
        !           933: characters between a certain pair of columns, in a certain range of
        !           934: lines. Commands are provided to kill rectangles, yank killed
        !           935: rectangles, clear them out, or delete them.  Rectangle commands are
        !           936: useful with text in multicolumnar formats, such as perhaps code with
        !           937: comments at the right, or for changing text into or out of such formats.
        !           938: 
        !           939:    When you must specify a rectangle for a command to work on, you do
        !           940: it by putting the mark at one corner and point at the opposite corner.
        !           941: The rectangle thus specified is called the "region-rectangle" because
        !           942: it is controlled about the same way the region is controlled. But
        !           943: remember that a given combination of point and mark values can be
        !           944: interpreted either as specifying a region or as specifying a rectangle;
        !           945: it is up to the command that uses them to choose the interpretation.
        !           946: 
        !           947: `M-x delete-rectangle'
        !           948:      Delete the text of the region-rectangle, moving any following text
        !           949:      on each line leftward to the left edge of the region-rectangle.
        !           950: 
        !           951: `M-x kill-rectangle'
        !           952:      Similar, but also save the contents of the region-rectangle as the
        !           953:      "last killed rectangle".
        !           954: 
        !           955: `M-x yank-rectangle'
        !           956:      Yank the last killed rectangle with its upper left corner at point.
        !           957: 
        !           958: `M-x open-rectangle'
        !           959:      Insert blank space to fill the space of the region-rectangle. The
        !           960:      previous contents of the region-rectangle are pushed rightward.
        !           961: 
        !           962: `M-x clear-rectangle'
        !           963:      Clear the region-rectangle by replacing its contents with spaces.
        !           964: 
        !           965:    The rectangle operations fall into two classes: commands deleting and
        !           966: moving rectangles, and commands for blank rectangles.
        !           967: 
        !           968:    There are two ways to get rid of the text in a rectangle: you can
        !           969: discard the text (delete it) or save it as the "last killed" rectangle.
        !           970:  The commands for these two ways are `M-x delete-rectangle' and `M-x
        !           971: kill-rectangle'.  In either case, the portion of each line that falls
        !           972: inside the rectangle's boundaries is deleted, causing following text
        !           973: (if any) on the line to move left.
        !           974: 
        !           975:    Note that "killing" a rectangle is not killing in the usual sense;
        !           976: the rectangle is not stored in the kill ring, but in a special place
        !           977: that can only record the most recent rectangle killed.  This is because
        !           978: yanking a rectangle is so different from yanking linear text that
        !           979: different yank commands have to be used and yank-popping is hard to
        !           980: make sense of.
        !           981: 
        !           982:    Inserting a rectangle is the opposite of deleting one.  All you need
        !           983: to specify is where to put the upper left corner; that is done by
        !           984: putting point there.  The rectangle's first line is inserted there, the
        !           985: rectangle's second line is inserted at a point one line vertically
        !           986: down, and so on. The number of lines affected is determined by the
        !           987: height of the saved rectangle.
        !           988: 
        !           989:    To insert the last killed rectangle, type `M-x yank-rectangle'. This
        !           990: can be used to convert single-column lists into double-column lists;
        !           991: kill the second half of the list as a rectangle and then yank it beside
        !           992: the first line of the list.
        !           993: 
        !           994:    There are two commands for working with blank rectangles: `M-x
        !           995: clear-rectangle' to blank out existing text, and `M-x open-rectangle'
        !           996: to insert a blank rectangle.  Clearing a rectangle is equivalent to
        !           997: deleting it and then inserting as blank rectangle of the same size.
        !           998: 
        !           999:    Rectangles can also be copied into and out of registers. *Note
        !          1000: Rectangle Registers: RegRect.
        !          1001: 
        !          1002: 
        !          1003: File: emacs,  Node: Registers,  Next: Display,  Prev: Rectangles,  Up: Top
        !          1004: 
        !          1005: Registers
        !          1006: *********
        !          1007: 
        !          1008:    Emacs "registers" are places you can save text or positions for
        !          1009: later use.  Text saved in a register can be copied into the buffer once
        !          1010: or many times; a position saved in a register is used by moving point
        !          1011: to that position.  Rectangles can also be copied into and out of
        !          1012: registers (*note Rectangles::.).
        !          1013: 
        !          1014:    Each register has a name, which is a single character.  A register
        !          1015: can store either a piece of text or a position or a rectangle, but only
        !          1016: one thing at any given time.  Whatever you store in a register remains
        !          1017: there until you store something else in that register.
        !          1018: 
        !          1019: * Menu:
        !          1020: 
        !          1021: * RegPos::    Saving positions in registers.
        !          1022: * RegText::   Saving text in registers.
        !          1023: * RegRect::   Saving rectangles in registers.
        !          1024: 
        !          1025: `M-x view-register RET R'
        !          1026:      Display a description of what register R contains.
        !          1027: 
        !          1028:    `M-x view-register' reads a register name as an argument and then
        !          1029: displays the contents of the specified register.
        !          1030: 
        !          1031: 
        !          1032: File: emacs,  Node: RegPos,  Next: RegText,  Prev: Registers,  Up: Registers
        !          1033: 
        !          1034: Saving Positions in Registers
        !          1035: =============================
        !          1036: 
        !          1037:    Saving a position records a spot in a buffer so that you can move
        !          1038: back there later.  Moving to a saved position reselects the buffer and
        !          1039: moves point to the spot.
        !          1040: 
        !          1041: `C-x / R'
        !          1042:      Save location of point in register R (`point-to-register').
        !          1043: 
        !          1044: `C-x j R'
        !          1045:      Jump to the location saved in register R (`register-to-point').
        !          1046: 
        !          1047:    To save the current location of point in a register, choose a name R
        !          1048: and type `C-x / R'.  The register R retains the location thus saved
        !          1049: until you store something else in that register.
        !          1050: 
        !          1051:    The command `C-x j R' moves point to the location recorded in
        !          1052: register R.  The register is not affected; it continues to record the
        !          1053: same location.  You can jump to the same position using the same
        !          1054: register any number of times.
        !          1055: 
        !          1056: 
        !          1057: File: emacs,  Node: RegText,  Next: RegRect,  Prev: RegPos,  Up: Registers
        !          1058: 
        !          1059: Saving Text in Registers
        !          1060: ========================
        !          1061: 
        !          1062:    When you want to insert a copy of the same piece of text frequently,
        !          1063: it may be impractical to use the kill ring, since each subsequent kill
        !          1064: moves the piece of text further down on the ring.  It becomes hard to
        !          1065: keep track of what argument is needed to retrieve the same text with
        !          1066: `C-y'.  An alternative is to store the text in a register with `C-x x'
        !          1067: (`copy-to-register') and then retrieve it with `C-x g'
        !          1068: (`insert-register').
        !          1069: 
        !          1070: `C-x x R'
        !          1071:      Copy region into register R (`copy-to-register').
        !          1072: 
        !          1073: `C-x g R'
        !          1074:      Insert text contents of register R (`insert-register').
        !          1075: 
        !          1076:    `C-x x R' stores a copy of the text of the region into the register
        !          1077: named R.  Given a numeric argument, `C-x x' deletes the text from the
        !          1078: buffer as well.
        !          1079: 
        !          1080:    `C-x g R' inserts in the buffer the text from register R. Normally
        !          1081: it leaves point before the text and places the mark after, but with a
        !          1082: numeric argument it puts point after the text and the mark before.
        !          1083: 
        !          1084: 
        !          1085: File: emacs,  Node: RegRect,  Prev: RegText,  Up: Registers
        !          1086: 
        !          1087: Saving Rectangles in Registers
        !          1088: ==============================
        !          1089: 
        !          1090:    A register can contain a rectangle instead of linear text.  The
        !          1091: rectangle is represented as a list of strings.  *Note Rectangles::, for
        !          1092: basic information on rectangles and how rectangles in the buffer are
        !          1093: specified.
        !          1094: 
        !          1095: `C-x r R'
        !          1096:      Copy the region-rectangle into register R
        !          1097:      (`copy-region-to-rectangle'). With numeric argument, delete it as
        !          1098:      well.
        !          1099: 
        !          1100: `C-x g R'
        !          1101:      Insert the rectangle stored in register R (if it contains a
        !          1102:      rectangle) (`insert-register').
        !          1103: 
        !          1104:    The `C-x g' command inserts linear text if the register contains
        !          1105: that, or inserts a rectangle if the register contains one.
        !          1106: 
        !          1107: 
        !          1108: File: emacs,  Node: Display,  Next: Search,  Prev: Registers,  Up: Top
        !          1109: 
        !          1110: Controlling the Display
        !          1111: ***********************
        !          1112: 
        !          1113:    Since only part of a large buffer fits in the window, Emacs tries to
        !          1114: show the part that is likely to be interesting.  The display control
        !          1115: commands allow you to specify which part of the text you want to see.
        !          1116: 
        !          1117: `C-l'
        !          1118:      Clear screen and redisplay, scrolling the selected window to center
        !          1119:      point vertically within it (`recenter').
        !          1120: 
        !          1121: `C-v'
        !          1122:      Scroll forward (a windowful or a specified number of lines)
        !          1123:      (`scroll-up').
        !          1124: 
        !          1125: `M-v'
        !          1126:      Scroll backward (`scroll-down').
        !          1127: 
        !          1128: `ARG C-l'
        !          1129:      Scroll so point is on line ARG (`recenter').
        !          1130: 
        !          1131: `C-x <'
        !          1132:      Scroll text in current window to the left (`scroll-left').
        !          1133: 
        !          1134: `C-x >'
        !          1135:      Scroll to the right (`scroll-right').
        !          1136: 
        !          1137: `C-x $'
        !          1138:      Make deeply indented lines invisible (`set-selective-display').
        !          1139: 
        !          1140: * Menu:
        !          1141: 
        !          1142: * Scrolling::             Moving text up and down in a window.
        !          1143: * Horizontal Scrolling::   Moving text left and right in a window.
        !          1144: * Selective Display::      Hiding lines with lots of indentation.
        !          1145: * Display Vars::           Information on variables for customizing display.
        !          1146: 
        !          1147: 
        !          1148: File: emacs,  Node: Scrolling,  Next: Horizontal Scrolling,  Prev: Display,  Up: Display
        !          1149: 
        !          1150: Scrolling
        !          1151: =========
        !          1152: 
        !          1153:    If a buffer contains text that is too large to fit entirely within a
        !          1154: window that is displaying the buffer, Emacs shows a contiguous section
        !          1155: of the text.  The section shown always contains point.
        !          1156: 
        !          1157:    "Scrolling" means moving text up or down in the window so that
        !          1158: different parts of the text are visible.  Scrolling forward means that
        !          1159: text moves up, and new text appears at the bottom.  Scrolling backward
        !          1160: moves text down and new text appears at the top.
        !          1161: 
        !          1162:    Scrolling happens automatically if you move point past the bottom or
        !          1163: top of the window.  You can also explicitly request scrolling with the
        !          1164: commands in this section.
        !          1165: 
        !          1166: `C-l'
        !          1167:      Clear screen and redisplay, scrolling the selected window to center
        !          1168:      point vertically within it (`recenter').
        !          1169: 
        !          1170: `C-v'
        !          1171:      Scroll forward (a windowful or a specified number of lines)
        !          1172:      (`scroll-up').
        !          1173: 
        !          1174: `M-v'
        !          1175:      Scroll backward (`scroll-down').
        !          1176: 
        !          1177: `ARG C-l'
        !          1178:      Scroll so point is on line ARG (`recenter').
        !          1179: 
        !          1180:    The most basic scrolling command is `C-l' (`recenter') with no
        !          1181: argument.  It clears the entire screen and redisplays all windows.  In
        !          1182: addition, the selected window is scrolled so that point is halfway down
        !          1183: from the top of the window.
        !          1184: 
        !          1185:    The scrolling commands `C-v' and `M-v' let you move all the text in
        !          1186: the window up or down a few lines.  `C-v' (`scroll-up') with an
        !          1187: argument shows you that many more lines at the bottom of the window,
        !          1188: moving the text and point up together as `C-l' might.  `C-v' with a
        !          1189: negative argument shows you more lines at the top of the window.
        !          1190: `Meta-v' (`scroll-down') is like `C-v', but moves in the opposite
        !          1191: direction.
        !          1192: 
        !          1193:    To read the buffer a windowful at a time, use `C-v' with no argument.
        !          1194: It takes the last two lines at the bottom of the window and puts them at
        !          1195: the top, followed by nearly a whole windowful of lines not previously
        !          1196: visible.  If point was in the text scrolled off the top, it moves to the
        !          1197: new top of the window.  `M-v' with no argument moves backward with
        !          1198: overlap similarly.  The number of lines of overlap across a `C-v' or
        !          1199: `M-v' is controlled by the variable `next-screen-context-lines'; by
        !          1200: default, it is two.
        !          1201: 
        !          1202:    Another way to do scrolling is with `C-l' with a numeric argument.
        !          1203: `C-l' does not clear the screen when given an argument; it only scrolls
        !          1204: the selected window.  With a positive argument N, it repositions text
        !          1205: to put point N lines down from the top.  An argument of zero puts point
        !          1206: on the very top line.  Point does not move with respect to the text;
        !          1207: rather, the text and point move rigidly on the screen.  `C-l' with a
        !          1208: negative argument puts point that many lines from the bottom of the
        !          1209: window. For example, `C-u - 1 C-l' puts point on the bottom line, and
        !          1210: `C-u - 5 C-l' puts it five lines from the bottom.  Just `C-u' as
        !          1211: argument, as in `C-u C-l', scrolls point to the center of the screen.
        !          1212: 
        !          1213:    Scrolling happens automatically if point has moved out of the visible
        !          1214: portion of the text when it is time to display.  Usually the scrolling
        !          1215: is done so as to put point vertically centered within the window. 
        !          1216: However, if the variable `scroll-step' has a nonzero value, an attempt
        !          1217: is made to scroll the buffer by that many lines; if that is enough to
        !          1218: bring point back into visibility, that is what is done.
        !          1219: 
        !          1220: 

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