Return to emacs-13 CVS log

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

Annotation of GNUtools/emacs/info/emacs-13, 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: TeX Mode Changes,  Next: Shell Changes,  Prev: Filling Changes,  Up: Version 19
        !            27: 
        !            28: Changes in TeX Mode
        !            29: ===================
        !            30: 
        !            31:    The old TeX mode bindings of `M-{' and `M-}' have been moved to `C-c
        !            32: {' and `C-c }'.  (These commands are `up-list' and `tex-insert-braces';
        !            33: they are the TeX equivalents of `M-(' and `M-)'.)
        !            34: 
        !            35:    The new command `C-c C-o' (`tex-latex-block') inserts a matching
        !            36: `\begin'--`\end' pair.  The new command `C-c C-e'
        !            37: (`tex-close-latex-block') inserts a matching `\end' for the last
        !            38: unterminated `\begin'.
        !            39: 
        !            40:    You can run BibTeX on the current file using `C-c TAB'
        !            41: (`tex-bibtex-file').
        !            42: 
        !            43:    There is a new command `C-c C-v' (`tex-view') for running a DVI
        !            44: previewer.
        !            45: 
        !            46:    You can specify the directory to use for running TeX by setting the
        !            47: variable `tex-directory'.  `"."' is the default value.  If your
        !            48: environment variable `TEXINPUTS' contains relative directory names, or
        !            49: if your files contains `\input' commands with relative file names, then
        !            50: `tex-directory' *must* be `"."' or you will get the wrong results. 
        !            51: Otherwise, it is safe to specify some other directory, such as `/tmp'.
        !            52: 
        !            53:    There is now a third variant of TeX mode, for SliTeX.  This is in
        !            54: addition to the variants for plain TeX and LaTeX.  As before, the
        !            55: correct variant is chosen automatically when you visit a file.
        !            56: 
        !            57: 
        !            58: File: emacs,  Node: Shell Changes,  Next: Spell Changes,  Prev: TeX Mode Changes,  Up: Version 19
        !            59: 
        !            60: Changes in Shell Mode
        !            61: =====================
        !            62: 
        !            63:    Shell mode has been completely replaced with a new implementation.
        !            64: The basic idea is the same: Emacs runs a subshell, and all input and
        !            65: output to the subshell go through the shell buffer.  But the special
        !            66: commands of Shell mode have been redesigned.
        !            67: 
        !            68: `TAB'
        !            69:      Complete the file name before point in the shell buffer
        !            70:      (`comint-dynamic-complete').
        !            71: 
        !            72: `M-?'
        !            73:      To get a list of all possible completions of the file name before,
        !            74:      type `M-?'  (`comint-dynamic-list-completions').
        !            75: 
        !            76: `M-p'
        !            77: `M-n'
        !            78:      There is a new convenient history mechanism for repeating previous
        !            79:      shell inputs.  Use the command `M-p' (`comint-previous-input') to
        !            80:      recall the last input; it copies the text of that input to the
        !            81:      place where you are editing.  If you repeat `M-p', it replaces the
        !            82:      copied input with successively earlier inputs.  `M-n' is similar
        !            83:      but goes in the opposite direction, towards the present
        !            84:      (`comint-next-input').
        !            85: 
        !            86:      When you find the previous input you want, you can resubmit it by
        !            87:      typing RET, or you can edit it first and then resubmit it if you
        !            88:      wish.
        !            89: 
        !            90:      These shell history commands operate outside the minibuffer, but
        !            91:      they are completely analogous to the minibuffer history commands.
        !            92: 
        !            93: `M-r'
        !            94: `M-s'
        !            95:      You can also use `M-r' and `M-s' to search for (respectively)
        !            96:      earlier or later inputs starting with a given string.  First type
        !            97:      the string, then type `M-r' (`comint-previous-matching-input') to
        !            98:      yank a previous input from the history which starts with that
        !            99:      string. You can repeat `M-r' to find successively earlier inputs
        !           100:      starting with the same string.
        !           101: 
        !           102:      You can start moving in the opposite direction (toward more recent
        !           103:      inputs) by typing `M-s' (`comint-next-matching-input') instead of
        !           104:      `M-r'.  As long as you don't use any commands except `M-r' and
        !           105:      `M-s', they keep using the same string that you had entered
        !           106:      initially.
        !           107: 
        !           108:      These commands serve a purpose similar to that of `M-r' and `M-s'
        !           109:      in the minibuffer, but do not work in quite the same way.  We may
        !           110:      change the interface of these commands, as well as that of the
        !           111:      analogous minibuffer commands; one goal will be to make the two
        !           112:      sets of commands compatible.  But we haven't yet figured out which
        !           113:      of the possible interfaces is best.  To find out what interface is
        !           114:      actually supported in Emacs 19, type `C-h f
        !           115:      comint-previous-matching-input RET'.
        !           116: 
        !           117: `C-c C-o'
        !           118:      Kill the last batch of output from a shell command
        !           119:      (`comint-kill-output').  This is useful if a shell command spews
        !           120:      out lots of output that just gets in the way.
        !           121: 
        !           122: `C-c C-r'
        !           123:      Scroll to display the beginning of the last batch of output at the
        !           124:      top of the window; it also moves the cursor there
        !           125:      (`comint-show-output').
        !           126: 
        !           127: `C-a'
        !           128:      If you type `C-a' on a line that starts with a shell prompt, it
        !           129:      moves to the end of the prompt, not to the very beginning of the
        !           130:      line.
        !           131: 
        !           132: `C-d'
        !           133:      Typed at the end of the shell buffer, `C-d' sends EOF to the
        !           134:      subshell.  Typed at any other position in the buffer, `C-d'
        !           135:      deletes a character as usual.
        !           136: 
        !           137: `M-x dirs'
        !           138:      If Emacs gets confused while trying to track changes in the shell's
        !           139:      current directory, type `M-x dirs' to re-synchronize.
        !           140: 
        !           141: `M-x send-invisible'
        !           142:      This command reads a line of text without echoing it, and sends it
        !           143:      to the shell.
        !           144: 
        !           145: `M-x comint-continue-subjob'
        !           146:      If you accidentally suspend your process, use this command to
        !           147:      continue it.
        !           148: 
        !           149: 
        !           150: File: emacs,  Node: Spell Changes,  Next: Tags Changes,  Prev: Shell Changes,  Up: Version 19
        !           151: 
        !           152: Changes in Spell Checking
        !           153: =========================
        !           154: 
        !           155:    Emacs 19 uses the Ispell program for spelling correction instead of
        !           156: the Unix spell program.  Ispell has many advantages; one is that it can
        !           157: be started the first time you check a word, and left running thereafter,
        !           158: which makes further checking much faster.  If you want to get rid of the
        !           159: Ispell process, use `M-x kill-ispell'.
        !           160: 
        !           161:    To check the entire current buffer, use `M-x ispell-buffer'.  Use
        !           162: `M-x ispell-region' to check just the current region.
        !           163: 
        !           164:    Ispell commands often involve interactive replacement of words. You
        !           165: can interrupt the interactive replacement with `C-g'. You can restart
        !           166: it again afterward with `C-u M-$'.
        !           167: 
        !           168:    Interactive replacement shows you one misspelling at a time and asks
        !           169: you what to do.  To answer, type one of the following characters:
        !           170: 
        !           171: `DIGIT'
        !           172:      Replace the word (this time) with one of the displayed near-misses.
        !           173:      The digit you use says which near-miss to use.
        !           174: 
        !           175: `a'
        !           176:      Accept this word this time.
        !           177: 
        !           178: `i'
        !           179:      Insert this word in your private dictionary so that Ispell will
        !           180:      consider it correct it from now on.
        !           181: 
        !           182: `r'
        !           183:      Replace the word this time with a string typed by you.
        !           184: 
        !           185:    When the Ispell process starts, it reads your private dictionary
        !           186: which is the file `~/ispell.words'.  Words that you "insert" with the
        !           187: `i' command are added to that file, but not right away--only at the end
        !           188: of the interactive replacement procedure.
        !           189: 
        !           190:    Use the `M-x reload-ispell' command to reload your private
        !           191: dictionary from `~/ispell.words' if you edit the file outside of Ispell.
        !           192: 
        !           193: 
        !           194: File: emacs,  Node: Mail Changes,  Next: Info Changes,  Prev: Tags Changes,  Up: Version 19
        !           195: 
        !           196: Changes in Mail Reading and Sending
        !           197: ===================================
        !           198: 
        !           199:    `%' is now a word-separator character in Mail mode.  This is because
        !           200: that character frequently appears in addresses.
        !           201: 
        !           202:    If you set the variable `mail-signature' non-`nil', then `mail'
        !           203: inserts the contents of your `.signature' file automatically when it
        !           204: initializes a mail buffer.  If you don't want your signature in a
        !           205: particular message, just delete it from the buffer before you send the
        !           206: message.
        !           207: 
        !           208:    You can specify the text to insert at the beginning of each line when
        !           209: you use `C-c C-y' to yank the message you are replying to.  Set
        !           210: `mail-yank-prefix' to the desired string.  A value of `nil' (the
        !           211: default) means to use indentation, as in Emacs 18.  If you use `C-u' by
        !           212: itself as the prefix argument to `C-c C-y', then it does not insert
        !           213: anything at the beginning of the lines, regardless of the value of
        !           214: `mail-yank-prefix'.
        !           215: 
        !           216:    You can easily convert an Rmail file to system mailbox format with
        !           217: the command `unrmail'.  This command reads two arguments, the name of
        !           218: the Rmail file to convert, and the name of the new mailbox file. The
        !           219: Rmail file is unchanged by this command.
        !           220: 
        !           221:    Rmail now initially positions you at the first message in the Rmail
        !           222: file that you have not seen.  This may not be a message that just
        !           223: arrived; it may have arrived in a previous session during which you did
        !           224: not select it.  You can then read all the unseen messages going
        !           225: forwards.
        !           226: 
        !           227:    When a message that you sent "bounces" back to you, you can retry
        !           228: sending it by typing `C-M-m' (`rmail-retry-failure') on the failure
        !           229: message.
        !           230: 
        !           231:    By contrast, the new command `M-x rmail-resend' is used for
        !           232: forwarding a message and marking it as "resentby" you, with the special
        !           233: header fields `Resent-by:' and `Resent-to:'.
        !           234: 
        !           235:    Another new Rmail command is `<', which moves to the first message.
        !           236: (This is for symmetry with `>'.)  `<' is actually an alias for `j'.
        !           237: 
        !           238:    `e' (`rmail-edit-current-message') is now the command to edit a
        !           239: message.  To expunge, type `x'.  We know this will surprise people some
        !           240: of the time, but the surprise will not be disastrous--if you type `e'
        !           241: meaning to expunge, just type `C-c C-c' to leave Rmail Edit mode, and
        !           242: then type `x'.
        !           243: 
        !           244:    The variable `rmail-output-file-alist' now controls the default for
        !           245: the file to output a message to.
        !           246: 
        !           247:    In the Rmail summary, `C-n' and `C-p' are now ordinary cursor motion
        !           248: commands.  To move in the summary *and* select a new message, use `n'
        !           249: and `p' (which skip deleted messages) or `M-n' and `M-p' (which stop at
        !           250: all messages).  These are, of course, the same commands you would use
        !           251: in the Rmail buffer.
        !           252: 
        !           253: 
        !           254: File: emacs,  Node: Tags Changes,  Next: Mail Changes,  Prev: Spell Changes,  Up: Version 19
        !           255: 
        !           256: Changes in Tags Commands
        !           257: ========================
        !           258: 
        !           259:    `M-.' (`find-tag') and the other commands to find a tag now look
        !           260: first for an exact match in the tags table, and try substring matches
        !           261: only afterward.
        !           262: 
        !           263:    Another change in `M-.' is that it has no effect on what `M-,' will
        !           264: do subsequently.  You can no longer use `M-,' to find the next similar
        !           265: tag; instead, use `M-.' with a prefix argument.
        !           266: 
        !           267:    The new command `find-tag-regexp' successively visits the tags that
        !           268: match a specified regular expression.
        !           269: 
        !           270:    You can now use more than one tags table.  Using `visit-tags-table'
        !           271: to load a new tags table does not discard the other tables previously
        !           272: loaded.  The other tags commands use all the tags tables that are
        !           273: loaded; the first one they use is the one that mentions the current
        !           274: visited file.
        !           275: 
        !           276:    You can specify a precise list of tags tables by setting the variable
        !           277: `tags-table-list' to a list of strings, like this:
        !           278: 
        !           279:      (setq tags-table-list
        !           280:            '("~/emacs" "/usr/local/lib/emacs/src"))
        !           281: 
        !           282: This tells `find-tag' to look at the `TAGS' files in your `~/emacs'
        !           283: directory and in the `/usr/local/lib/emacs/src' directory.  The order
        !           284: depends on which file you are in and which tags table mentions that
        !           285: file, as explained above.
        !           286: 
        !           287:    You can now use the tags table for completion of names during
        !           288: ordinary editing.  The command `M-TAB' (except in Emacs Lisp and Lisp
        !           289: Interaction modes) completes the identifier in the buffer before point,
        !           290: using the set of all tags as the list of possible completions.
        !           291: 
        !           292:    `tags-query-replace' and `tags-search' now create buffers only
        !           293: temporarily for the files that they have to search (those which are not
        !           294: already visited in Emacs buffers).  If one of these files contains a
        !           295: match for the search pattern, then its buffer continues to exist;
        !           296: otherwise, it is killed.
        !           297: 
        !           298: 
        !           299: File: emacs,  Node: Info Changes,  Next: Dired Changes,  Prev: Mail Changes,  Up: Version 19
        !           300: 
        !           301: Changes in Info
        !           302: ===============
        !           303: 
        !           304:    There are new commands in Info mode.
        !           305: 
        !           306: `]'
        !           307:      Move forward a node, going up and down levels as needed in a
        !           308:      depth-first tree walk.  This command treats all the nodes in the
        !           309:      file as forming a single sequence in which the "children" of a
        !           310:      node follow that node. It is the equivalent of reading a printed
        !           311:      manual sequentially.
        !           312: 
        !           313: `['
        !           314:      Similar, but move backward.
        !           315: 
        !           316: `<'
        !           317:      Move to the top node of the current Info file.
        !           318: 
        !           319: `>'
        !           320:      Move to the last node of the file.
        !           321: 
        !           322: `SPC'
        !           323:      Scroll through this node, or advance to the next node in
        !           324:      depth-first order (like `]').
        !           325: 
        !           326: `i STRING RET'
        !           327:      Move to the node associated with STRING in the index or indices of
        !           328:      this manual.  If there is more than one match for STRING, the `i'
        !           329:      command finds the first match.
        !           330: 
        !           331: `,'
        !           332:      Find the next match for the string in the previous `i' command, and
        !           333:      go to that node.
        !           334: 
        !           335:    If you click the middle mouse button near a cross-reference, menu
        !           336: item or node pointer while in Info, you will go to the node which is
        !           337: referenced.
        !           338: 
        !           339:    The variable `Info-directory-list' specifies a list of directory
        !           340: names that contain Info files.  Each time Info looks for an Info file,
        !           341: it searches all these directories.  This makes it easy to install the
        !           342: Info files that come with various packages.  You can specify the path
        !           343: with the environment variable `INFOPATH'.
        !           344: 
        !           345: 
        !           346: File: emacs,  Node: Dired Changes,  Next: GNUS,  Prev: Info Changes,  Up: Version 19
        !           347: 
        !           348: Changes in Dired
        !           349: ================
        !           350: 
        !           351:    Dired has many new features which allow you to do these things:
        !           352: 
        !           353:    * Make distinguishable types of marks for different operations.
        !           354: 
        !           355:    * Rename, copy, or make links to many files at once.
        !           356: 
        !           357:    * Display contents of subdirectories in the same Dired buffer as the
        !           358:      parent directory.
        !           359: 
        !           360: * Menu:
        !           361: 
        !           362: * Marks in Dired::         Flagging for deletion vs marking for other actions.
        !           363: * Multiple Files::         How to copy, rename, print, compress, etc.
        !           364:                              either one file or several files.
        !           365: * Shell Commands in Dired:: Running a shell command on the marked files.
        !           366: * Dired Regexps::          Using patterns to rename multiple files.
        !           367: * Dired Case Conversion::   Converting file names to upper or lower case.
        !           368: * Comparison in Dired::            Running `diff' by way of Dired.
        !           369: * Subdirectories in Dired:: Adding subdirectories to the Dired buffer.
        !           370: * Hiding Subdirectories::   Making subdirectories visible or invisible.
        !           371: * Editing Dired Buffer::    Discarding lines for files of no interest.
        !           372: * Dired and Find::         Using `find' to select the files for Dired to show.
        !           373: 
        !           374: 
        !           375: File: emacs,  Node: Marks in Dired,  Next: Multiple Files,  Up: Dired Changes
        !           376: 
        !           377: Setting and Clearing Marks
        !           378: --------------------------
        !           379: 
        !           380:    There are now two kinds of marker that you can put on a file in
        !           381: Dired: `D' for deletion, and `*' for any other kind of operation. The
        !           382: `x' command deletes only files marked with `D', and most other Dired
        !           383: commands operate only on the files marked with `*'.
        !           384: 
        !           385:    To mark files with `D' (also called "flagging" the files), you can
        !           386: use `d' as usual.  Here are some commands for marking with `*' (and
        !           387: also for unmarking):
        !           388: 
        !           389: `m'
        !           390:      Mark the current file with `*', for an operation other than
        !           391:      deletion (`dired-mark').
        !           392: 
        !           393: `*'
        !           394:      Mark all executable files (`dired-mark-executables'). With a
        !           395:      prefix argument, unmark all those files.
        !           396: 
        !           397: `@'
        !           398:      Mark all symbolic links (`dired-mark-symlinks').  With a prefix
        !           399:      argument, unmark all those files.
        !           400: 
        !           401: `/'
        !           402:      Mark all files which are actually directories, except for `.' and
        !           403:      `..' (`dired-mark-directories').  With a prefix argument, unmark
        !           404:      all those files.
        !           405: 
        !           406: `M-DEL'
        !           407:      Remove a specific or all marks from every file
        !           408:      (`dired-unmark-all-files'). With an argument, query for each
        !           409:      marked file. Type your help character, usually `C-h', at that time
        !           410:      for help.
        !           411: 
        !           412: `c OLD NEW'
        !           413:      Replace all marks that use the character OLD with marks that use
        !           414:      the character NEW.  You can use almost any character as a mark
        !           415:      character by means of this command, to distinguish various classes
        !           416:      of files.  If OLD is ` ', then the command operates on all
        !           417:      unmarked files; if NEW is ` ', then the command unmarks the files
        !           418:      it acts on.
        !           419: 
        !           420:      To illustrate the power of this command, here is how to put `*'
        !           421:      marks on all the files that were unmarked, while unmarking all
        !           422:      those that had `*' marks:
        !           423: 
        !           424:           c * t c SPC * c t SPC
        !           425: 
        !           426: 
        !           427: File: emacs,  Node: Multiple Files,  Next: Shell Commands in Dired,  Prev: Marks in Dired,  Up: Dired Changes
        !           428: 
        !           429: Operating on Multiple Files
        !           430: ---------------------------
        !           431: 
        !           432:    The Dired commands to operate on files (rename them, copy them, and
        !           433: so on) have been generalized to work on multiple files.  There are also
        !           434: some additional commands in this series.
        !           435: 
        !           436:    All of these commands use the same convention to decide which files
        !           437: to manipulate:
        !           438: 
        !           439:    * If you give the command a numeric prefix argument N, it operates
        !           440:      on the next N files, starting with the current file.
        !           441: 
        !           442:    * Otherwise, if there are marked files, the commands operate on all
        !           443:      the marked files.
        !           444: 
        !           445:    * Otherwise, the command operates on the current file only.
        !           446: 
        !           447:    Here are the commands that operate on multiple files in this way:
        !           448: 
        !           449: `C'
        !           450:      Copy the specified files (`dired-do-copy').  You must specify a
        !           451:      directory to copy into, or (if copying a single file) a new name.
        !           452: 
        !           453:      If `dired-copy-preserve-time' is non-`nil', then copying with this
        !           454:      command sets the modification time of the new file to be the same
        !           455:      as that of the old file.
        !           456: 
        !           457: `R'
        !           458:      Rename the specified files (`dired-do-rename').  You must specify
        !           459:      a directory to rename into, or (if renaming a single file) a new
        !           460:      name.
        !           461: 
        !           462:      Dired automatically changes the visited file name of buffers
        !           463:      associated with renamed files so that they refer to the new names.
        !           464: 
        !           465: `H'
        !           466:      Make hard links to the specified files (`dired-do-hardlink'). You
        !           467:      must specify a directory to make the links in, or (if making just
        !           468:      one link) the name to give the link.
        !           469: 
        !           470: `S'
        !           471:      Make symbolic links to the specified files (`dired-do-symlink').
        !           472:      You must specify a directory to make the links in, or (if making
        !           473:      just one link) the name to give the link.
        !           474: 
        !           475: `M'
        !           476:      Change the mode (also called "permission bits") of the specified
        !           477:      files (`dired-do-chmod').  This calls the `chmod' program, so you
        !           478:      can describe the desired mode change with any argument that
        !           479:      `chmod' would handle.
        !           480: 
        !           481: `G'
        !           482:      Change the group of the specified files (`dired-do-chgrp').
        !           483: 
        !           484: `O'
        !           485:      Change the owner of the specified files (`dired-do-chown'). (On
        !           486:      most systems, only the superuser can do this.)
        !           487: 
        !           488:      The variable `dired-chown-program' specifies the name of the
        !           489:      program to use to do the work (different systems put `chown' in
        !           490:      different places.
        !           491: 
        !           492: `Z'
        !           493:      Compress or uncompress the specified files. If the file appears to
        !           494:      be a compressed file, it is uncompressed; otherwise, it is
        !           495:      compressed (`dired-do-compress').
        !           496: 
        !           497: `L'
        !           498:      Load the specified Emacs Lisp files (`dired-do-load').
        !           499: 
        !           500: `B'
        !           501:      Byte compile the specified Emacs Lisp files
        !           502:      (`dired-do-byte-compile').
        !           503: 
        !           504: `P'
        !           505:      Print the specified files (`dired-do-print').  This command uses
        !           506:      the variables `lpr-command' and `lpr-switches' just as `lpr-file'
        !           507:      does (*note Hardcopy::.).
        !           508: 
        !           509: 
        !           510: File: emacs,  Node: Shell Commands in Dired,  Next: Dired Regexps,  Prev: Multiple Files,  Up: Dired Changes
        !           511: 
        !           512: Shell Commands in Dired
        !           513: -----------------------
        !           514: 
        !           515:    The dired command `!' (`dired-do-shell-command') reads a shell
        !           516: command string in the minibuffer and runs the shell command on all the
        !           517: specified files.  There are two ways of applying a shell command to
        !           518: multiple files:
        !           519: 
        !           520:    * If you use `*' in the shell command, then it runs just once, with
        !           521:      the list of file names substituted for the `*'.
        !           522: 
        !           523:      Thus, `! tar cf foo.tar * RET' runs `tar' on the entire list of
        !           524:      file names, putting them into one tar file `foo.tar'.  The file
        !           525:      names are inserted in the order that they appear in the Dired
        !           526:      buffer.
        !           527: 
        !           528:    * If the command string doesn't contain `*', then it runs once *for
        !           529:      each file*, with the file name attached at the end.
        !           530: 
        !           531:      For example, `! uudecode RET' runs `uudecode' on each file.
        !           532: 
        !           533:    What if you want to run the shell command once for each file but with
        !           534: the file name inserted in the middle?  Or if you want to use the file
        !           535: names in a more complicated fashion?  Use a shell loop.  For example,
        !           536: this shell command would run `uuencode' on each of the specified files,
        !           537: writing the output into a corresponding `.uu' file:
        !           538: 
        !           539:      for file in *; uuencode $file $file >$file.uu; done
        !           540: 
        !           541:    The working directory for the shell command is the top level
        !           542: directory of the Dired buffer.
        !           543: 
        !           544:    The `!' command does not attempt to update the Dired buffer to show
        !           545: new or modified files, because it doesn't know what those files might
        !           546: be.  Type `g' to update the Dired buffer.
        !           547: 
        !           548: 
        !           549: File: emacs,  Node: Dired Regexps,  Next: Dired Case Conversion,  Prev: Shell Commands in Dired,  Up: Dired Changes
        !           550: 
        !           551: Regular Expression File Name Substitution
        !           552: -----------------------------------------
        !           553: 
        !           554:    Here are commands that select files according to a regular
        !           555: expression:
        !           556: 
        !           557: `% m REGEXP RET'
        !           558:      Mark all files whose names match the regular expression REGEXP
        !           559:      (`dired-mark-files-regexp').
        !           560: 
        !           561:      Only the non-directory part of the file name is used in matching. 
        !           562:      Use `^' and `$' to anchor matches.  Exclude subdirs by hiding them
        !           563:      (*note Hiding Subdirectories::.).
        !           564: 
        !           565: `% d REGEXP RET'
        !           566:      Flag for deletion all files whose names match the regular
        !           567:      expression REGEXP (`dired-flag-files-regexp').
        !           568: 
        !           569: `% R FROM RET TO RET'
        !           570: `% C FROM RET TO RET'
        !           571: `% H FROM RET TO RET'
        !           572: `% S FROM RET TO RET'
        !           573:      These four commands rename, copy, make hard links and make soft
        !           574:      links, in each case computing the new name by regular expression
        !           575:      substitution from the name of the old file.
        !           576: 
        !           577:    The four regular expression substitution commands effectively perform
        !           578: `query-replace-regexp' on the selected file names in the Dired buffer. 
        !           579: They read two arguments: a regular expression FROM, and a substitution
        !           580: pattern TO.  Each selected file name is matched against the regular
        !           581: expression, and then the part which matched is replaced with the
        !           582: substitution pattern.  You can use `\&' and `\DIGIT' in the
        !           583: substitution pattern to refer to all or part of the old file name.
        !           584: 
        !           585:    Thus, `% R ^.*$ RET x-\& RET' renames each selected file by
        !           586: prepending `x-' to its name.  The inverse of this is to remove `x-'
        !           587: from the front of each file name.  One way to do that is `% R ^x-.*$
        !           588: RET \& RET'; another is `% R ^x- RET RET'.  (Use `^' and `$' to anchor
        !           589: matches that should span the whole filename.)
        !           590: 
        !           591:    If the regular expression matches more than once in a file name,
        !           592: only the first match is replaced.
        !           593: 
        !           594:    Normally, the replacement process does not consider the directory
        !           595: names; it operates on the file name within the directory.  If you
        !           596: specify a prefix argument of zero, then replacement affects the entire
        !           597: file name.
        !           598: 
        !           599:    Often you will want to apply the command to all files matching the
        !           600: same REGEXP that you use in the command.  To do this, mark those files
        !           601: with `% m REGEXP RET', then use the same regular expression in `% R'. 
        !           602: To make this easier, `% R' uses the last regular expression specified
        !           603: in a `%' command as a default.
        !           604: 
        !           605: 
        !           606: File: emacs,  Node: Dired Case Conversion,  Next: Comparison in Dired,  Prev: Dired Regexps,  Up: Dired Changes
        !           607: 
        !           608: Dired Case Conversion
        !           609: ---------------------
        !           610: 
        !           611:    Here are commands for changing the case of selected files:
        !           612: 
        !           613: `% u'
        !           614:      Rename each of the selected files to an upper case name
        !           615:      (`dired-upcase').
        !           616: 
        !           617: `% l'
        !           618:      Rename each of the selected files to a lower case name
        !           619:      (`dired-downcase').
        !           620: 
        !           621: 
        !           622: File: emacs,  Node: Comparison in Dired,  Next: Subdirectories in Dired,  Prev: Dired Case Conversion,  Up: Dired Changes
        !           623: 
        !           624: File Comparison with Dired
        !           625: --------------------------
        !           626: 
        !           627:    Here are two commands to run `diff' on selected files:
        !           628: 
        !           629: `='
        !           630:      Compare the current file with another file (the file at the mark),
        !           631:      by running the `diff' program (`dired-diff').  The file at the
        !           632:      mark is the first argument of `diff', and the file at point is the
        !           633:      second argument.
        !           634: 
        !           635: `M-='
        !           636:      Compare the current file with its backup file
        !           637:      (`dired-backup-diff'). If there are several numerical backups, use
        !           638:      the most recent one.  If this file is a backup, compare it to its
        !           639:      original.  The backup file is the first file given to `diff'.
        !           640: 
        !           641: 
        !           642: File: emacs,  Node: Subdirectories in Dired,  Next: Hiding Subdirectories,  Prev: Comparison in Dired,  Up: Dired Changes
        !           643: 
        !           644: Subdirectories in Dired
        !           645: -----------------------
        !           646: 
        !           647:    One Dired buffer can now display more than one directory.
        !           648: 
        !           649:    The simplest way to include multiple directories is to specify the
        !           650: options `-lR' for running `ls'.  That produces a recursive directory
        !           651: listing showing all subdirectories, all within the same Dired buffer.
        !           652: 
        !           653:    But the simplest way is not usually the most convenient way--usually
        !           654: the complete recursive listing is more than you want.  So there is a
        !           655: Dired command to insert a single subdirectory into the Dired buffer:
        !           656: 
        !           657: `i'
        !           658:      Use the `i' (`dired-maybe-insert-subdir') command on a line that
        !           659:      describes a file which is a directory.  It inserts the contents of
        !           660:      that directory into the same Dired buffer.  Inserted subdirectory
        !           661:      contents follow the top-level directory of the Dired buffer, just
        !           662:      as they do in `ls -lR' output.
        !           663: 
        !           664:      If the subdirectory's contents are already present in the buffer,
        !           665:      the `i' command just moves to it (type `l' (`dired-do-redisplay')
        !           666:      to refresh it).  It sets the Emacs mark before moving, so `C-x
        !           667:      C-x' takes you back to the old position in the buffer.
        !           668: 
        !           669:    When you have subdirectories in the Dired buffer, you can use the
        !           670: page motion commands `C-x [' and `C-x ]' to move by entire directories.
        !           671: 
        !           672:    The following commands move up and down in the tree of directories
        !           673: in one Dired buffer:
        !           674: 
        !           675: `C-M-u'
        !           676:      Go up to the parent directory's headerline (`dired-tree-up').
        !           677: 
        !           678: `C-M-d'
        !           679:      Go down in the tree, to the first subdirectory's headerline
        !           680:      (`dired-tree-down').
        !           681: 
        !           682:    The following commands move forwards and backwards to subdirectory
        !           683: headerlines:
        !           684: 
        !           685: `C-M-n'
        !           686:      Go to next subdirectory headerline, regardless of level
        !           687:      (`dired-next-subdir').
        !           688: 
        !           689: `C-M-p'
        !           690:      Go to previous subdirectory headerline, regardless of level
        !           691:      (`dired-prev-subdir').
        !           692: 
        !           693: 
        !           694: File: emacs,  Node: Hiding Subdirectories,  Next: Editing Dired Buffer,  Prev: Subdirectories in Dired,  Up: Dired Changes
        !           695: 
        !           696: Hiding Subdirectories
        !           697: ---------------------
        !           698: 
        !           699:    "Hiding" a subdirectory means to make it invisible, except for its
        !           700: headerline.  Files inside a hidden subdirectory are never considered by
        !           701: Dired.  For example, the commands to operate on marked files ignore
        !           702: files in hidden directories even if they are marked.  Thus you can use
        !           703: hiding to temporarily exclude subdirectories from operations without
        !           704: having to remove the markers.
        !           705: 
        !           706:    The hiding commands toggle; that is they unhide what was hidden and
        !           707: vice versa.
        !           708: 
        !           709: `$'
        !           710:      Hide or reveal the current subdirectory and move point to the next
        !           711:      subdirectory (`dired-hide-subdir').  A prefix argument serves as a
        !           712:      repeat count.
        !           713: 
        !           714: `M-$'
        !           715:      Hide all subdirectories, leaving only their header lines
        !           716:      (`dired-hide-all').  Or, if any subdirectory is currently hidden,
        !           717:      make all subdirectories visible again.  You can use this command
        !           718:      to get an overview in very deep directory trees or to move quickly
        !           719:      to subdirectories far away.
        !           720: 
        !           721: 
        !           722: File: emacs,  Node: Editing Dired Buffer,  Next: Dired and Find,  Prev: Hiding Subdirectories,  Up: Dired Changes
        !           723: 
        !           724: Editing the Dired Buffer
        !           725: ------------------------
        !           726: 
        !           727: `l'
        !           728:      Update the specified files in a Dired buffer.  This means reading
        !           729:      their current status from the file system and changing the buffer
        !           730:      to reflect it properly (`dired-do-redisplay').
        !           731: 
        !           732:      If you use this command on a subdirectory header line, it updates
        !           733:      the contents of the subdirectory.
        !           734: 
        !           735: `g'
        !           736:      Update the entire contents of the Dired buffer (`revert-buffer'). 
        !           737:      Preserve all marks except for those on files that have vanished. 
        !           738:      Hidden subdirectories are updated but remain hidden.
        !           739: 
        !           740: `k'
        !           741:      Kill all marked lines (`dired-do-kill-lines').  With a prefix
        !           742:      argument, kill that many lines starting with the current line.
        !           743: 
        !           744:      This command does not delete files; it just deletes text from the
        !           745:      Dired buffer.
        !           746: 
        !           747:      If you kill the line for a file that is a directory, then its
        !           748:      contents are also deleted from the buffer.  Typing `C-u k' on the
        !           749:      header line for a subdirectory is another way to delete a
        !           750:      subdirectory from the Dired buffer.
        !           751: 
        !           752:      The `g' command will bring back any individual lines that you have
        !           753:      killed in this way, but not subdirectories--you must use `i' to
        !           754:      reinsert each subdirectory.
        !           755: 
        !           756: 
        !           757: File: emacs,  Node: Dired and Find,  Prev: Editing Dired Buffer,  Up: Dired Changes
        !           758: 
        !           759: Dired and `find'
        !           760: ----------------
        !           761: 
        !           762:    You can select a set of files for display in a Dired buffer more
        !           763: flexibly by using the `find' utility to choose the files.
        !           764: 
        !           765:    To search for files with names matching a wildcard pattern use
        !           766: `find-name-dired'.  Its arguments are DIRECTORY and PATTERN.  It
        !           767: selects all the files in DIRECTORY or its subdirectories whose own
        !           768: names match PATTERN.
        !           769: 
        !           770:    The files thus selected are displayed in a Dired buffer in which the
        !           771: ordinary Dired commands are available.
        !           772: 
        !           773:    If you want to test the contents of files, rather than their names,
        !           774: use `find-grep-dired'.  This command takes two minibuffer arguments,
        !           775: DIRECTORY and REGEXP; it selects all the files in DIRECTORY or its
        !           776: subdirectories that contain a match for REGEXP.  It works by running
        !           777: `find' and `grep'.
        !           778: 
        !           779:    The most general command in this series is `find-dired', which lets
        !           780: you specify any condition that `find' can test.  It takes two
        !           781: minibuffer arguments, DIRECTORY and FIND-ARGS; it runs `find' in
        !           782: DIRECTORY with FIND-ARGS as the arguments to `find' that specify which
        !           783: files to accept.  To use this command, you need to know how to use
        !           784: `find'.
        !           785: 
        !           786: 
        !           787: File: emacs,  Node: GNUS,  Next: Calendar/Diary,  Prev: Dired Changes,  Up: Version 19
        !           788: 
        !           789: GNUS
        !           790: ====
        !           791: 
        !           792:    GNUS is an Emacs subsystem for reading and responding to netnews. 
        !           793: You can use GNUS to browse through news groups, look at summaries of
        !           794: articles in specific group, and read articles of interest.  You can
        !           795: respond to authors or write replies to all the readers of a news group.
        !           796: 
        !           797:    This document introduces GNUS and describes several basic features.
        !           798: Full documentation will appear in `The GNU Emacs Extensions Manual'.
        !           799: 
        !           800:    To start GNUS, type `M-x gnus RET'.
        !           801: 
        !           802: * Menu:
        !           803: 
        !           804: * Buffers of GNUS::   The Newsgroups, Summary and Article buffers.
        !           805: * GNUS Startup::      What you should know about starting GNUS.
        !           806: * Summary of GNUS::   A short description of the basic GNUS commands.
        !           807: 
        !           808: 
        !           809: File: emacs,  Node: Buffers of GNUS,  Next: GNUS Startup,  Up: GNUS
        !           810: 
        !           811: GNUS's Three Buffers
        !           812: --------------------
        !           813: 
        !           814:    GNUS creates and uses three Emacs buffers, each with its own
        !           815: particular purpose and its own major mode.
        !           816: 
        !           817:    The "Newsgroup buffer" contains a list of newsgroups.  This is the
        !           818: first buffer that GNUS displays when it starts up.  Normally the list
        !           819: contains only the newsgroups to which you subscribe (which are listed in
        !           820: your `.newsrc' file) and which contain unread articles.  Use this
        !           821: buffer to select a specific newsgroup.
        !           822: 
        !           823:    The "Summary buffer" lists the articles in a single newsgroup,
        !           824: including their subjects, their numbers, and who posted them.  GNUS
        !           825: creates a Summary buffer for a newsgroup when you select the group in
        !           826: the Newsgroup buffer.  Use this buffer to select an article, and to move
        !           827: around in an article.
        !           828: 
        !           829:    The "Article buffer" displays the text of an article.  You rarely
        !           830: need to select this buffer because you can read the text while keeping
        !           831: the Summary buffer selected.
        !           832: 
        !           833: 
        !           834: File: emacs,  Node: GNUS Startup,  Next: Summary of GNUS,  Prev: Buffers of GNUS,  Up: GNUS
        !           835: 
        !           836: When GNUS Starts Up
        !           837: -------------------
        !           838: 
        !           839:    At startup, GNUS reads your `.newsrc' news initialization file and
        !           840: attempts to communicate with the local news server, which is a
        !           841: repository of news articles.  The news server need not be the same
        !           842: computer you are logged in on.
        !           843: 
        !           844:    If you start GNUS and connect to the server, but do not see any
        !           845: newsgroups listed in the Newsgroup buffer, type `L' to get a listing of
        !           846: all the newsgroups.  Then type `u' to unsubscribe from particular
        !           847: newsgroups.  (Move the cursor using `n' and `p' or the usual Emacs
        !           848: commands.)  When you quit with `q', GNUS automatically records the
        !           849: subscribed groups in your `.newsrc' initialization file.  (You do not
        !           850: have to edit this file yourself, although you may.) Next time you start
        !           851: GNUS, you will see only the subscribed groups.
        !           852: 
        !           853: 
        !           854: File: emacs,  Node: Summary of GNUS,  Prev: GNUS Startup,  Up: GNUS
        !           855: 
        !           856: Summary of GNUS Commands
        !           857: ------------------------
        !           858: 
        !           859:    Reading news is a two step process:
        !           860: 
        !           861:   1. Choose a newsgroup in the Newsgroup buffer.
        !           862: 
        !           863:   2. Choose an article in the Summary buffer.  The article is displayed
        !           864:      in the Article buffer in a large window, below the Summary buffer
        !           865:      in its small window.
        !           866: 
        !           867:    Each buffer has commands particular to it, but commands that do the
        !           868: same things have similar keybindings.  Here are commands for the
        !           869: Newsgroup and Summary buffers:
        !           870: 
        !           871: `z'
        !           872:      In the Newsgroup buffer, suspend GNUS.  You can return to GNUS
        !           873:      later by selecting the Newsgroup buffer and typing `g' to get
        !           874:      newly arrived articles.
        !           875: 
        !           876: `q'
        !           877:      In the Newsgroup buffer, update your `.newsrc' initialization file
        !           878:      and quit GNUS.
        !           879: 
        !           880:      In the Summary buffer, exit the current newsgroup and return to the
        !           881:      Newsgroup buffer.  Thus, typing `q' twice quits GNUS.
        !           882: 
        !           883: `L'
        !           884:      In the Newsgroup buffer, list all the newsgroups available on your
        !           885:      news server.  This may be a long list!
        !           886: 
        !           887: `l'
        !           888:      In the Newsgroup buffer, list only the newsgroups to which you
        !           889:      subscribe and which contain unread articles.
        !           890: 
        !           891: `u'
        !           892:      In the Newsgroup buffer, unsubscribe from (or subscribe to) the
        !           893:      newsgroup listed in the line that point is on.  When you quit GNUS
        !           894:      by typing `q', GNUS lists your subscribed-to newsgroups in your
        !           895:      `.newsrc' file.  The next time you start GNUS, you see only the
        !           896:      newsgroups listed in your `.newsrc' file.
        !           897: 
        !           898:      You may also edit your `.newsrc' file directly in Emacs.  First
        !           899:      quit GNUS, then visit the `.newsrc' file.  For example, you can
        !           900:      remove all the `alt.' groups by going to the beginning of the file
        !           901:      and typing `M-x flush-lines RET alt RET'.  Next time you start
        !           902:      GNUS, you will see only the newsgroups still listed in the
        !           903:      `.newsrc' file.
        !           904: 
        !           905: `SPC'
        !           906:      In the Newsgroup buffer, select the group on the line under the
        !           907:      cursor and display the first unread article in that group.
        !           908: 
        !           909:      In the Summary buffer,
        !           910: 
        !           911:         - Select the article on the line under the cursor if none is
        !           912:           selected.
        !           913: 
        !           914:         - Scroll the text of the article if one is selected.
        !           915: 
        !           916:         - Select the next unread article if at the end of the current
        !           917:           article.
        !           918: 
        !           919:      Thus, you can move through all the articles by repeatedly typing
        !           920:      SPC.
        !           921: 
        !           922: `DEL'
        !           923:      In the Newsgroup Buffer, move point to the previous newsgroup
        !           924:      containing unread articles.
        !           925: 
        !           926:      In the Summary buffer, scroll the text of the article backwards.
        !           927: 
        !           928: `n'
        !           929:      Move point to the next unread newsgroup, or select the next unread
        !           930:      article.
        !           931: 
        !           932: `p'
        !           933:      Move point to the previous unread newsgroup, or select the previous
        !           934:      unread article.
        !           935: 
        !           936: `C-n'
        !           937: `C-p'
        !           938:      Move point to the next or previous item, even if it is marked as
        !           939:      read. This does not select the article or newsgroup on that line.
        !           940: 
        !           941: `s'
        !           942:      In the Summary buffer, do an incremental search of the current
        !           943:      text in the Article buffer, just as if you switched to the Article
        !           944:      buffer and typed `C-s'.
        !           945: 
        !           946: `M-s REGEXP RET'
        !           947:      In the Summary buffer, search forward for articles containing a
        !           948:      match for REGEXP.
        !           949: 
        !           950: `C-c C-s C-n'
        !           951: `C-c C-s C-s'
        !           952: `C-c C-s C-d'
        !           953: `C-c C-s C-a'
        !           954:      In the Summary buffer, sort the list of articles by number,
        !           955:      subject, date, or author.
        !           956: 
        !           957: `C-M-n'
        !           958: `C-M-p'
        !           959:      In the Summary buffer, read the next or previous article with the
        !           960:      same subject as the current article.
        !           961: 
        !           962: 
        !           963: File: emacs,  Node: Calendar/Diary,  Next: Version Control,  Prev: GNUS,  Up: Version 19
        !           964: 
        !           965: Calendar and Diary
        !           966: ==================
        !           967: 
        !           968:    The calendar facility in Emacs 19 is almost completely new, and it
        !           969: comes with a diary feature.  You can use the diary to keep track of
        !           970: appointments, anniversaries, and other events.
        !           971: 
        !           972:    To use the diary, you must write diary entries in a particular file,
        !           973: called your "diary file".  Its name is `~/diary'.  Emacs displays the
        !           974: entries for particular dates by finding them in the diary file,
        !           975: formatting them, and displaying them in a diary display buffer.
        !           976: 
        !           977: * Menu:
        !           978: 
        !           979: * Calendar::                   New features of the calendar proper.
        !           980: * Entries: Diary Entries.      The location and form of a diary entry.
        !           981: * New Entries::                        Inserting diary entries using the calendar.
        !           982: * Displaying Diary::            How to display diary entries from the calendar.
        !           983: * European Calendar Style ::    Day-month-year style for dates.
        !           984: * Simple and Fancy::            The diary has two modes for display.
        !           985: * Other Diary Features::        The diary has many advanced commands.
        !           986: * Startup Diary::              How to display your diary when you start Emacs.
        !           987: * Printing Diary::             Print selected entries of the diary.
        !           988: 
        !           989: 
        !           990: File: emacs,  Node: Calendar,  Next: Diary Entries,  Up: Calendar/Diary
        !           991: 
        !           992: Calendar
        !           993: --------
        !           994: 
        !           995:    In Emacs 19 you can use ordinary Emacs cursor commands to move
        !           996: through the calendar, which scrolls automatically to display different
        !           997: months or different years.  Character motion translates to days, line
        !           998: motion to weeks, sentence and paragraph motion to months, and page
        !           999: motion to years.  The vertical and horizontal scroll commands also
        !          1000: handle the calendar suitably.
        !          1001: 
        !          1002:    `p d' displays the selected date as a day within the year.  `g d'
        !          1003: selects a date given as month, day, year.  Type `.' to go back to
        !          1004: today's date.
        !          1005: 
        !          1006:    The command `M-=', which normally gives the number of lines in the
        !          1007: region, in Calendar mode gives the number of days in the region
        !          1008: (`calendar-count-days-region').
        !          1009: 
        !          1010:    The calendar facility also knows about other important calendars. 
        !          1011: The commands for these come in pairs; the commands to convert *to*
        !          1012: another calendar start with the `p' prefix (short for "print"), and the
        !          1013: commands to convert from another calendar start with the `g' prefix
        !          1014: (short for "go to").  Here is a complete list:
        !          1015: 
        !          1016: `g a', `p a'
        !          1017:      The astronomical calendar, a simple count of days elapsed since
        !          1018:      noon, Monday, January 1, 4713 B.C. on the Julian calendar.  The
        !          1019:      number of days elapsed is also called the "Julian day number"
        !          1020:      (`calendar-goto-astro-date', `calendar-print-astro-date').
        !          1021: 
        !          1022: `g c', `p c'
        !          1023:      ISO commercial calendar
        !          1024:      (`calendar-goto-iso-date', `calendar-print-iso-date').
        !          1025: 
        !          1026: `g f', `p f'
        !          1027:      French revolutionary calendar
        !          1028:      (`calendar-goto-french-date',
        !          1029:      `calendar-print-french-date').
        !          1030: 
        !          1031: `g h', `p h'
        !          1032:      Hebrew calendar
        !          1033:      (`calendar-goto-hebrew-date',
        !          1034:      `calendar-print-hebrew-date').
        !          1035: 
        !          1036: `g i', `p i'
        !          1037:      Islamic calendar
        !          1038:      (`calendar-goto-islamic-date',
        !          1039:      `calendar-print-islamic-date').
        !          1040: 
        !          1041: `g j', `p j'
        !          1042:      Julian calendar
        !          1043:      (`calendar-goto-julian-date',
        !          1044:      `calendar-print-julian-date').
        !          1045: 
        !          1046: `p m'
        !          1047:      Mayan calendar (`calendar-print-mayan-date').
        !          1048: 
        !          1049:    The calendar also knows the dates of standard holidays.  Type `h'
        !          1050: (`calendar-cursor-holidays') to display a list of holidays for the
        !          1051: selected date.  This list appears in another window.  Type `x'
        !          1052: (`mark-calendar-holidays') to mark each day that is a holiday with `*'
        !          1053: in the calendar itself.  The command `u' (`calendar-unmark') turns off
        !          1054: this marking.
        !          1055: 
        !          1056:    At any time, you can use `M-x holidays' to display a list of
        !          1057: holidays for the present month and the preceding and following months.
        !          1058: 
        !          1059: 
        !          1060: File: emacs,  Node: Diary Entries,  Next: New Entries,  Prev: Calendar,  Up: Calendar/Diary
        !          1061: 
        !          1062: Diary Entries
        !          1063: -------------
        !          1064: 
        !          1065:    To use the diary feature, you must write "diary entries" that
        !          1066: describe plans associated with particular dates, and put them in your
        !          1067: "diary file", which is normally the file `~/diary'.  You can specify a
        !          1068: different name for it by setting the variable `diary-file'; you would
        !          1069: do this before using any of the commands that operate on the diary.
        !          1070: 
        !          1071:    Diary file entries follow a simple convention: begin entries with a
        !          1072: date at the beginning of a line, followed optionally by a time, and
        !          1073: then by the text of the entry:
        !          1074: 
        !          1075:      DATE OPTIONAL-TIME-OF-DAY TEXT-OF-ENTRY
        !          1076: 
        !          1077: To continue an entry over two or more lines, indent the second and
        !          1078: subsequent lines.  The lines of the entry after the first are called
        !          1079: "continuation lines".  Other lines in the diary file that are not part
        !          1080: of any entry are comment lines; Emacs does not display these.
        !          1081: 
        !          1082:    When you make diary entries using Calendar mode, Emacs inserts the
        !          1083: date for you in the appropriate format and places the cursor so you can
        !          1084: type the text of the entry.
        !          1085: 
        !          1086:    You can write entries in any order and Emacs will display the
        !          1087: entries by date.  However, time-of-day entries can be sorted
        !          1088: chronologically only in a diary mode called Fancy mode; in Simple mode,
        !          1089: Emacs displays time-of-day entries in their order in the diary file.
        !          1090: 
        !          1091: 
        !          1092: File: emacs,  Node: Displaying Diary,  Next: European Calendar Style,  Prev: New Entries,  Up: Calendar/Diary
        !          1093: 
        !          1094: Calendar Commands to Display Diary Entries
        !          1095: ------------------------------------------
        !          1096: 
        !          1097:    In Calendar mode, use the following commands to display your diary
        !          1098: entries:
        !          1099: 
        !          1100: `d'
        !          1101:      Display any diary entries for the date under the cursor
        !          1102:      (`view-diary-entries').
        !          1103: 
        !          1104:      With a numeric argument, Emacs shows the diary entries for that
        !          1105:      many successive days, starting with and including the date under
        !          1106:      the cursor. Thus, `2 d' displays all the entries for the selected
        !          1107:      date and for the following day.
        !          1108: 
        !          1109: `s'
        !          1110:      Display your entire diary file (`show-all-diary-entries').
        !          1111: 
        !          1112: `m'
        !          1113:      In the calendar, mark all visible dates that have diary entries
        !          1114:      (`mark-diary-entries').
        !          1115: 
        !          1116: `u'
        !          1117:      Unmark the calendar (`calendar-unmark').
        !          1118: 
        !          1119:    At any time, not just in Calendar mode, you can display today's diary
        !          1120: entries by typing:
        !          1121: 
        !          1122:      M-x diary
        !          1123: 
        !          1124: With a prefix argument N, this command displays diary entries for N
        !          1125: successive days, starting from and including today.
        !          1126: 
        !          1127: 
        !          1128: File: emacs,  Node: New Entries,  Next: Displaying Diary,  Prev: Diary Entries,  Up: Calendar/Diary
        !          1129: 
        !          1130: Calendar Commands for Making Diary Entries
        !          1131: ------------------------------------------
        !          1132: 
        !          1133:    Calendar mode provides several commands to help you make diary file
        !          1134: entries.  These commands work by visiting the diary file and inserting
        !          1135: the date information; you must finish the job by inserting the text of
        !          1136: the entry, and then save the diary file with `C-x C-s'.  The commands
        !          1137: are:
        !          1138: 
        !          1139: `i d'
        !          1140:      Add a diary entry for the selected date in the calendar
        !          1141:      (`insert-diary-entry').
        !          1142: 
        !          1143: `i w'
        !          1144:      Add a diary entry for the selected day of the week
        !          1145:      (`insert-weekly-diary-entry').  This entry is displayed each week
        !          1146:      on the selected day.
        !          1147: 
        !          1148: `i m'
        !          1149:      Add a diary entry for the selected day of the month
        !          1150:      (`insert-monthly-diary-entry').  This entry is displayed each month
        !          1151:      on the selected day.
        !          1152: 
        !          1153: `i y'
        !          1154:      Add a diary entry for the selected day of the year
        !          1155:      (`insert-yearly-diary-entry').  This entry is displayed each year
        !          1156:      on the selected day.
        !          1157: 
        !          1158:    Here are commands for entering more complex kinds of diary entries in
        !          1159: Calendar mode.  These kinds of entries operate properly only in Fancy
        !          1160: Diary Display mode (*note Simple and Fancy::.).
        !          1161: 
        !          1162: `i a'
        !          1163:      Add an anniversary diary entry for the selected date
        !          1164:      (`insert-anniversary-diary-entry').
        !          1165: 
        !          1166:      Select the date you want remembered, in the proper year--if it is a
        !          1167:      birthday, remember to go to the person's year of birth!  Then type
        !          1168:      `i a' and enter the text of the entry.
        !          1169: 
        !          1170:      In the textual part of the entry you can type `%d'.  When Emacs
        !          1171:      displays the entry in the diary buffer, the `%d' is replaced by the
        !          1172:      number of years since the date.  Thus, if you use `%d years old' as
        !          1173:      the text of the entry, it will display as `53 years old' on the
        !          1174:      53rd birthday.
        !          1175: 
        !          1176: `i c'
        !          1177:      Add a cyclic diary entry starting at the date
        !          1178:      (`insert-cyclic-diary-entry').  An entry is displayed on a
        !          1179:      specified starting date and then is repeatedly displayed at the
        !          1180:      specified interval.  This is useful for ten day cycles of
        !          1181:      preventive maintenance and similar activities.
        !          1182: 
        !          1183:      To use this command, first select the start date.  The command
        !          1184:      reads the interval (the number of days between repetitions) using
        !          1185:      the minibuffer, then inserts the beginning of the entry.
        !          1186: 
        !          1187: `i b'
        !          1188:      Add a block diary entry for the current region
        !          1189:      (`insert-block-diary-entry').  With a block entry, Emacs writes
        !          1190:      the same message in the display for successive days.
        !          1191: 
        !          1192:      Position point and mark at the beginning and end of the block of
        !          1193:      days you want entered and type `i b'.  This sets up the diary
        !          1194:      entry's date info and positions point so you can write the text of
        !          1195:      the entry. People usually use this command for trips or vacations.
        !          1196: 
        !          1197: 
        !          1198: File: emacs,  Node: European Calendar Style,  Next: Simple and Fancy,  Prev: Displaying Diary,  Up: Calendar/Diary
        !          1199: 
        !          1200: European Calendar Style
        !          1201: -----------------------
        !          1202: 
        !          1203:    By default, Emacs interprets and displays diary dates in civilian
        !          1204: American form, `MONTH/DAY/YEAR': `2/15/1993', or `February 15, 1993'.
        !          1205: 
        !          1206:    Alternatively, you can specify the European calendar style for
        !          1207: writing dates: `DAY/MONTH/YEAR', `15/2/1993' or `15 February 1993'.  To
        !          1208: do this, set the variable `european-calendar-style' to `t', before
        !          1209: using any calendar or diary command.  This also affects display of
        !          1210: dates.
        !          1211: 
        !          1212:    Here's how to do this in your `.emacs' file:
        !          1213: 
        !          1214:      (setq european-calendar-style t)
        !          1215: 
        !          1216: 
        !          1217: File: emacs,  Node: Simple and Fancy,  Next: Other Diary Features,  Prev: European Calendar Style,  Up: Calendar/Diary
        !          1218: 
        !          1219: Simple and Fancy Diary Display
        !          1220: ------------------------------
        !          1221: 
        !          1222:    There are two modes for displaying a subset of diary entries: Simple
        !          1223: mode and Fancy mode.  Fancy mode provides a more dramatic display for
        !          1224: the diary, and can also display the actual matching date for diary
        !          1225: entries that match more than one date.
        !          1226: 
        !          1227:    By default, Emacs uses Simple mode, which is quicker than Fancy mode.
        !          1228: Another advantage of Simple mode is that you can edit the displayed
        !          1229: diary entries "in place" and save them.  When you use Fancy mode, it is
        !          1230: useless to edit the displayed subset of the diary; instead you must
        !          1231: visit the diary file separately.  To select Fancy mode, set
        !          1232: `diary-display-hook' to `fancy-diary-display' like this:
        !          1233: 
        !          1234:      (setq diary-display-hook 'fancy-diary-display)
        !          1235: 
        !          1236: 
        !          1237: File: emacs,  Node: Other Diary Features,  Next: Startup Diary,  Prev: Simple and Fancy,  Up: Calendar/Diary
        !          1238: 
        !          1239: Other Diary Features
        !          1240: --------------------
        !          1241: 
        !          1242:    Here are some additional diary features.  These will be explained in
        !          1243: full in `The GNU Emacs Extensions Manual'.
        !          1244: 
        !          1245:    You can schedule meetings on a date such as the first Tuesday of
        !          1246: every month.  This is called an "offset" date.  The diary has commands
        !          1247: for specifying such meetings, but not in Calendar mode.  To create such
        !          1248: an entry, you need to edit the diary file yourself.
        !          1249: 
        !          1250:    You can make entries according to Hebrew and Islamic dates.  Calendar
        !          1251: mode provides commands of the form `i h d' to add a diary entry for the
        !          1252: Hebrew date corresponding to the selected date and `i i d' to add a
        !          1253: diary entry for the Islamic date corresponding to the selected date. 
        !          1254: You can make entries that repeat every week, month, or year. Before
        !          1255: using these commands, you must set the
        !          1256: `nongregorian-diary-listing-hook' and the
        !          1257: `nongregorian-diary-marking-hook' in your `.emacs' file.
        !          1258: 
        !          1259:    You can include other diary files in your diary display.  This way, a
        !          1260: group of people can share a common diary file.
        !          1261: 
        !          1262: 
        !          1263: File: emacs,  Node: Startup Diary,  Next: Printing Diary,  Prev: Other Diary Features,  Up: Calendar/Diary
        !          1264: 
        !          1265: Displaying your Diary on Emacs Startup
        !          1266: --------------------------------------
        !          1267: 
        !          1268:    If you start a new Emacs each day, you might want to display your
        !          1269: diary automatically at that time.  To do so, put this in your `.emacs'
        !          1270: file:
        !          1271: 
        !          1272:      (diary)
        !          1273: 
        !          1274:    If you want to see both the calendar and your diary at startup, use
        !          1275: this instead:
        !          1276: 
        !          1277:      (setq view-diary-entries-initially t)
        !          1278:      (calendar)
        !          1279: 
        !          1280: 
        !          1281: File: emacs,  Node: Printing Diary,  Prev: Startup Diary,  Up: Calendar/Diary
        !          1282: 
        !          1283: Printing the Displayed Part of the Diary
        !          1284: ----------------------------------------
        !          1285: 
        !          1286:    To print the selected diary entries as they appear on the screen, use
        !          1287: `M-x print-diary-entries'.  The same variables that customize
        !          1288: `lpr-buffer' also affect this command.
        !          1289: 
        !          1290:    In Simple mode, the diary display buffer uses selective display
        !          1291: (*note Selective Display::.).  This means that what you see on the
        !          1292: screen is just part of the text in the Emacs buffer.  The diary entries
        !          1293: that don't apply to the dates you asked for are still in the buffer, but
        !          1294: hidden.  The ordinary printing commands such as `lpr-buffer' would not
        !          1295: do what you want; they print the entire text, including the hidden
        !          1296: parts.  This is why we need `print-diary-entries'.
        !          1297: 
        !          1298: 
        !          1299: File: emacs,  Node: Version Control,  Next: Emerge,  Prev: Calendar/Diary,  Up: Version 19
        !          1300: 
        !          1301: Version Control
        !          1302: ===============
        !          1303: 
        !          1304:    "Version control systems" are packages that can record multiple
        !          1305: versions of a source file, usually storing the unchanged parts of the
        !          1306: file just once.  Version control systems also record history information
        !          1307: such as the creation time of each version, who created it, and a
        !          1308: description of what was changed in that version.
        !          1309: 
        !          1310:    The GNU project recommends the version control system known as RCS,
        !          1311: which is free software and available from the Free Software Foundation.
        !          1312: Emacs supports use of either RCS or SCCS (a proprietary, but widely
        !          1313: used, version control system that is not quite as powerful as RCS)
        !          1314: through a facility called VC.  The same Emacs commands work with either
        !          1315: RCS or SCCS, so you hardly have to know which one of them you are using.
        !          1316: 
        !          1317: * Menu:
        !          1318: 
        !          1319: * Concepts of VC::
        !          1320: * Editing with VC::
        !          1321: * Variables for Check-in/out::
        !          1322: * Comparing Versions::
        !          1323: * VC Status::
        !          1324: * Renaming and VC::
        !          1325: * Snapshots::
        !          1326: * Log Entries::
        !          1327: * Change Logs and VC::
        !          1328: * Version Headers::
        !          1329: 
        !          1330: 

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