#

1 files changed, 1049 insertions, 0 deletions

diff --git a/etc/OTHER.EMACSES b/etc/OTHER.EMACSES
new file mode 100644
index 00000000000..13b27bf2793
--- /dev/null
+++ b/etc/OTHER.EMACSES
@@ -0,0 +1,1049 @@
+How is this Emacs different from all other Emacses?  -*-Outline-*-
+
+This file describes the differences between GNU Emacs 19, Twenex
+Emacs, Gosling Emacs (including the commercial versions by Unipress)
+and CCA Emacs.
+
+* Copyright (c) 1985 Richard M. Stallman
+
+   Permission is granted to anyone to make or distribute verbatim copies
+   of this document as received, in any medium, provided that the
+   copyright notice and permission notice are preserved,
+   and that the distributor grants the recipient permission
+   for further redistribution as permitted by this notice.
+
+   Permission is granted to distribute modified versions
+   of this document, or of portions of it,
+   under the above conditions, provided also that they
+   carry prominent notices stating who last changed them.
+
+Updated March 1993 for Emacs 19 by Eric S. Raymond
+
+
+* How is this Emacs different from Twenex Emacs?
+
+** Fundamental concepts.
+
+*** There is no concept of "typeout" in GNU Emacs.
+
+Any time that a command wants to display some output,
+it creates a buffer (usually with a name surrounded by asterisks)
+and displays it in a window.
+
+This provides some advantages:
+ you can edit some more while looking at the output;
+ you can copy parts of the output into other buffers.
+
+It also has a disadvantage that you must type a command
+in order to make the output disappear.
+You can use C-x 1 to get rid of all windows except the
+selected one.  To be more selective, you can switch to
+the window you want to get rid of and then type C-x 0
+(delete-window).
+
+You also need to type a command to scroll the other
+window if not all the output fits in it.  Meta-Control-v
+will usually do the job.
+
+*** There is no concept of a "subsystem" in GNU Emacs.
+
+Where Twenex Emacs would use a subsystem, GNU Emacs
+instead creates a buffer and redefines commands in it.
+
+For example, when you send mail in GNU Emacs, you use
+a buffer named *mail* which is in Mail Mode.  You can
+switch away from this buffer to any other buffer and
+resume normal editing; then switch back and resume
+composing mail.  You do not have to "exit" from
+composing mail in order to do ordinary editing.
+
+This has many advantages, but it also has a disadvantage:
+Subsystems in Emacs tend to have "exit" commands that return you
+to whatever you were doing before entering the subsystem.
+In GNU Emacs the idea of what to return to is not well defined,
+so it is not clear what an "exit" command should do.
+The only way to "exit" in general is to type C-x b, C-x C-f, or
+some other suitable command to switch buffers.  Some
+subsystem-like major modes, such as Info and Mail mode, provide
+commands to "exit" by switching to the previously selected
+buffer.
+
+*** Files are always visited in their own buffers.
+
+Beginning users of Twenex Emacs were told how to edit
+using a single buffer and reading one file after another
+into that buffer.  Use of a new buffer for each file was
+regarded as a more advanced mode.
+
+In GNU Emacs, the idea of using a single buffer for various
+files, one by one, has been dropped, given that the address
+space is expected to be large enough for many buffers.  C-x
+C-f (find-file), which behaves nearly the same as in Twenex
+Emacs, is in GNU Emacs the canonical way for all users to
+visit files.
+
+Various commands need to read files into Emacs in the course
+of their execution.  In Twenex Emacs the user must tell them
+whether to reuse buffers or create new ones, using the variable
+Tags Find File.  In GNU Emacs, these commands always use
+C-x C-f.
+
+The command C-x C-v does still exist; it kills the current
+buffer and reads the specified file into a new buffer.
+It is equivalent to kill-buffer followed by find-file.
+
+Since there is no reusing of buffers, there is no point in
+calling the initial buffer "main".  So the initial buffer
+in GNU Emacs is called "*scratch*" and is intended for typing
+Lisp expressions to be evaluated.
+
+*** File name defaulting.
+
+GNU Emacs records a separate working directory for each buffer.
+Normally this is the directory on which the buffer's file
+resides; for buffers not visiting any file, it is copied from
+the buffer that was current when it was created.  The current buffer's
+working directory can be printed with M-x pwd and set with M-x cd.
+
+GNU Emacs shows you the default directory by inserting it in
+the minibuffer when a file name is being read.  You can type
+the filename you want at the end of the default as if the
+default were not there, or you can edit and alter the default.
+
+If you want file /lose/big when the default /foo/defaultdir/
+has been inserted for you, you need not kill the default; simply
+type at the end of it: /foo/defaultdir//lose/big.  Such a file
+name is not ordinarily considered valid, but GNU Emacs
+considers it equivalent to /lose/big.
+
+Likewise, if you want file quux in your home directory, just add
+~/quux to the end of the supplied text, to get
+/foo/defaultdir/~/quux.  GNU Emacs sees "/~" and throws away
+everything before the "~".
+
+You can refer to environment variables also within file names.
+$ followed by the environment variable name is replaced by the
+variable's value.  The variable name should either be followed
+by a nonalphanumeric character (which counts as part of the
+file name) or be surrounded by braces {...} (which do not count
+as part of the file name).  Thus, if variable USER has value "rms",
+"x/$USER-foo" is expanded to "x/rms-foo", and "x${USER}foo"
+is expanded to "xrmsfoo".  Note that this substitution is not
+performed by the primitive file operation functions of GNU Emacs,
+but rather by the interactive file name reader.  It is also
+available as a separate primitive, in the function
+substitute-in-file-name.
+
+*** Exit commands C-z, C-x C-c and C-x C-z.
+
+There are two ways to exit GNU Emacs: killing and suspending.
+Killing is like what Control-c does to ordinary Unix programs.
+In GNU Emacs, you type C-x C-c to kill it.  (This offers to
+save any modified file buffers before really killing Emacs.)
+Suspending is like what Control-z does to ordinary Unix programs.
+To suspend GNU Emacs, type C-x C-z, or type just C-z.
+Note that C-z suspends ordinary programs instantly, but
+Emacs does not suspend until it reads the C-z.
+
+Usually it is better to suspend: once a system is smart
+enough to have job control, why ever kill an editor?
+You'll just have to make a new one in a minute.
+This is why the convenient command C-z is provided for
+suspending.
+
+C-c is used as a prefix key for mode-specific commands and for users'
+own commands.  We deliberately do not make C-c ever kill Emacs,
+because it should not be so easy to do something irreversible.
+
+*** Quitting with C-g.
+
+If you type C-g while GNU Emacs is waiting for input, it
+is an ordinary command (which is defined to beep).  If you
+type C-g while Lisp code is executing, it sets a flag which
+causes a special signal, nearly the same as an error, to
+happen at the next safe place in Lisp execution.  This usually
+has the effect of aborting the current command in a safe way.
+
+Because at times there have been bugs causing GNU Emacs to loop
+without checking the quit flag, a special feature causes
+GNU Emacs to be suspended immediately if you type a second C-g
+while the flag is already set.  So you can always get out
+of GNU Emacs.  Normally GNU Emacs recognizes and clears the quit flag
+quickly enough to prevent this from happening.
+
+When you resume GNU Emacs after a suspension caused by multiple C-g, it
+asks two questions before resuming execution:
+ Checkpoint?
+ Dump core?
+Answer each one with `y' or `n' and a Return.
+ `y' to Checkpoint? causes immediate auto-saving of all
+    buffers in which auto-saving is enabled.
+ `y' to Dump core? causes an illegal instruction to be executed.
+    This is to enable a wizard to figure out why GNU Emacs was
+    looping without checking for quits.  Execution does not continue
+    after a core dump.  If you answer `n', execution continues.
+With luck, GNU Emacs will ultimately check the quit flag,
+and quit normally.  If not, and you type another C-g, it
+is suspended again.
+
+If GNU Emacs is not really hung, just slow, you may invoke
+the double C-g feature without really meaning to.  Then just
+resume and answer `n' to both questions, and you will
+arrive at your former state.  Presumably the quit you
+wanted will finish happening soon.
+
+These questions are not asked if you suspend GNU Emacs with the C-z
+command.  Continuing GNU Emacs after a C-z takes you straight back
+into editing.
+
+*** Undoing with C-x u or C-_
+
+You can undo many commands--up to 10,000 characters worth.
+Each time you type C-x u or C-_, another command or batch of change
+is undone.  Undo information is stored per buffer, and the undo
+command always applies to the current buffer.  A numeric argument
+serves as a repeat count.
+
+Consecutive self-inserting characters are undone in groups of twenty.
+
+*** Different character set.
+
+GNU Emacs does not expect anyone ever to have a keyboard in which
+the Control key sets an independent bit which may accompany any
+character. The only control characters that can exist are the
+ASCII control characters.
+
+There is, as a result, no "control prefix" character.
+
+*** Control-h is the Help character.
+
+I'm amazed it took me so long to get this idea.  In Twenex Emacs, C-h
+and C-b are equivalent commands, making C-h redundant.  C-h is not
+only easy to type, it is mnemonic for "Help".  So in GNU Emacs the
+Help character is C-h.
+
+*** Completion is done by TAB, not ESC.
+
+ESC in the minibuffer is a Meta prefix, same as at top level.
+
+*** The string-argument reader is the minibuffer is an editor window.
+
+In GNU Emacs, the line at the bottom of the screen is the minibuffer.
+Commands that want string arguments always use this line to read them,
+and you can use the ordinary Emacs editing commands to edit the
+input.  You can terminate input with Return because Return is defined
+as the exit-minibuffer command when in the minibuffer.  If you
+are using a command that needs several arguments, terminate each
+one with Return.  You cannot separate arguments with Escape
+the way you would in Twenex Emacs.
+
+The minibuffer window does not overlay other editor windows;
+it is a nearly ordinary editor window which lacks a mode line
+and is "turned off" when not in use.  While it IS in use, you
+can switch windows to and from the minibuffer, kill text in other
+windows and yank in the minibuffer, etc.
+
+You can even issue a command that uses the minibuffer while in the
+minibuffer.  This gets you temporarily into a recursive minibuffer.
+However, this is allowed only if you enable it, since it could be
+confusing for beginners.
+
+When you exit the minibuffer, the cursor immediately moves back to
+column zero of the minibuffer line, to show you that the exit
+command has been obeyed.  The minibuffer contents remain on the screen
+until the end of the command, unless some other text is displayed there.
+
+A single Control-g exits the minibuffer.
+
+*** There are no &'s or ^R's or spaces in function names.
+
+For example, the function which is called ^R Forward Word
+in Twenex Emacs is called forward-word in GNU Emacs.
+
+*** The extension language is Lisp rather than TECO.
+
+Libraries must be written in Lisp.  Meta-ESC reads a Lisp
+expression, evaluates it, and prints the result.  Note that
+Meta-ESC is "disabled" by default, so that beginning users
+do not get into the minibuffer by accident in a confusing way.
+
+Data types available include integers (which double as characters),
+strings, symbols, lists, vectors, buffers, buffer pointers,
+windows, and process channels.
+
+For now, to learn about writing Lisp code for GNU Emacs, read some of
+the source code, which is in directory ../lisp.  Read the GNU Emacs Lisp
+Reference Manual.  Also, all Lisp primitives have self-documentation you can
+read with C-h f.
+
+*** Enabling the error handler.
+
+GNU Emacs has a Lisp debugger/stepper/trace package, but normally
+errors do not enter the debugger because that is slow, and unlikely to
+be of interest to most users.  Set the variable debug-on-error to t to
+cause errors to invoke the debugger.  Set debug-on-quit to cause quit
+signals (caused by C-g) to invoke the debugger.
+
+** Other changes.
+
+*** More than two windows are allowed.
+
+C-x 2 splits the current window into two windows,
+  one above the other.  Initially they both display
+  the same buffer.
+
+  C-x 2 now accepts a numeric argument to specify the number of
+  lines to give to the uppermost of the two windows it makes.
+
+C-x 0 kills the current window, making all others larger.
+C-x 1 kills all windows except the current one.
+C-x O switches to the next window down.
+  It rotates from the bottom one to the top one.
+  An argument serves as a repeat count; negative arguments
+  circulate in the reverse order.
+
+If the same buffer is displayed in several windows,
+changes made in it are redisplayed in all of them.
+
+*** Side by side windows are supported.
+
+The command C-x 3 splits the current window into
+two side-by-side windows.
+
+C-x } makes the selected window ARG columns wider at the
+expense of the windows at its sides.  C-x { makes the selected
+window ARG columns narrower.  An argument to C-x 5 specifies
+how many columns to give to the leftmost of the two windows made.
+
+*** Horizontal scrolling of the lines in a window is implemented.
+
+C-x < (scroll-left) scrolls all displayed lines left,
+with the numeric argument (default 1) saying how far to scroll.
+When the window is scrolled left, some amount of the beginning
+of each nonempty line is replaced by an "$".
+C-x > scrolls right.  If a window has no text hidden at the left
+margin, it cannot be scrolled any farther right than that.
+When nonzero leftwards scrolling is in effect in a window.
+lines are automatically truncated at the window's right margin
+regardless of the value of the variable truncate-lines in the
+buffer being displayed.
+
+*** Return key does not use up empty lines.
+
+In Twenex Emacs, the Return command advances over an existing
+empty line in some cases.  In GNU Emacs, the Return command always
+makes inserts a newline.  Twenex Emacs was designed at a time when
+most display terminals did not have the ability to scroll part
+of the screen, and using existing empty lines made redisplay faster.
+Nowadays, terminals that cannot scroll part of the screen are rare,
+so there is no need to make Return behave in a more complicated manner.
+
+*** Help m.
+
+Typing C-h m displays documentation of the current major mode.,
+telling you what special commands and features are available
+and how to use them or get more information on them.
+
+This is simply the documentation, as a function, of the
+symbol which is the value of major-mode.  Each major mode
+function has been given documentation intended for C-h m.
+
+*** Display-hiding features.
+
+**** Hiding indented lines
+
+The command C-x $ with numeric argument N causes lines indented by N
+or more columns to become invisible.  All you see is " ..."  appended
+to the previous line, in place of any number of consecutive invisible
+lines.
+
+**** Outline Mode.
+
+Outline mode is designed for editing outline-structured
+files, such as this one.
+
+Headings should be lines starting with one or more asterisks.
+Major headings have one asterisk, subheadings two, etc.
+Lines not starting with asterisks are body text.
+
+You can make the body under a heading, or the subheadings
+under a heading, temporarily invisible, or visible again.
+Invisible lines are attached to the end of the previous line
+so they go with it if you kill it and yank it back.
+
+Commands:
+Meta-}   next-visible-heading      move by visible headings
+Meta-{   previous-visible-heading  move by visible headings
+
+Meta-x hide-body        make all body text invisible (not headings).
+Meta-x show-all         make everything in buffer visible.
+
+The remaining commands are used when dot is on a heading line.
+They apply to some of the body or subheadings of that heading.
+C-c C-h  hide-subtree   make text and subheadings invisible.
+C-c C-s  show-subtree   make text and subheadings visible.
+C-c C-i  show-children  make direct subheadings visible.
+                 No effect on body, or subheadings 2 or more levels down.
+                 With arg N, affects subheadings N levels down.
+M-x hide-entry  make immediately following body invisible.
+M-x show-entry  make it visible.
+M-x hide-leaves  make text under heading and under its subheadings invisible.
+                 The subheadings remain visible.
+M-x show-branches  make all subheadings at all levels visible.
+
+*** C mode is fancy.
+
+C mode assumes that you put the initial open-brace of
+a function definition at the beginning of a line.
+If you use the popular indenting style that puts this
+open-brace at the end of a line containing a type declaration,
+YOU WILL LOSE: C mode does not know a function starts there.
+
+Open-brace at the beginning of a line makes it possible
+for C mode to find function boundaries with total reliability;
+something I consider vital and which cannot be done
+if the other style is used.
+
+The Tab command indents C code very cleverly.
+I know of only one cases in which Tab does not indent C code nicely:
+ Expressions continued over several lines with few parentheses.
+ Tab does not know the precedences of C operators, so it does
+ not know which lines of the expression should go where.
+ Using parentheses to indicate the nesting of operators
+ except within a line makes this problem go away.
+
+The indenting algorithm is entirely written in Lisp.
+
+Tab with a numeric argument in Twenex Emacs indents
+that many lines.  It is different in GNU Emacs: it means
+to shift all the lines of a bracketed expression by the
+same amount as the line being indented.  For example, if you have
+    if (foo)
+        {
+            hack ();
+             /** Well? */
+        }
+and type C-u Tab on the line with the open brace, you get
+    if (foo)
+      {
+          hack ();
+           /* Well? */
+      }
+from indenting the brace line and then shifting the
+lines within the braces rigidly with the first one.
+
+Meta-Control-q works as in Lisp mode; it should be
+used with dot just before a bracketed grouping, and
+indents each line INSIDE that grouping using Tab.
+If used instead of C-u Tab in the previous example, it makes
+    if (foo)
+        {
+          hack ();
+          /* Well? */
+        }
+
+Meta-Control-h puts mark at the end of the current C function
+and puts dot before it.
+
+Most other Meta-Control commands intended for Lisp expressions
+work usefully in C mode as well.
+
+*** Meta-g (fill-region) is different.
+
+In Twenex Emacs, Meta-g fills the region with no paragraph
+boundaries except for blank and indented lines.  In GNU Emacs,
+it divides the region into paragraphs in the same manner as
+Meta-], and fills each paragraph separately.  There is also
+the function fill-region-as-paragraph which fills the region
+regarding at as a single paragraph regardless even of blank
+or indented lines.
+
+*** Indented Text Mode instead of Edit Indented Text.
+
+Twenex Emacs has a command Edit Indented Text which temporarily
+alters some commands for editing indented paragraphs.
+GNU Emacs has instead a separate major mode, Indented Text Mode,
+which is different from ordinary Text Mode in just the same
+alterations.  Specifically, in Indented Text Mode,
+Tab runs the function indent-relative, and auto filling indents
+the newly created lines.
+
+*** But rectangle commands are implemented.
+
+C-x r r stores the rectangle described by dot and mark
+into a register; it reads the register name from the keyboard.
+C-x r g, the command to insert the contents of a register,
+can be used to reinsert the rectangle elsewhere.
+
+Other rectangle commands include
+  open-rectangle:
+    insert a blank rectangle in the position and size
+    described by dot and mark, at its corners;
+    the existing text is pushed to the right.
+  clear-rectangle:
+    replace the rectangle described by dot ane mark
+    with blanks.  The previous text is deleted.
+  delete-rectangle:
+    delete the text of the specified rectangle,
+    moving the text beyond it on each line leftward.
+  kill-rectangle
+    like delete-rectangle but also stores the text of
+    the rectangle in the "rectangle kill buffer".
+    More precisely, it stores the text as a list of strings
+    (one string for each line) in the variable killed-rectangle.
+  yank-rectangle
+    inserts the text of the last killed rectangle.
+  extract-rectangle and delete-extract-rectangle
+    these functions return the text of a rectangle
+    as a list of strings.  They are for use in writing
+    other functions that operate on rectangles.   
+
+*** Keyboard Macros
+
+The C-x ( command for defining a keyboard macro can in GNU Emacs
+be given a numeric argument, which means that the new macro
+starts out not empty but rather as the same as the last
+keyboard macro entered.  In addition, that last keyboard
+macro is replayed when the C-x ( is typed.  C-x ( with an
+argument is thus equivalent to typing plain C-x ( and then
+retyping the last keyboard macro entered.
+
+The command write-kbd-macro and append-kbd-macro can be used to
+save a keyboard macro definition in a file.  It is represented as
+a Lisp expression which, when evaluated, will define the keyboard
+macro.  write-kbd-macro writes the specified file from scratch,
+whereas append-kbd-macro adds to any existing text in the file.
+Both expect the keyboard macro to be saved to be specified by
+name; this means you must use the command name-last-kbd-macro to
+give the macro a name before you can save it.
+
+*** The command to resume a terminated tags-search or tags-query-replace
+
+is Meta-comma in GNU Emacs.
+
+*** Auto Save is on by default.
+
+Auto Save mode is enabled by default in all buffers
+that are visiting files.
+
+The file name used for auto saving is made by prepending
+"#" to the file name visited.
+
+*** Backup files.
+
+Since Unix stupidly fails to have file version numbers,
+GNU Emacs compensates slightly in the customary fashion:
+when a file is modified and saved for the first time in
+a particular GNU Emacs run, the original file is renamed,
+appending "~" to its name.  Thus, foo.c becomes foo.c~.
+
+Emacs can also put a version number into the name of the backup file,
+as in foo.c.~69~ for version number 69.  This is an optional feature
+that the user has to enable.
+
+*** Mode Line differences.
+
+Each window in GNU Emacs has its own mode line, which always
+displays the status of that window's buffer and nothing else.
+The mode line appears at the bottom of the window.  It is
+full of dashes, to emphasize the boundaries between windows,
+and is displayed in inverse video if the terminal supports it.
+The information usually available includes:
+
+*** Local Modes feature changed slightly.
+
+GNU Emacs supports local mode lists much like those in Twenex Emacs,
+but you can only set variables, not commands.  You write
+
+Local variables:
+tab-width:      10
+end:
+
+in the last page of a file, if you want to make tab-width be ten in a
+file's buffer.  The value you specify must be a Lisp object!
+It will be read, but not evaluated.  So, to specify a string,
+you MUST use doublequotes.  For "false", in variables whose
+meanings are true or false, you MUST write  nil  .
+
+Two variable names are special: "mode" and "eval".
+Mode is used for specifying the major mode (as in Twenex Emacs).
+
+mode: text
+
+specifies text mode.  Eval is used for requesting the evaluation
+of a Lisp expression; its value is ignored.  Thus,
+
+eval: (set-syntax-table lisp-mode-syntax-table)
+
+causes Lisp Mode syntax to be used.
+
+
+Note that GNU Emacs looks for the string "Local variables:"
+whereas Twenex Emacs looks for "Local modes:".  This incompatibility
+id deliberate, so that neither one will see local settings
+intended for the other.
+
+*** Lisp code libraries.
+
+Libraries of commands, and init files, are written in Lisp.
+libraries conventionally have names ending in .el, while the
+init file is named .emacs and is in your home directory.
+
+Use  Meta-x load-library  to load a library.  Most standard libraries
+load automatically if you try to use the commands in them.
+
+Meta-x byte-compile-file filename
+compiles the file into byte code which loads and runs faster
+than Lisp source code.  The file of byte code is given a name
+made by appending "c" to the end of the input file name.
+
+Meta-x byte-recompile-directory directoryname
+compiles all files in the specified directory (globbing not allowed)
+which have been compiled before but have been changed since then.
+
+Meta-x load-library automatically checks for a compiled file
+before loading the source file.
+
+Libraries once loaded do not retain their identity within GNU
+Emacs.  Therefore, you cannot tell just what was loaded from a
+library, and you cannot un-load a library.  Normally, libraries
+are written so that loading one has no effect on the editing
+operations that you would have used if you had not loaded the
+library.
+
+*** Dired features.
+
+You can do dired on partial directories --- any pattern
+the shell can glob.  Dired creates a buffer named after
+the directory or pattern, so you can dired several different
+directories.  If you repeat dired on the same directory or
+pattern, it just reselects the same buffer.  Use Meta-x Revert
+on that buffer to read in the current contents of the directory.
+
+*** Directory listing features.
+
+C-x C-d now uses the default output format of `ls',
+which gives just file names in multiple columns.
+C-u C-x C-d passes the -l switch to `ls'.
+
+Both read a directory spec from the minibuffer.  It can
+be any pattern that the shell can glob.
+
+*** Compiling other programs.
+
+Meta-x compile allows you to run make, or any other compilation
+command, underneath GNU Emacs.  Error messages go into a buffer whose
+name is *compilation*.  If you get error messages, you can use the
+command C-x ` (that is a backquote) to find the text of the next
+error message.
+
+You must specify the command to be run as an argument to M-x compile.
+A default is placed in the minibuffer; you can kill it and start
+fresh, edit it, or just type Return if it is what you want.
+The default is the last compilation command you used; initially,
+it is "make -k".
+
+*** Searching multiple files.
+
+Meta-x grep searches many files for a regexp by invoking grep
+and reading the output of grep into a buffer.  You can then
+move to the text lines that grep found, using the C-x ` command
+just as after M-x compile.
+
+*** Running inferior shells.
+
+Do Meta-x shell to make an inferior shell together with a buffer
+which serves to hold "terminal" input and output of the shell.
+The shell used is specified by the environment variable ESHELL,
+or by SHELL if ESHELL is not set.
+
+Use C-h m whilst in the *shell* buffer to get more detailed info.
+
+The inferior shell loads the file .emacs_csh or.emacs_sh
+(or similar using whatever name the shell has) when it starts up.
+
+M-! executes a shell command in an inferior shell
+and displays the output from it.  With a prefix argument,
+it inserts the output in the current buffer after dot
+and sets the mark after the output.  The shell command
+gets /dev/null as its standard input.
+
+M-| is like M-! but passes the contents of the region
+as input to the shell command.  A prefix argument makes
+the output from the command replace the contents of the region.
+
+*** Sending mail.
+
+Once you enter Mail Mode using C-x m or C-x 4 m or M-x mail,
+C-c becomes a prefix character for mail-related editing commands.
+C-c C-s is vital; that's how you send the message.  C-c C-c sends
+and then switches buffers or kills the current window.
+Use C-h m to get a list of the others.
+
+*** Regular expressions.
+
+GNU Emacs has regular expression facilities like those of most
+Unix editors, but more powerful:
+
+****            -- + --
+
++ specifies repetition of the preceding expression 1 or more
+times.  It is in other respect like *, which specifies repetition
+0 or more times.
+
+****            -- ? --
+
+?  is like * but matches at most one repetition of the preceding
+expression.
+
+****            -- \| --
+
+\| specifies an alternative.  Two regular expressions A and B with \| in
+between form an expression that matches anything that either A or B will
+match.  Thus, "foo\|bar" matches either "foo" or "bar" but no other
+string.
+
+\| applies to the larges possible surrounding expressions.  Only a
+surrounding \( ... \) grouping can limit the grouping power of \|.
+
+Full backtracking capability exists when multiple \|'s are used.
+
+****            -- \( ... \) --
+
+\( ... \) are a grouping construct that serves three purposes:
+
+1.  To enclose a set of \| alternatives for other operations.
+    Thus, "\(foo\|bar\)x" matches either "foox" or "barx".
+2.  To enclose a complicated expression for * to operate on.
+    Thus, "ba\(na\)*" matches "bananana", etc., with any number
+    of na's (zero or more).
+3.  To mark a matched substring for future reference.
+
+Application 3 is not a consequence of the idea of a parenthetical
+grouping; it is a separate feature which happens to be assigned as a
+second meaning to the same \( ... \) construct because there is no
+conflict in practice between the two meanings.  Here is an explanation
+of this feature.
+
+                -- \digit --
+
+After the end of a \( ... \) construct, the matcher remembers the
+beginning and end of the text matched by that construct.  Then, later on
+in the regular expression, you can use \ followed by a digit to mean,
+``match the same text matched this time by the \( ... \) construct.''
+The first nine \( ... \) constructs that appear in a regular expression
+are assigned numbers 1 through 9 in order of their beginnings.  \1
+through \9 can be used to refer to the text matched by the corresponding
+\( ... \) construct.
+
+For example, "\(.*\)\1" matches any string that is composed of two
+identical halves.  The "\(.*\)" matches the first half, which can be
+anything, but the \1 that follows must match the same exact text.
+
+****            -- \` --
+
+Matches the empty string, but only if it is at the beginning of the buffer.
+
+****            -- \' --
+
+Matches the empty string, but only if it is at the end of the buffer.
+
+****            -- \b --
+
+Matches the empty string, but only if it is at the beginning or end of
+a word.  Thus, "\bfoo\b" matches any occurrence of "foo" as a separate word.
+"\bball\(s\|\)\b" matches "ball" or "balls" as a separate word.
+
+****            -- \B --
+
+Matches the empty string, provided it is NOT at the beginning or end of
+a word.
+
+****            -- \< --
+
+Matches the empty string, provided it is at the beginning of a word.
+
+****            -- \> --
+
+Matches the empty string, provided it is at the end of a word.
+
+****            -- \w --
+
+Matches any word-constituent character.  The editor syntax table determines
+which characters these are.
+
+****            -- \W --
+
+Matches any character that is not a word-constituent.
+
+****            -- \s<code> --
+
+Matches any character whose syntax is <code>.  <code> is a letter that
+represents a syntax code: thus, "w" for word constituent, "-" for
+whitespace, "(" for open-parenthesis, etc.  Thus, "\s(" matches any
+character with open-parenthesis syntax.
+
+****            -- \S<code> --
+
+Matches any character whose syntax is not <code>.
+
+* How is this Emacs different from Gosling Emacs?
+
+** Advantages of Gosling Emacs:
+
+1. The program itself is much smaller.
+GNU Emacs uses about 250k more pure storage.
+As a result, Gosling Emacs can run on machines
+that cannot run GNU Emacs.  There is not much difference
+in the amount of impure storage in the two programs.
+
+2. In some versions there is support for other forks to
+establish communications channels to Emacs (using sockets?).
+
+3. There is a direct interface to dbm (data bases).
+
+** Advantages of GNU Emacs:
+
+*** True Lisp, not Mocklisp.
+
+GNU Emacs's extension language has real symbols, lists
+and vectors.  Many extensions are much simpler, and some
+become possible that were nearly impossible in Gosling Emacs.
+Many primitives can have cleaner interfaces, and some features
+need not be put in as special primitives because you can do
+them easily yourself.
+
+*** But Mocklisp still works.
+
+An automatic conversion package plus a run-time library
+allows you to convert a Mocklisp library into a Lisp library.
+
+*** Commands are better crafted.
+
+For example, nearly every editing function for which a
+numeric argument would make sense as a repeat count does
+accept a repeat count, and does handle a negative argument
+in the way you would expect.
+
+*** The manual is clearer.
+
+Everyone tells me it is a very good manual.
+
+*** Better on-line documentation.
+
+Both functions and variables have documentation strings that
+describe exactly how to use them.
+
+*** C mode is smart.
+
+It really knows how to indent each line correctly,
+for most popular indentation styles.  (Some variables
+control which style is used; popular named styles are also supported.)
+
+*** Compatible with PDP-10 Emacs, Multics Emacs and Zmacs.
+
+The commands in GNU Emacs are nearly the same as in the
+original Emacs and the other Emacses which imitated it.
+(A few have been changed to fit the Unix environment better.)
+
+*** Support for Gosling's Emacs commands.
+
+M-x set-gosmacs-bindings rebinds many editing commands for
+compatibility with Gosling's Emacs.
+M-x set-gnu-bindings reverses the change.
+
+*** Side-by-side windows.
+
+You can split a GNU Emacs window either horizontally or
+vertically.
+
+*** Redisplay is faster.
+
+GNU Emacs sends about the same stuff to the terminal that
+Gosling's does, but GNU Emacs uses much less CPU time to
+decide what to do.
+
+*** Entirely termcap-driven.
+
+GNU Emacs has nearly no special code for any terminal type.  Various
+new termcap strings make it possible to handle all terminals nearly as
+fast as they could be handled by special-case code.
+
+*** Display-hiding features.
+
+For example, Outline Mode makes it possible for you to edit
+an outline, making entire sub-branches of the outline visible
+or invisible when you wish.
+
+*** You can interrupt with Control-G.
+
+Even a looping Lisp program can be stopped this way.
+And even a loop in C code does not stop you from killing
+Emacs and getting back to your shell.
+
+*** Per-buffer Undo.
+
+You can undo the last several changes, in each buffer
+independently.
+
+*** The editor code itself is clean.
+
+Many people have remarked on how much they enjoy reading
+the code for GNU Emacs.
+
+One other note: The program etc/cvtmail that comes with GNU Emacs can
+be used to convert a mail directory for Gosling Emacs's Rmail into a
+Unix mail file that you could read into GNU Emacs's Rmail.
+
+* How is this Emacs different from CCA Emacs?
+
+** GNU Emacs Lisp vs CCA Elisp.
+
+GNU Emacs Lisp does not have a distinction between Lisp functions
+and Emacs functions, or between Lisp variables and Emacs variables.
+The Lisp and the editor are integrated.  A Lisp function defined
+with defun is callable as an editor command if you put an
+interactive calling spec in it; for example, 
+  (defun forward-character (n)
+    (interactive "p")
+    (goto-char (+ (point) n)))
+defines a function of one argument that moves point forward by
+a specified number of characters.  Programs could call this function,
+as in (forward-character 6), or it could be assigned to a key,
+in which case the "p" says to pass the prefix numeric arg as
+the function's argument.  As a result of this feature, you often
+need not have two different functions, one to be called by programs
+and another to read arguments from the user conveniently; the same
+function can do both.
+
+CCA Elisp tries to be a subset of Common Lisp and tries to
+have as many Common Lisp functions as possible (though it is still
+only a small fraction of full Common Lisp).  GNU Emacs Lisp
+is somewhat similar to Common Lisp just because of my Maclisp
+and Lisp Machine background, but it has several distinct incompatibilities
+in both syntax and semantics.  Also, I have not attempted to
+provide many Common Lisp functions that you could write in Lisp,
+or others that provide no new capability in the circumstances.
+
+GNU Emacs Lisp does not have packages, readtables, or character objects
+(it uses integers to represent characters).
+
+On the other hand, windows, buffers, relocatable markers and processes
+are first class objects in GNU Emacs Lisp.  You can get information about them
+and do things to them in a Lispy fashion.  Not so in CCA Emacs.
+
+In GNU Emacs Lisp, you cannot open a file and read or write characters
+or Lisp objects from it.  This feature is painful to support, and
+is not fundamentally necessary in an Emacs, because instead you
+can read the file into a buffer, read or write characters or
+Lisp objects in the buffer, and then write the buffer into the file.
+
+On the other hand, GNU Emacs Lisp does allow you to rename, delete, add
+names to, and copy files; also to find out whether a file is a
+directory, whether it is a symbolic link and to what name, whether
+you can read it or write it, find out its directory component,
+expand a relative pathname, find completions of a file name, etc.,
+which you cannot do in CCA Elisp.
+
+GNU Emacs Lisp uses dynamic scope exclusively.  This enables you to
+bind variables which affect the execution of the editor, such as
+indent-tabs-mode.
+
+GNU Emacs Lisp code is normally compiled into byte code.  Most of the
+standard editing commands are written in Lisp, and many are
+dumped, pure, in the Emacs that users normally run.
+
+GNU Emacs allows you to interrupt a runaway Lisp program with
+Control-g.
+
+** GNU Emacs Editing Advantages
+
+GNU Emacs is faster for many things, especially insertion of text
+and file I/O.
+
+GNU Emacs allows you to undo more than just the last command
+with the undo command (C-x u, or C-_).  You can undo quite a ways back.
+Undo information is separate for each buffer; changes in one buffer
+do not affect your ability to undo in another buffer.
+
+GNU Emacs commands that want to display some output do so by putting
+it in a buffer and displaying that buffer in a window.  This
+technique comes from Gosling Emacs.  It has both advantages and
+disadvantages when compared with the technique, copied by CCA Emacs
+from my original Emacs which inherited it from TECO, of having "type
+out" which appears on top of the text in the current window but
+disappears automatically at the next input character.
+
+GNU Emacs does not use the concept of "subsystems".  Instead, it uses
+highly specialized major modes.  For example, dired in GNU Emacs has
+the same commands as dired does in other versions of Emacs, give or
+take a few, but it is a major mode, not a subsystem.  The advantage
+of this is that you do not have to "exit" from dired and lose the
+state of dired in order to edit files again.  You can simply switch
+to another buffer, and switch back to the dired buffer later.  You
+can also have several dired buffers, looking at different directories.
+
+It is still possible to write a subsystem--your own command loop--
+in GNU Emacs, but it is not recommended, since writing a major mode
+for a special buffer is better.
+
+Recursive edits are also rarely used, for the same reason: it is better
+to make a new buffer and put it in a special major mode.  Sending
+mail is done this way.
+
+GNU Emacs expects everyone to use find-file (C-x C-f) for reading
+in files; its C-x C-v command kills the current buffer and then finds
+the specified file.
+
+As a result, users do not need to think about the complexities
+of subsystems, recursive edits, and various ways to read in files
+or what to do if a buffer contains changes to some other file.
+
+GNU Emacs uses its own format of tag table, made by the "etags"
+program.  This format makes finding a tag much faster.
+
+Dissociated Press is supported.
+
+
+** GNU Emacs Editing Disadvantages.
+
+GNU Emacs does not display the location of the mark.
+
+GNU Emacs does not have a concept of numbers of buffers,
+or a permanent ordering of buffers, or searching through multiple
+buffers.  The tags-search command provides a way to search
+through several buffers automatically.
+
+GNU Emacs does not provide commands to visit files without
+setting the buffer's default directory.  Users can write such
+commands in Lisp by copying the code of the standard file
+visiting commands and modifying them.
+
+GNU Emacs does not support "plus options" in the command
+arguments or in buffer-selection commands, except for line numbers.
+
+GNU Emacs does not support encryption.  Down with security!
+
+GNU Emacs does not support replaying keystroke files,
+and does not normally write keystroke files.
+
+
+** Neutral Differences
+
+GNU Emacs uses TAB, not ESC, to complete file names, buffer names,
+command names, etc.
+
+GNU Emacs uses LFD to terminate searches, instead of
+the C-d uses by CCA Emacs.  (Actually, this character is controlled
+by a parameter in GNU Emacs.)  C-M-s in GNU Emacs is an interactive
+regular expression search, but you can get to a noninteractive
+one by typing ESC right after the C-M-s.
+
+In GNU Emacs, C-x s asks, for each modified file buffer, whether
+to save it.
+
+GNU Emacs indicates line continuation with "\" and line
+truncation (at either margin) with "$".
+
+The command to resume a tags-search or tags-query-replace in
+GNU Emacs is Meta-Comma.