emacs/etc/OTHER.EMACSES

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.

arch-tag: e5a3da2f-f13d-400e-95e2-b6e1a520af90