GNU Emacs NEWS -- history of user-visible changes.  7 Jul 1993
Copyright (C) 1993 Free Software Foundation, Inc.
See the end for copying conditions.

Please send Emacs bug reports to bug-gnu-emacs@prep.ai.mit.edu.
For older news, see the file ONEWS.  For Lisp changes in Emacs 19,
see the file LNEWS.

Changes in version 19.17.

* When Emacs displays a list of completions in a buffer, 
you can select a completion by clicking mouse button 2
on that completion.

* Use the command `list-faces-display' to display a list of 
all the currently defined faces, showing what they look like.

* Menu bar items from local maps now come after the usual items.

* The Help menu bar item always comes last in the menu bar.

* If you enable Font-Lock mode on a buffer containing a program
(certain languages such as C and Lisp are supported), everything you
type is automatically given a face property appropriate to its
syntactic role.  For example, there are faces for comments, string
constants, names of functions being defined, and so on.

* Dunnet, an adventure game, is now available.

* Several major modes now have their own menu bar items, 
including Dired, Rmail, and Sendmail.  We would like to add 
suitable menu bar items to other major modes.

* The key binding C-x a C-h has been eliminated.
This is because it got in the way of the general feature of typing
C-h after a prefix character.  If you want to run
inverse-add-global-abbrev, you can use C-x a - or C-x a i g instead.

* If you set the variable `rmail-mail-new-frame' to a non-nil value,
all the Rmail commands to send mail make a new frame to do it in.
When you send the message, or use the menu bar command not to send it,
that frame is deleted.

* In Rmail, the o and C-o commands are now almost interchangeable.
Both commands check the format of the file you specify, and append
the message to it in Rmail format if it is an Rmail file, and in
inbox file format otherwise.  C-o and o are different only when you
specify a new file.

* The function `copy-face' now takes an optional fourth argument
NEW-FRAME.  If you specify this, it copies the definition of face
OLD-FACE on frame FRAME to face NEW-NAME on frame NEW-FRAME.

* A local map can now cancel out one of the global map's menu items.
Just define that subcommand of the menu item with `undefined'
as the definition.  For example, this cancels out the `Buffers' item
for the current major mode:

    (local-set-key [menu-bar buffer] 'undefined)

* To put global items at the end of the menu bar, use the new variable
`menu-bar-final-items'.  It should be a list of symbols--event types
bound in the menu bar.  The menu bar items for these symbols are
moved to the end.

* The list returned by `buffer-local-variables' now contains cons-cell
elements of the form (SYMBOL . VALUE) only for buffer-local variables
that have values.  For unbound buffer-local variables, the variable
name (symbol) appears directly as an element of the list.

* The `modification-hooks' property of a character no longer affects
insertion; it runs only for deletion and modification of the character.

To detect insertion, use `insert-in-front-hooks' and
`insert-behind-hooks' properties.  The former runs when text is
inserted immediately preceding the character that has the property;
the latter runs when text is inserted immediately following the
character.

* Buffer modification now runs hooks belonging to overlays as well as
hooks belonging to characters.  If an overlay has a
`modification-hooks' property, it applies to any change to text in the
overlay, and any insertion within the overlay.  If the overlay has a
`insert-in-front-hooks' property, it runs for insertion at the
beginning boundary of the overlay.  If the overlay has an
`insert-behind-hooks' property, it runs for insertion at the end
boundary of the overlay.

The values of these properties should be lists of functions.  Each
function is called, receiving as arguments the overlay in question,
followed by the bounds of the range being modified.

* The new `-name NAME' option directs Emacs to search for its X
resources using the name `NAME', and sets the title of the initial
frame.  This argument was added for consistency with other X clients.

* The new `-xrm DATABASE' option tells Emacs to treat the string
DATABASE as the text of an X resource database.  Emacs searches
DATABASE for resource values, in addition to the usual places.  This
argument was added for consistency with other X clients.

* Emacs now searches for X resources in the files specified by the
XFILESEARCHPATH, XUSERFILESEARCHPATH, and XAPPLRESDIR environment
variables, emulating the functionality provided by programs written
using Xt.  Because of this change, Emacs will now notice system-wide
application defaults files, as other X clients do.

XFILESEARCHPATH and XUSERFILESEARCHPATH should be a list of file names
separated by colons; XAPPLRESDIR should be a list of directory names
separated by colons.

Emacs searches for X resources
  + specified on the command line, with the `-xrm RESOURCESTRING'
    option,
  + then in the value of the XENVIRONMENT environment variable,
    - or if that is unset, in the file named ~/.Xdefaults-HOSTNAME if it exists
      (where HOSTNAME is the hostname of the machine Emacs is running on),
  + then in the screen-specific and server-wide resource properties
    provided by the server,
    - or if those properties are unset, in the file named ~/.Xdefaults
      if it exists,
  + then in the files listed in XUSERFILESEARCHPATH,
    - or in files named LANG/Emacs in directories listed in XAPPLRESDIR
      (where LANG is the value of the LANG environment variable), if
      the LANG environment variable is set,
    - or in files named Emacs in the directories listed in XAPPLRESDIR
    - or in ~/LANG/Emacs (if the LANG environment variable is set),
    - or in ~/Emacs,
  + then in the files listed in XFILESEARCHPATH.

The paths in the variables XFILESEARCHPATH, XUSERFILESEARCHPATH, and
XAPPLRESDIR may contain %-escapes (like the control strings passed to
the the Emacs lisp `format' function or C printf function), which
Emacs expands.

%N is replaced by the string "Emacs" wherever it occurs.
%T is replaced by "app-defaults" wherever it occurs.
%S is replaced by the empty string wherever it occurs.
%L and %l are replaced by the value of the LANG environment variable; if LANG
   is not set, Emacs does not use that directory or file name at all.
%C is replaced by the value of the resource named "customization"
   (class "Customization"), as retrieved from the server's resource
   properties or the user's ~/.Xdefaults file, or the empty string if
   that resource doesn't exist.

So, for example,
  if XFILESEARCHPATH is set to the value
    "/usr/lib/X11/%L/%T/%N%C:/usr/lib/X11/%T/%N%C:/usr/lib/X11/%T/%N",
  and the LANG environment variable is set to
    "english",
  and the customization resource is the string
    "-color",
then, in the last step of the process described above, Emacs checks
for resources in the first of the following files that is present and
readable:
	/usr/lib/X11/english/app-defaults/Emacs-color
	/usr/lib/X11/app-defaults/Emacs-color
	/usr/lib/X11/app-defaults/Emacs
If the LANG environment variable is not set, then Emacs never uses the
first element of the path, "/usr/lib/X11/%L/%T/%N%C", because it
contains the %L escape.

If XFILESEARCHPATH is unset, Emacs uses the default value
"/usr/lib/X11/%L/app-defaults/Emacs%C:\
/usr/lib/X11/app-defaults/Emacs%C:\
/usr/lib/X11/%L/app-defaults/Emacs:\
/usr/lib/X11/app-defaults/Emacs"

This feature was added for consistency with other X applications.

* The new function `text-property-any' scans the region of text from
START to END to see if any character's property PROP is `eq' to
VALUE.  If so, it returns the position of the first such character.
Otherwise, it returns nil.

The optional fifth argument, OBJECT, specifies the string or buffer to
be examined.

* The new function `text-property-not-all' scans the region of text from
START to END to see if any character's property PROP is not `eq' to
VALUE.  If so, it returns the position of the first such character.
Otherwise, it returns nil.

The optional fifth argument, OBJECT, specifies the string or buffer to
be examined.

* The function `delete-windows-on' now takes an optional second
argument FRAME, which specifies which frames it should affect.
  + If FRAME is nil or omitted, then `delete-windows-on' deletes windows
    showing BUFFER (its first argument) on all frames.
  + If FRAME is t, then `delete-windows-on' only deletes windows on the
    selected frame; other frames are unaffected.
  + If FRAME is a frame, then `delete-windows-on' only deletes windows on
    the given frame; other frames are unaffected.


Changes in version 19.16.

* When dragging the mouse to select a region, Emacs now highlights the
region as you drag (if Transient Mark mode is enabled).  If you
continue the drag beyond the boundaries of the window, Emacs scrolls
the window at a steady rate until you either move the mouse back into
the window or release the button.

* RET now exits `query-replace' and `query-replace-regexp'; this makes it
more consistent with the incremental search facility, which uses RET
to end the search.

* In C mode, C-c C-u now runs c-up-conditional.
C-c C-n and C-c C-p now run new commands that move forward
and back over balanced sets of C conditionals (c-forward-conditional
and c-backward-conditional).

* The Edit entry in the menu bar has a new alternative:
"Choose Next Paste".  It gives you a menu showing the various
strings in the kill ring; click on one to select it as the text 
to be yanked ("pasted") the next time you yank.

* If you enable Transient Mark mode and set `mark-even-if-inactive' to
non-nil, then the region is highlighted in a transient fashion just as
normally in Transient Mark mode, but the mark really remains active
all the time; commands that use the region can be used even if the
region highlighting turns off.

* If you type C-h after a prefix key, it displays the bindings
that start with that prefix.

* The VC package now searches for version control commands in the
directories named by the variable `vc-path'; its value should be a
list of strings.

* If you are visiting a file that has locks registered under RCS,
VC now displays each lock's owner and version number in the mode line
after the string `RCS'.  If there are no locks, VC displays the head
version number.

* When using X, if you load the `paren' library, Emacs automatically
underlines or highlights the matching paren whenever point is
next to the outside of a paren.  When point is before an open-paren,
this shows the matching close; when point is after a close-paren,
this shows the matching open.

* The new function `define-key-after' is like `define-key',
but takes an extra argument AFTER.  It places the newly defined
binding after the binding for the event AFTER.

* `accessible-keymaps' now takes an optional second argument, PREFIX.
If PREFIX is non-nil, it means the value should include only maps for
keys that start with PREFIX.

`describe-bindings' also accepts an optional argument PREFIX which
means to describe only the keys that start with PREFIX.

* The variable `prefix-help-command' hold a command to run to display help
whenever the character `help-char' follows a prefix key and does not have
a key binding in that context.

* Emacs now detects double- and triple-mouse clicks.  A single mouse
click produces a pair events of the form:
	(down-mouse-N POSITION)
	(mouse-N POSITION)
Clicking the same mouse button again, soon thereafter and at the same
location, produces another pair of events of the form:
	(down-mouse-N POSITION)
	(double-mouse-N POSITION 2)
Another click will produce an event pair of the form:
	(down-mouse-N POSITION)
	(triple-mouse-N POSITION 3)
All the POSITIONs in such a sequence would be identical, except for
their timestamps.

To count as double- and triple-clicks, mouse clicks must be at the
same location as the first click, and the number of milliseconds
between the first release and the second must be less than the value
of the lisp variable `double-click-time'.  Setting `double-click-time'
to nil disables multi-click detection.  Setting it to t removes the
time limit; Emacs then detects multi-clicks by position only.

If `read-key-sequence' finds no binding for a double-click event, but
the corresponding single-click event would be bound,
`read-key-sequence' demotes it to a single-click.  Similarly, it
demotes unbound triple-clicks to double- or single-clicks.  This means
you don't have to distinguish between single- and multi-clicks if you
don't want to.

Emacs reports all clicks after the third as `triple-mouse-N' clicks,
but increments the click count after POSITION.  For example, a fourth
click, soon after the third and at the same location, produces a pair
of events of the form:
	(down-mouse-N POSITION)
	(triple-mouse-N POSITION 4)

* The way Emacs reports positions of mouse events has changed
slightly.  If a mouse event includes a position list of the form:
	(WINDOW (PLACE-SYMBOL) (COLUMN . ROW) TIMESTAMP)
this denotes exactly the same position as the list:
	(WINDOW  PLACE-SYMBOL  (COLUMN . ROW) TIMESTAMP)
That is, the event occurred over a non-textual area of the frame,
specified by PLACE-SYMBOL, a symbol like `mode-line' or
`vertical-scroll-bar'.

Enclosing PLACE-SYMBOL in a singleton list does not change the
position denoted, but the `read-key-sequence' function uses the
presence or absence of the singleton list to tell whether or not it
should prefix the event with its place symbol.

Normally, `read-key-sequence' prefixes mouse events occuring over
non-textual areas with their PLACE-SYMBOLs, to select the sub-keymap
appropriate for the event; for example, clicking on the mode line
produces a sequence like
	[mode-line (mouse-1 POSN)]
However, if lisp code elects to unread the resulting key sequence by
placing it in the `unread-command-events' variable, it is important
that `read-key-sequence' not insert the prefix symbol again; that
would produce a malformed key sequence like
	[mode-line mode-line (mouse-1 POSN)]
For this reason, `read-key-sequence' encloses the event's PLACE-SYMBOL
in a singleton list when it first inserts the prefix, but doesn't
insert the prefix when processing events whose PLACE-SYMBOLs are
already thus enclosed.


Changes in version 19.15.

* `make-frame-visible', which uniconified frames, is now a command,
and thus may be bound to a key.  This makes sense because frames
respond to user input while iconified.

* You can now use Meta mouse clicks to set and use the "secondary
selection".  You can drag M-Mouse-1 across the region you want to
select.  Or you can press M-Mouse-1 at one end and M-Mouse-3 at the
other (this also copies the text to the kill ring).  Repeating M-Mouse-3
again at the same place kills that text.

M-Mouse-2 kills the secondary selection.

Setting the secondary selection does not move point or the mark.  It
is possible to make a secondary selection that does not all fit on the
screen, by using M-Mouse-1 at one end, scrolling, then using M-Mouse-3
at the other end.

Emacs has only one secondary selection at any time.  Starting to set
a new one cancels any previous one.  The secondary selection displays
using a face named `secondary-selection'.

* There's a new way to request use of Supercite (sc.el).  Do this:

    (add-hook 'mail-citation-hook 'sc-cite-original)

Currently this works with Rmail.  In the future, other Emacs based
mail-readers should be modified to understand this hook also.
In the mean time, you should keep doing what you have done in the past
for those other mail readers.

* When a regular expression contains `\(...\)' inside a repetition
operator such as `*' or `+', and you ask about the range that was matched
using `match-beginning' and `match-end', the range you get corresponds
to the *last* repetition *only*.  In Emacs 18, you would get a range
corresponding to all the repetitions.

If you want to get a range corresponding to all the repetitions,
put a `\(...\)' grouping *outside* the repetition operator.  This
is the syntax that corresponds logically to the desired result, and
it works the same in Emacs 18 and Emacs 19.

(This change actually took place earlier, but we didn't know about it
and thus didn't document it.)

Changes in version 19.14.

* To modify read-only text, bind the variable `inhibit-read-only'
to a non-nil value.  If the value is t, then all reasons that might
make text read-only are inhibited (including `read-only' text properties).
If the value is a list, then a `read-only' property is inhibited
if it is `memq' in the list.

* If you call `get-buffer-window' passing t as its second argument, it
will only search for windows on visible frames.  Previously, passing t
as the secord argument caused `get-buffer-window' to search all
frames, visible or not.

* If you call `other-buffer' with a nil or omitted second argument, it
will ignore buffers displayed windows on any visible frame, not just
the selected frame.

* You can specify a window or a frame for C-x # to use when
selects a server buffer.  Set the variable server-window
to the window or frame that you want.

* The command M-( now inserts spaces outside the open-parentheses in
some cases--depending on the syntax classes of the surrounding
characters.  If the variable `parens-dont-require-spaces' is non-nil,
it inhibits insertion of these spaces.

* The GUD package now supports the debugger known as xdb on HP/UX
systems.  Use M-x xdb.  The variable `gud-xdb-directories' lets you
specify a list of directories to search for source code.

* If you are using the mailabbrev package, you should note that its
function for defining an alias is now called `define-mail-abbrev'.
This package no longer contains a definition for `define-mail-alias';
that name is used only in mailaliases.

* Inserted characters now inherit the properties of the text before
them, by default, rather than those of the following text.

* The function `insert-file-contents' now takes optional arguments BEG
and END that specify which part of the file to insert.  BEG defaults to
0 (the beginning of the file), and END defaults to the end of the file.

If you specify BEG or END, then the argument VISIT must be nil.

Changes in version 19.13.

* Magic file names can now handle the `load' operation.

* Bibtex mode now sets up special entries in the menu bar.

* The incremental search commands C-w and C-y, which copy text from
the buffer into the search string, now convert it to lower case
if you are in a case-insensitive search.  This is to avoid making
the search a case-sensitive one.

* GNUS now knows your time zone automatically if Emacs does.

* Hide-ifdef mode no longer defines keys of the form
C-c LETTER, since those keys are reserved for users.
Those commands have been moved to C-c M-LETTER.
We may move them again for greater consistency with other modes.

Changes in version 19.12.

* You can now make many of the sort commands ignore case by setting
`sort-fold-case' to a non-nil value.

Changes in version 19.11.

* Supercite is installed.

* `write-file-hooks' functions that return non-nil are responsible
for making a backup file if you want that to be done.
To do so, execute the following code:

   (or buffer-backed-up (backup-buffer))

You might wish to save the file modes value returned by
`backup-buffer' and use that to set the mode bits of the file
that you write.  This is what `basic-save-buffer' does when
it writes a file in the usual way.

(This is not actually new, but wasn't documented before.)

Changes in version 19.10.

* The command `repeat-complex-command' is now on C-x ESC ESC.
It used to be bound to C-x ESC.

The reason for this change is to make function keys work after C-x.

* The variable `highlight-nonselected-windows' now controls whether
the region is highlighted in windows other than the selected window
(in Transient Mark mode only, of course, and currently only when
using X).

Changes in version 19.8.

* It is now simpler to tell Emacs to display accented characters under
X windows.  M-x standard-display-european toggles the display of
buffer text according to the ISO Latin-1 standard.  With a prefix
argument, this command enables European character display iff the
argument is positive.

* The `-i' command-line argument tells Emacs to use a picture of the
GNU gnu as its icon, instead of letting the window manager choose an
icon for it.  This option used to insert a file into the current
buffer; use `-insert' to do that now.

* The `configure' script now supports `--prefix' and `--exec-prefix'
options.

The `--prefix=PREFIXDIR' option specifies where the installation process
should put emacs and its data files.  This defaults to `/usr/local'.
- Emacs (and the other utilities users run) go in PREFIXDIR/bin
  (unless the `--exec-prefix' option says otherwise).
- The architecture-independent files go in PREFIXDIR/lib/emacs/VERSION
  (where VERSION is the version number of Emacs, like `19.7').
- The architecture-dependent files go in
  PREFIXDIR/lib/emacs/VERSION/CONFIGURATION
  (where CONFIGURATION is the configuration name, like mips-dec-ultrix4.2),
  unless the `--exec-prefix' option says otherwise.

The `--exec-prefix=EXECDIR' option allows you to specify a separate
portion of the directory tree for installing architecture-specific
files, like executables and utility programs.  If specified,
- Emacs (and the other utilities users run) go in EXECDIR/bin, and
- The architecture-dependent files go in
  EXECDIR/lib/emacs/VERSION/CONFIGURATION.
EXECDIR/bin should be a directory that is normally in users' PATHs.

* When running under X Windows, the new lisp function `x-list-fonts'
allows code to find out which fonts are available from the X server.
The first argument PATTERN is a string, perhaps with wildcard characters;
  the * character matches any substring, and
  the ? character matches any single character.
  PATTERN is case-insensitive.
If the optional arguments FACE and FRAME are specified, then
`x-list-fonts' returns only fonts the same size as FACE on FRAME.



Changes in version 19.

* When you kill buffers, Emacs now returns memory to the operating system,
thus reducing the size of the Emacs process.  All the space that you free
up by killing buffers can now be reused for other buffers no matter what
their sizes, or reused by other processes if Emacs doesn't need it.

* Emacs now does garbage collection and auto saving while it is waiting
for input, which often avoids the need to do these things while you
are typing.

The variable `auto-save-timeout' says how many seconds Emacs should
wait, after you stop typing, before it does an auto save and a garbage
collection.

* If auto saving detects that a buffer has shrunk greatly, it refrains
from auto saving that buffer and displays a warning.  Now it also turns
off Auto Save mode in that buffer, so that you won't get the same
warning again.

If you reenable Auto Save mode in that buffer, Emacs will start saving
it again with no further warnings.

* A new minor mode called Line Number mode displays the current line
number in the mode line, updating it as necessary when you move
point.

However, if the buffer is very large (larger than the value of
`line-number-display-limit'), then the line number doesn't appear.
This is because computing the line number can be painfully slow if the
buffer is very large.

* You can quit while Emacs is waiting to read or write files.

* The arrow keys now have default bindings to move in the appropriate
directions. 

* You can suppress next-line's habit of inserting a newline when
called at the end of a buffer by setting next-line-add-newlines to nil
(it defaults to t).

* You can now get back recent minibuffer inputs conveniently.  While
in the minibuffer, type M-p to fetch the next earlier minibuffer
input, and use M-n to fetch the next later input.

There are also commands to search forward or backward through the
history for history elements that match a regular expression.  M-r
searches older elements in the history, while M-s searches newer
elements.  By special dispensation, these commands can always use the
minibuffer to read their arguments even though you are already in the
minibuffer when you issue them.

The history feature is available for all uses of the minibuffer, but
there are separate history lists for different kinds of input.  For
example, there is a list for file names, used by all the commands that
read file names.  There is a list for arguments of commands like
`query-replace'.  There are also very specific history lists, such
as the one that `compile' uses for compilation commands.

* You can now display text in a mixture of fonts and colors, using the
"face" feature, together with the overlay and text property features.
See the Emacs Lisp manual for details.  The Emacs Users Manual describes
how to change the colors and font of standard predefined faces.

* You can refer to files on other machines using special file name syntax:

/HOST:FILENAME
/USER@HOST:FILENAME

When you do this, Emacs uses the FTP program to read and write files on
the specified host.  It logs in through FTP using your user name or the
name USER.  It may ask you for a password from time to time; this
is used for logging in on HOST.

* Some C-x key bindings have been moved onto new prefix keys.

C-x r is a prefix for registers and rectangles.
C-x n is a prefix for narrowing.
C-x a is a prefix for abbrev commands.

C-x r C-SPC
C-x r SPC	point-to-register    (Was C-x /)
C-x r j		jump-to-register     (Was C-x j)
C-x r s		copy-to-register     (Was C-x x)
C-x r i		insert-register      (Was C-x g)
C-x r r		copy-rectangle-to-register  (Was C-x r)
C-x r k		kill-rectangle
C-x r y		yank-rectangle
C-x r o		open-rectangle
C-x r f		frame-configuration-to-register
		  (This saves the state of all windows in all frames.)
C-x r w		window-configuration-to-register
		  (This saves the state of all windows in the selected  frame.)

(Use C-x r j to restore a configuration saved with C-x r f or C-x r w.)

C-x n n		narrow-to-region	(Was C-x n)
C-x n p		narrow-to-page		(Was C-x p)
C-x n w		widen			(Was C-x w)

C-x a l		add-mode-abbrev		(Was C-x C-a)
C-x a g		add-global-abbrev	(Was C-x +)
C-x a i l	inverse-add-mode-abbrev	(Was C-x C-h)
C-x a i g	inverse-add-global-abbrev  (Was C-x -)
C-x a e		expand-abbrev		(Was C-x ')

(The old key bindings C-x /, C-x j, C-x x and C-x g
have not yet been removed.)

* You can put a file name in a register to be able to visit the file
quickly.  Do this:

   (set-register ?CHAR '(file . NAME))

where NAME is the file name as a string.  Then C-x r j CHAR finds that
file.

This is useful for files that you need to visit frequently,
but that you don't want to keep in buffers all the time.

* The keys M-g (fill-region) and C-x a (append-to-buffer)
have been eliminated.

* The new command `string-rectangle' inserts a specified string on
each line of the region-rectangle.

* C-x 4 r is now `find-file-read-only-other-window'.

* C-x 4 C-o is now `display-buffer', which displays a specified buffer
in another window without selecting it.

* Picture mode has been substantially improved.  The picture editing commands
now arrange for automatic horizontal scrolling to keep point visible
when editing a wide buffer with truncate-lines on.  Picture-mode
initialization now does a better job of rebinding standard commands;
it finds not just their normal keybindings, but any function keys
attached to them.

* If you enable Transient Mark mode, then the mark becomes "inactive"
after every command that modifies the buffer.  While the mark is
active, the region is highlighted (under X, at least).  Most commands
that use the mark give an error if the mark is inactive, but you can
use C-x C-x to make it active again.  This feature is also sometimes
known as "Zmacs mode".

* Outline mode is now available as a minor mode.  This minor mode can
combine with any major mode; it substitutes the C-c commands of
Outline mode for those of the major mode.  Use M-x outline-minor-mode
to enable and disable the new mode.

M-x outline-mode is unchanged; it still switches to Outline mode as a
major mode.

* The default setting of `version-control' comes from the environment
variable VERSION_CONTROL.

* The user option for controlling whether files can set local
variables is now called `enable-local-variables'.  A value of t means
local-variables lists are obeyed; nil means they are ignored; anything
else means query the user.

The user option for controlling use of the `eval' local variable is
now called is `enable-local-eval'; its values are interpreted like
those of `enable-local-variables'.

* X Window System changes:

C-x 5 C-f and C-x 5 b switch to a specified file or buffer in a new
frame.  Likewise, C-x 5 m starts outgoing mail in another frame, and
C-x 5 . finds a tag in another frame.

When you are using X, C-z now iconifies the selected frame.

Emacs can now exchange text with other X applications.  Killing or
copying text in Emacs now makes that text available for pasting into
other X applications.  The Emacs yanking commands now insert the
latest selection set by other applications, and add the text to the
kill ring.  The Emacs commands for selecting and inserting text with
the mouse now use the kill ring in the same way the keyboard killing
and yanking commands do.

The option to specify the title for the initial frame is now `-name NAME'.
There is currently no way to specify an icon title; perhaps we will add
one in the future.

* Undoing a deletion now puts point back where it was before the
deletion.

* The variables that control how much undo information to save have
been renamed to `undo-limit' and `undo-strong-limit'.  They used to be
called `undo-threshold' and `undo-high-threshold'.

* You can now use kill commands in read-only buffers.  They don't
actually change the buffer, and Emacs will beep and warn you that the
buffer is read-only, but they do copy the text you tried to kill into
the kill ring, so you can yank it into other buffers.

* C-o inserts the fill-prefix on the newly created line.  The command
M-^ deletes the prefix (if it occurs) after the newline that it
deletes.

* C-M-l now runs the command `reposition-window'.  It scrolls the
window heuristically in a way designed to get useful information onto
the screen.

* C-M-r is now reverse incremental regexp search.

* M-z now kills through the target character.  In version 18, it
killed up to but not including the target character.

* M-! now runs the specified shell command asynchronously if it
ends in `&' (just as the shell does).

* C-h C-f and C-h C-k are new help commands that display the Info
node for a given Emacs function name or key sequence, respectively.

* The C-h p command system lets you find Emacs Lisp packages by
topic keywords.  Here is a partial list of package categories:

abbrev	      abbreviation handling, typing shortcuts, macros
bib	      code related to the bib bibliography processor
c	      C and C++ language support
calendar      calendar and time management support
comm	      communications, networking, remote access to files
docs	      support for Emacs documentation
emulations    emulations of other editors
extensions    Emacs Lisp language extensions
games	      games, jokes and amusements
hardware      support for interfacing with exotic hardware
help	      support for on-line help systems
i14n	      internationalization and alternate character-set support
internal      code for Emacs internals, build process, defaults
languages     specialized modes for editing programming languages
lisp	      Lisp support, including Emacs Lisp
local	      code local to your site
maint	      maintenance aids for the Emacs development group
mail	      modes for electronic-mail handling
news	      support for netnews reading and posting
processes     process, subshell, compilation, and job control support
terminals     support for terminal types
tex	      code related to the TeX formatter
tools	      programming tools
unix	      front-ends/assistants for, or emulators of, UNIX features
vms	      support code for vms
wp	      word processing

More will be added soon.

* The command to split a window into two side-by-side windows is now
C-x 3.  It was C-x 5.

* M-. (find-tag) no longer has any effect on what M-, will do
subsequently.  You can no longer use M-, to find the next similar tag;
you must use M-. with a prefix argument, instead.

The motive for this change is so that you can more reliably use
M-, to resume a suspended `tags-search' or `tags-query-replace'.

* C-x s (`save-some-buffers') now gives you more options when it asks
whether to save a particular buffer.  In addition to `y' or `n', you
can answer `!' to save all the remaining buffers, `.' to save this
buffer but not save any others, ESC to stop saving and exit the
command, and C-h to get help.  These options are analogous to those 
of `query-replace'.

* M-x make-symbolic-link does not expand its first argument.
This lets you make a link with a target that is a relative file name.

* M-x add-change-log-entry and C-x 4 a now automatically insert the
name of the file and often the name of the function that you changed.
They also handle grouping of entries.

There is now a special major mode for editing ChangeLog files.  It
makes filling work conveniently.  Each bunch of grouped entries is one
paragraph, and each collection of entries from one person on one day
is considered a page.

* The `comment-region' command adds comment delimiters to the lines that
start in the region, thus commenting them out.  With a negative argument,
it deletes comment delimiters from the lines in the region--this cancels
the effect of `comment-region' without an argument.

With a positive argument, `comment-region' adds comment delimiters
but duplicates the last character of the comment start sequence as many
times as the argument specifies.  This is a way of calling attention to
the comment.  In Lisp, you should use an argument at least two, because
the indentation convention for single semicolon comments does not leave
them at the beginning of a line.

* If `split-window-keep-point' is non-nil, C-x 2 tries to avoid
shifting any text on the screen by putting point in whichever window
happens to contain the screen line the cursor is already on.
The default is that `split-window-keep-point' is non-nil on slow
terminals.

* M-x super-apropos is like M-x apropos except that it searches both
Lisp symbol names and documentation strings for matches.  It describes
every symbol that has a match in either the symbol's name or its
documentation.

Both M-x apropos and M-x super-apropos take an optional second
argument DO-ALL which controls the more expensive part of the job.
This includes looking up and printing the key bindings of all
commands.  It also includes checking documentation strings in
super-apropos.  DO-ALL is nil by default; use a prefix arg to make it
non-nil.

* M-x revert-buffer no longer offers to revert from a recent auto-save
file unless you give it a prefix argument.  Otherwise it always
reverts from the real file regardless of whether there has been an
auto-save since thenm.  (Reverting from the auto-save file is no longer
very useful now that the undo capacity is larger.)

* M-x recover-file no longer turns off Auto Save mode when it reads
the last Auto Save file.

* M-x rename-buffer, if you give it a prefix argument,
avoids errors by modifying the new name to make it unique.

* M-x rename-uniquely renames the current buffer to a similar name
with a numeric suffix added to make it both different and unique.

One use of this command is for creating multiple shell buffers.
If you rename your shell buffer, and then do M-x shell again, it
makes a new shell buffer.  This method is also good for mail buffers,
compilation buffers, and any Emacs feature which creates a special
buffer with a particular name.

* M-x compare-windows with a prefix argument ignores changes in whitespace.
If `compare-ignore-case' is non-nil, then differences in case are also
ignored.

* `backward-paragraph' is now bound to M-{ by default, and `forward-paragraph'
to M-}.  Originally, these commands were bound to M-[ and M-], but they were
running into conflicts with the use of function keys.  On many terminals,
function keys send a sequence beginning ESC-[, so many users have defined this
as a prefix key.

* C-x C-u (upcase-region) and C-x C-l (downcase-region) are now disabled by
default; these commands seem to be often hit by accident, and can be
quite destructive if their effects are not noticed immediately.

* The function `erase-buffer' is now interactive, but disabled by default.

* When visiting a new file, Emacs attempts to abbreviate the file's
path using the symlinks listed in `directory-abbrev-alist'.

* When you visit the same file in under two names that translate into
the same name once symbolic links are handled, Emacs warns you that
you have two buffers for the same file.

* If you wish to avoid visiting the same file in two buffers under
different names, set the variable `find-file-existing-other-name'
non-nil.  Then `find-file' uses the existing buffer visiting the file,
no matter which of the file's names you specify.

* If you set `find-file-visit-truename' non-nil, then the file name
recorded for a buffer is the file's truename (in which all symbolic
links have been removed), rather than the name you specify.  Setting
`find-file-visit-truename' also implies the effect of
`find-file-existing-other-name'.

* C-x C-v now inserts the entire current file name in the minibuffer.
This is convenient if you made a small mistake in typing it.  Point
goes after the last slash, before the last file name component, so if
you want to replace it entirely, you can use C-k right away to delete
it.

* Commands such as C-M-f in Lisp mode now ignore parentheses within comments.

* C-x q now uses ESC to terminate all iterations of the keyboard
macro, rather than C-d as before.

* Use the command `setenv' to set an individual environment variable
for Emacs subprocesses.  Specify a variable name and a value, both as
strings.  This command applies only to subprocesses yet to be
started.

* Use `rot13-other-window' to examine a buffer with rot13.

This command does not change the text in the buffer.  Instead, it
creates a window with a funny display table that applies the code when
displaying the text.

* The command `M-x version' now prints the current Emacs version; The
`version' command is an alias for the `emacs-version' command.

* More complex changes in existing packages.

** `fill-nonuniform-paragraphs' is a new command, much like
`fill-individual-paragraphs' except that only separator lines separate
paragraphs.  Since this means that the lines of one paragraph may have
different amounts of indentation, the fill prefix used is the smallest
amount of indentation of any of the lines of the paragraph.

** Filling is now partially controlled by a new minor mode, Adaptive
Fill mode.  When this mode is enabled (and it is enabled by default),
if you use M-x fill-region-as-paragraph on an indented paragraph and
you don't have a fill prefix, it uses the indentation of the second
line of the paragraph as the fill prefix.

Adaptive Fill mode doesn't have much effect on M-q in most major
modes, because an indented line will probably count as a paragraph
starter and thus each line of an indented paragraph will be considered
a paragraph of its own.

** M-q in C mode now runs `c-fill-paragraph', which is designed
for filling C comments.  (We assume you don't want to fill
the code in a C program.)

** M-$ now runs the Ispell program instead of the Unix spell program.

M-$ starts an Ispell process the first time you use it.  But the process
stays alive, so that subsequent uses of M-$ run very fast.
If you want to get rid of the process, use M-x kill-ispell.

To check the entire current buffer, use M-x ispell-buffer.
Use M-x ispell-region to check just the current region.

Ispell commands often involve interactive replacement of words.
You can interrupt the interactive replacement with C-g.
You can restart it again afterward with C-u M-$.

During interactive replacement, you can type the following characters:

a	Accept this word this time.
DIGIT	Replace the word (this time) with one of the displayed near-misses.
	The digit you use says which near-miss to use.
i	Insert this word in your private dictionary
	  so that Ispell will consider it correct it from now on.
r	Replace the word this time with a string typed by you.

When the Ispell process starts, it reads your private dictionary which
is the file `~/ispell.words'.  If you "insert" words with the `i' command,
these words are added to that file, but not right away--only at the end
of the interactive replacement process.

Use M-x reload-ispell to reload your private dictionary from
`~/ispell.words' if you edit it outside of Ispell.

* Changes in existing modes.

** gdb-mode has been replaced by gud-mode.

The package gud.el (Grand Unified Debugger) replaces gdb.el in Emacs
19.  It provides a gdb.el-like interface to any of three debuggers;
gdb itself, the sdb debugger supported on some Unix systems, or the
dbx debugger on Berkeley systems.

   You start it up with one of the commands M-x gdb, M-x sdb, or
M-x dbx.  Each entry point finishes by executing a hook; gdb-mode-hook,
sdb-mode-hook or dbx-mode-hook respectively.

These bindings have changed:
C-x C-a >	gud-down			(was M-d)
C-x C-a <	gud-up				(was M-u)
C-x C-a C-r	gud-cont			(was M-c)
C-x C-a C-n	gud-next			(was M-n)
C-x C-a C-s	gud-step			(was M-s)
C-x C-a C-i 	gud-stepi			(was M-i)
C-x C-a C-l	gud-recenter			(was C-l)
C-d		comint-delchar-or-maybe-eof	(was C-c C-d)

These bindings have been removed:
C-c C-r		(was comint-show-output; now gud-cont)

Since GUD mode uses comint, it uses comint's input history commands,
superseding C-c C-y (copy-last-shell-input):
  M-p		comint-next-input
  M-n		comint-previous-input
  M-r		comint-previous-similar-input
  M-s		comint-next-similar-input
  M-C-r		comint-previous-input-matching

The C-x C-a bindings are also active in source files.

** The old TeX mode bindings of M-{ and M-} have been moved to C-c {
and C-c }.  (These commands are `up-list' and `tex-insert-braces';
they are the TeX equivalents of M-( and M-).)  This is because M-{ 
and M-} are now globally defined commands.

** Changes in Mail mode.

`%' is now a word-separator character in Mail mode.

`mail-signature', if non-nil, tells M-x mail to insert your
`.signature' file automatically.  If you don't want your signature in
a particular message, just delete it before you send the message.

You can specify the text to insert at the beginning of each line when
you use C-c C-y to yank the message you are replying to.  Set
`mail-yank-prefix' to the desired string.  A value of `nil' (the
default) means to use indentation, as in Emacs 18.  If you use just
C-u as the prefix argument to C-c C-y, then it does not insert
anything at the beginning of the lines, regardless of the value of
`mail-yank-prefix'.

If you like, you can expand mail aliases as abbrevs, as soon as you
type them in.  To enable this feature, execute the following:

    (add-hook 'mail-setup-hook 'mail-abbrevs-setup)

This can go in your .emacs file.

Word abbrevs don't expand unless you insert a word-separator character
afterward.  Any mail aliases that you didn't expand at insertion time
are expanded subsequently when you send the message.

** Changes in Rmail.

Rmail by default gets new mail only from the system inbox file,
not from `~/mbox'.

In Rmail, you can retry sending a message that failed
by typing `M-m' on the failure message.

By contrast, another new command M-x rmail-resend is used for
forwarding a message and marking it as "resent from" you
with header fields "Resent-From:" and "Resent-To:".

`e' is now the command to edit a message.
To expunge, type `x'.  We know this will surprise people
some of the time, but the surprise will not be disastrous--if
you type `e' meaning to expunge, just turn off editing with C-c C-c
and then type `x'.

Another new Rmail command is `<', which moves to the first message.
This is for symmetry with `>'.

Use the `b' command to bury the Rmail buffer and its summary buffer,
if any, removing both of them from display on the screen.

The variable `rmail-output-file-alist' now controls the default
for the file to output a message to.

In the Rmail summary buffer, all cursor motion commands select
the message you move to.  It's really neat when you use
incremental search.

You can now issue most Rmail commands from an Rmail summary buffer.
The commands do the same thing in that buffer that they do in the
Rmail buffer.  They apply to the message that is selected in the Rmail
buffer, which is always the one described by the current summary
line.

Conversely, motion and deletion commands in the Rmail buffer also
update the summary buffer.  If you set the variable
`rmail-redisplay-summary' to a non-nil value, then they bring the
summary buffer (if one exists) back onto the screen.

C-M-t is a new command to make a summary by topic.  It uses regexp
matching against just the subjects of the messages to decide which
messages to show in the summary.

You can easily convert an Rmail file to system mailbox format with the
command `unrmail'.  This command reads two arguments, the name of
the Rmail file to convert, and the name of the new mailbox file.
(This command does not change the Rmail file itself.)

Rmail now handles Content Length fields in messages.

** `mail-extract-address-components' unpacks mail addresses.
It takes an address as a string (the contents of the From field, for
example) and returns a list of the form (FULL-NAME
CANONICAL-ADDRESS).

** Changes in C mode and C-related commands.

*** M-x c-up-conditional

In C mode, `c-up-conditional' moves back to the containing
preprocessor conditional, setting the mark where point was
previously.

A prefix argument acts as a repeat count.  With a negative argument,
this command moves forward to the end of the containing preprocessor
conditional.  When going backwards, `#elif' acts like `#else' followed
by `#if'.  When going forwards, `#elif' is ignored.

*** In C mode, M-a and M-e are now defined as
`c-beginning-of-statement' and `c-end-of-statement'.

*** In C mode, M-x c-backslash-region is a new command to insert or
align `\' characters at the ends of the lines of the region, except
for the last such line.  This is useful after writing or editing a C
macro definition.

If a line already ends in `\', this command adjusts the amount of
whitespace before it.  Otherwise, it inserts a new `\'.

** New features in info.

When Info looks for an Info file, it searches the directories
in `Info-directory-list'.  This makes it easy to install the Info files
that come with various packages.  You can specify the path with
the environment variable INFOPATH.

There are new commands in Info mode.

`]' now moves forward a node, going up and down levels as needed.
`[' is similar but moves backward.  These two commands try to traverse
the entire Info tree, node by node.  They are the equivalent of reading
a printed manual sequentially.

`<' moves to the top node of the current Info file.
`>' moves to the last node of the file.

SPC scrolls through the current node; at the end, it advances to the
next node in depth-first order (like `]').

DEL scrolls backwards in the current node; at the end, it moves to the
previous node in depth-first order (like `[').

After a menu select, the info `up' command now restores point in the
menu.  The combination of this and the previous two changes means that
repeated SPC keystrokes do the right (depth-first traverse forward) thing.

`i STRING RET' moves to the node associated with STRING in the index
or indices of this manual.  If there is more than one match for
STRING, the `i' command finds the first match.

`,' finds the next match for the string in the previous `i' command

If you click the middle mouse button near a cross-reference,
menu item or node pointer while in Info, you will go to the node
which is referenced.

** Changes in M-x compile.

You can repeat any previous compilation command conveniently using the
minibuffer history commands, while in the minibuffer entering the
compilation command.

While a compilation is going on, the string `Compiling' appears in
the mode line.  When this string disappears, that tells you the
compilation is finished.

The buffer of compiler messages is in Compilation mode.  This mode
provides the keys SPC and DEL to scroll by screenfuls, and M-n and M-p
to move to the next or previous error message.  You can also use C-c
C-c on any error message to find the corresponding source code.

Emacs 19 has a more general parser for compiler messages.  For example, it
can understand messages from lint, and from certain C compilers whose error
message format is unusual.  Also, it only parses until it sees the error
message you want; you never have to wait a long time to see the first
error, no matter how big the buffer is.

** M-x diff and M-x diff-backup.

This new command compares two files, displaying the differences in an
Emacs buffer.  The options for the `diff' program come from the
variable `diff-switches', whose value should be a string.

The buffer of differences has Compilation mode as its major mode, so you
can use C-x ` to visit successive changed locations in the two
source files, or you can move to a particular hunk of changes and type
C-c C-c to move to the corresponding source.  You can also use the
other special commands of Compilation mode: SPC and DEL for
scrolling, and M-n and M-p for cursor motion.

M-x diff-backup compares a file with its most recent backup.
If you specify the name of a backup file, `diff-backup' compares it
with the source file that it is a backup of.

** The View commands (such as M-x view-buffer and M-x view-file) no
longer use recursive edits; instead, they switch temporarily to a
different major mode (View mode) specifically designed for moving
around through a buffer without editing it.

** Changes in incremental search.

*** The character to terminate an incremental search is now RET.
This is for compatibility with the way most other arguments are read.

To search for a newline in an incremental search, type LFD (also known
as C-j).

*** Incremental search now maintains a ring of previous search
strings.  Use M-p and M-n to move through the ring to pick a search
string to reuse.  These commands leave the selected search ring
element in the minibuffer, where you can edit it.  Type C-s or C-r to
finish editing and search for the chosen string.

*** If you type an upper case letter in incremental search, that turns
off case-folding, so that you get a case-sensitive search.

*** If you type a space during regexp incremental search, it matches
any sequence of whitespace characters.  If you want to match just a space,
type C-q SPC.

*** Incremental search is now implemented as a major mode.  When you
type C-s, it switches temporarily to a different keymap which defines
each key to do what it ought to do for incremental search.  This has
next to no effect on the user-visible behavior of searching, but makes
it easier to customize that behavior.

Emacs 19 eliminates the old variables `search-...-char' that used to
be the way to specify the characters to use for various special
purposes in incremental search.  Instead, you can define the meaning
of a character in incremental search by modifying `isearch-mode-map'.

** New commands in Buffer Menu mode.

The command C-o now displays the current line's buffer in another
window but does not select it.  This is like the existing command `o'
which selects the current line's buffer in another window.

The command % toggles the read-only flag of the current line's buffer.

The way to switch to a set of several buffers, including those marked
with m, is now v.  The q command simply quits, replacing the buffer
menu buffer with the buffer that was displayed previously.

* New major modes and packages.

** The news reader GNUS is now installed.

** There is a new interface for version control systems, called VC.
It works with both RCS and SCCS; in fact, you don't really have to
know which one of them is being used, because it automatically deals
with either one.

Most of the time, the only command you have to know about is C-x C-q.
This command normally toggles the read-only flag of the current
buffer.  If the buffer is visiting a file that is maintained with a
version control system, the command still toggles read-only, but does
so by checking the file in or checking it out.

When you check a file in, VC asks you for a log entry by popping up a
buffer.  Edit the entry there, then type C-c C-c when it is ready.
That's when the actual checkin happens.  If you change your mind about
the checkin, simply switch buffers and don't ever go back to the log
buffer.

To start using version control for a file, use the command C-x v v.
This works like C-x C-q (performing the next logical version-control
operation needed to change the file's writeability) but it will also
perform initial checkin on an unregistered file.

By default, VC uses RCS if RCS is installed on your machine;
otherwise, SCCS.  If you want to make the choice explicitly, you can do
it by setting `vc-default-back-end' to the symbol `RCS' or the symbol
`SCCS'.

You can tell when a file you visit is maintained with version control
because either `RCS' or `SCCS' appears in the mode line.

** A new Calendar mode has been added, based on the work of Nachum
Dershowitz and Edward M. Reingold.  The mode can display the Gregorian
calendar and a variety of other calendars at any date, and interacts
with a diary facility similar to the UNIX `calendar' utility.

** There is a new major mode for editing binary files: Hexl mode.
To use it, use M-x hexl-find-file instead of C-x C-f to visit the file.
This command converts the file's contents to hexadecimal and lets you
edit the translation.  When you save the file, it is converted 
automatically back to binary.

You can also use M-x hexl-mode to translate an existing buffer into hex.
Do this if you have already visited a binary file.  

Hexl mode has a few other commands:

C-M-d	insert a byte with a code typed in decimal.
C-M-o	insert a byte with a code typed in octal.
C-M-x	insert a byte with a code typed in hex.

C-x [   move to the beginning of a 1k-byte "page".
C-x ]   move to the end of a 1k-byte "page".

M-g     go to an address specified in hex.
M-j	go to an address specified in decimal.

C-c C-c	leave hexl mode and go back to the previous major mode.

** Miscellaneous new major modes include Awk mode, Icon mode, Makefile
mode, Perl mode and SGML mode.

** Edebug, a new source-level debugger for Emacs Lisp functions.

To use Edebug, use the command M-x edebug-defun to "evaluate" a
function definition in an Emacs Lisp file.  We put "evaluate" in
quotation marks because it doesn't just evaluate the function, it also
inserts additional information to support source-level debugging.

You must also do

    (setq debugger 'edebug-debug)

to cause errors and single-stepping to use Edebug instead of the usual
Emacs Lisp debugger.

For more information, see the Edebug manual, which should be included
in the Emacs distribution.

** C++ mode is like C mode, except that it understands C++ comment syntax
and certain other differences between C and C++.  It also has a command
`fill-c++-comment' which fills a paragraph made of comment lines.

The command `comment-region' is useful in C++ mode for commenting out
several consecutive lines, or removing the commenting out of such lines.

** A new package for merging two variants of the same text.

It's not unusual for programmers to get their signals crossed and
modify the same program in two different directions.  Then somebody
has to merge the two versions.  The command `emerge-files' makes this
easier.

`emerge-files' reads two file names and compares them.  Then it
displays three buffers: one for each file, and one for the
differences.

If the original version of the file is available, you can make things
even easier using `emerge-files-with-ancestor'.  It reads three file
names--variant 1, variant 2, and the common ancestor--and uses diff3
to compare them.

You control the merging interactively.  The main loop of Emerge
consists of showing you one set of differences, asking you what to do
about them, and doing it.  You have a choice of two modes for giving
directions to Emerge: "fast" mode and "edit" mode.

In Fast mode, Emerge commands are single characters, and ordinary
Emacs commands are disabled.  This makes Emerge operations fast, but
prevents you from doing more than selecting the A or the B version of
differences.  In Edit mode, all emerge commands use the C-c prefix,
and the usual Emacs commands are available.  This allows editing the
merge buffer, but slows down Emerge operations.  Edit and fast modes
are indicated by `F' and `E' in the minor modes in the mode line.

The Emerge commands are:

	p	go to the previous difference
	n	go to the next difference
	a	select the A version of this difference
	b	select the B version of this difference
	j	go to a particular difference (prefix argument
		specifies which difference) (0j suppresses display of
		the flags)
	q	quit - finish the merge*
	f	go into fast mode
	e	go into edit mode
	l	recenter (C-l) all three windows*
	- and 0 through 9
		prefix numeric arguments
	d a	select the A version as the default from here down in
		the merge buffer*
	d b	select the B version as the default from here down in
		the merge buffer*
	c a	copy the A version of the difference into the kill
		ring
	c b	copy the B version of the difference into the kill
		ring
	i a	insert the A version of the difference at the point
	i b	insert the B version of the difference at the point
	m	put the point and mark around the difference region
	^	scroll-down (like M-v) the three windows*
	v	scroll-up (like C-v) the three windows*
	<	scroll-left (like C-x <) the three windows*
	>	scroll-right (like C-x >) the three windows*
	|	reset horizontal scroll on the three windows*
	x 1	shrink the merge window to one line (use C-u l to restore it
		to full size)
	x a	find the difference containing a location in the A buffer*
	x b	find the difference containing a location in the B buffer*
	x c	combine the two versions of this difference*
	x C	combine the two versions of this difference, using a
		register's value as the template*
	x d	find the difference containing a location in the merge buffer*
	x f	show the files/buffers Emerge is operating on in Help window
		(use C-u l to restore windows)
	x j	join this difference with the following one
		(C-u x j joins this difference with the previous one)
	x l	show line numbers of points in A, B, and merge buffers
	x m	change major mode of merge buffer*
	x s	split this difference into two differences
		(first position the point in all three buffers to the places
		to split the difference)
	x t	trim identical lines off top and bottom of difference
		(such lines occur when the A and B versions are
		identical but differ from the ancestor version)
	x x	set the template for the x c command*

Normally, the merged output goes back in the first file specified.
If you use a prefix argument, Emerge reads another file name to use
for the output file.

Once Emerge has prepared the buffer of differences, it runs the hooks
in `emerge-startup-hooks'.

** Asm mode is a new major mode for editing files of assembler code.
It defines these commands:

TAB	tab-to-tab-stop.
LFD	Insert a newline and then indent using tab-to-tab-stop.
:	Insert a colon and then remove the indentation
	from before the label preceding colon.  Then tab-to-tab-stop.
;	Insert or align a comment.

** Two-column mode lets you conveniently edit two side-by-side columns
of text.  It works using two side-by-side windows, each showing its
own buffer.

Here are three ways to enter two-column mode:

C-x 6 2 makes the current buffer into the left-hand buffer.  It the
right-hand window it puts a buffer whose name is based on the current
buffer's name.

C-x 6 b BUFFER RET makes the current buffer into the left-hand buffer,
and uses buffer BUFFER as the right-hand buffer.

C-x 6 s splits the current buffer, which contains two-column text,
into two side-by-side buffers.  The old current buffer becomes the
left-hand buffer, but the text in the right column is moved into the
right-hand buffer.  The current column specifies the split point.
Splitting starts with the current line and continues to the end of the
buffer.

C-x 6 s takes a prefix argument which specifies how many characters
before point constitute the column separator.  (The default argument
is 1, as usual, so by default the column separator is the character
before point.)  Lines that don't have the column separator at the
proper place remain unsplit; they stay in the left-hand buffer, and
the right-hand buffer gets an empty line to correspond.

You can scroll both buffers together using C-x 6 SPC (scroll up), C-x
6 DEL (scroll down), and C-x 6 RET (scroll up one line).  C-x 6 C-l
recenters both buffers together.

If you want to make a lines which will span both columns, put it in
the left-hand buffer, with an empty line in the corresponding place in
the right-hand buffer.

When you have edited both buffers as you wish, merge them with C-x 6
1.  This copies the text from the right-hand buffer as a second column
in the other buffer.  To go back to two-column editing, use C-x 6 s.

Use C-x 6 d to disassociate the two buffers, leaving each as it
stands.  (If the other buffer, the one that was not current when you
type C-x 6 d, is empty, C-x 6 d kills it.)

** You can supply command arguments such as files to visit to an Emacs
that is already running.  To do this, you must do this in your .emacs
file:
   (add-hook 'suspend-hook 'resume-suspend-hook)
Also you must use the shellscript emacs.csh or emacs.sh, found in the
etc subdirectory.

** Shell mode has been completely replaced.
The basic idea is the same, but there are new commands available in
this mode.
      
TAB now completes the file name before point in the shell buffer.
To get a list of all possible completions, type M-?.

There is a new convenient history mechanism for repeating previous
commands.  Use the command M-p to recall the last command; it copies
the text of that command to the place where you are editing.  If you
repeat M-p, it replaces the copied command with the previous command.
M-n is similar but goes in the opposite direction towards the present.
When you find the command you wanted, you can edit it, or just
resubmit it by typing RET.

You can also use M-r and M-s to search for (respectively) earlier or 
later inputs starting with a given string.  First type the string, 
then type M-r to yank a previous input from the history which starts
with that string.  You can repeat M-r to find successively earlier
inputs starting with the same string.  You can start moving in the
opposite direction (toward more recent inputs) by typing M-s instead
of M-r.  As long as you don't use any commands except M-r and M-s,
they keep using the same string that you had entered initially.

C-c C-o kills the last batch of output from a shell command.  This is
useful if a shell command spews out lots of output that just gets in
the way.

C-c C-r scrolls to display the beginning of the last batch of output
at the top of the window; it also moves the cursor there.

C-a on a line that starts with a shell prompt moves to the end of the
prompt, not to the very beginning of the line.

C-d typed at the end of the shell buffer sends EOF to the subshell.
At any other position in the buffer, it deletes a character as usual.

If Emacs gets confused while trying to track changes in the shell's
current directory, type M-x dirs to re-synchronize.

M-x send-invisible reads a line of text without echoing it, and
sends it to the shell.

If you accidentally suspend your process, use M-x comint-continue-subjob 
to continue it.
         
** There is now a convenient way to enable flow control on terminals
where you can't win without it.  Suppose you want to do this on
VT-100 and H19 terminals; put the following in your `.emacs' file:

   (enable-flow-control-on "vt100" "h19")

When flow control is enabled, you must type C-\ to get the effect of a
C-s, and type C-^ to get the effect of a C-q.

The function `enable-flow-control' enables flow control unconditionally.

* Changes in Dired

Dired has many new features which allow you to do these things:

- Rename, copy, or make links to many files at once.

- Make distinguishable types of marks for different operations.

- Display contents of subdirectories in the same Dired buffer as the
parent directory.

** Setting and Clearing Marks

There are now two kinds of marker that you can put on a file in Dired:
`D' for deletion, and `*' for any other kind of operation.
The `x' command deletes only files marked with `D', and most
other Dired commands operate only on the files marked with `*'.

To mark files with `D' (also called "flagging" the files), you
can use `d' as usual.  Here are some commands for marking with
`*' (and also for unmarking):

*** `m' marks the current file with `*', for an operation other than
deletion.

*** `*' marks all executable files.  With a prefix argument, it
unmarks all those files.

*** `@' marks all symbolic links.  With a prefix argument, it unmarks
all those files.

*** `/' marks all directory files except `.' and `..'.  With a prefix
argument, it unmarks all those files.

*** M-DEL removes a specific or all marks from every file.  With an
argument, queries for each marked file.  Type your help character,
usually C-h, at that time for help.

*** `c' replaces all marks that use the character OLD with marks that
use the character NEW.  You can use almost any character as a mark
character by means of this command, to distinguish various classes of
files.  If OLD is ` ', then the command operates on all unmarked
files; if NEW is ` ', then the command unmarks the files in acts on.

** Operating on Multiple Files

The Dired commands to operate directly on files (rename them, copy
them, and so on) have been generalized to work on multiple files.
There are also some additional commands in this series.

All of these commands use the same convention to decide which files to
manipulate:

- If you give the command a numeric prefix argument @var{n}, it operates
on the next @var{n} files, starting with the current file.

- Otherwise, if there are marked files, the commands operate on all the
marked files.

- Otherwise, the command operates on the current file only.

These are the commands:

*** `C' copies the specified files.  You must specify a directory to
copy into, or (if copying a single file) a new name.

If `dired-copy-preserve-time' is non-`nil', then copying sets
the modification time of the new file to be the same as that of the old
file.

*** `R' renames the specified files.  You must specify a directory to
rename into, or (if renaming a single file) a new name.

Dired automatically changes the visited file name of buffers associated
with renamed files so that they refer to the new names.

*** `H' makes hard links to the specified files.  You must specify a
directory to make the links in, or (if making just one link) the name
to give the link.

*** `S' makes symbolic links to the specified files.  You must specify
a directory to make the links in, or (if making just one link) the
name to give the link.

*** `M' changes the mode of the specified files.  This calls the
`chmod' program, so you can describe the desired mode change with any
argument that `chmod' would handle.

*** `G' changes the group of the specified files.

*** `O' changes the owner of the specified files.  (On normal systems,
only the superuser can do this.)

The variable `dired-chown-program' specifies the name of the
program to use to do the work (different systems put `chown' in
different places.

*** `Z' compresses or uncompresses the specified files.

*** `L' loads the specified Emacs Lisp files.

*** `B' byte compiles the specified Emacs Lisp files.

*** `P' prints the specified files.  It uses the variables
`lpr-command' and `lpr-switches' just as `lpr-file' does.

** Shell Commands in Dired

`!' reads a shell command string in the minibuffer and runs the shell
command on all the specified files.  There are two ways of applying a
shell command to multiple files:

- If you use `*' in the command, then the shell command runs just
once, with the list of file names substituted for the `*'.

Thus, `! tar cf foo.tar * RET' runs `tar' on the entire list of file
names, putting them into one tar file `foo.tar'.  The file names are
inserted in the order that they appear in the Dired buffer.

- If the command string doesn't contain `*', then it runs once for
each file, with the file name attached at the end.  For example, `!
uudecode RET' runs `uudecode' on each file.

To run the shell command once for each file but without being limited
to putting the file name inserted in the middle, use a shell loop.
For example, this shell command would run `uuencode' on each of the
specified files, writing the output into a corresponding `.uu' file:

    for file in *; uuencode $file $file >$file.uu; done

The working directory for the shell command is the top level directory
of the Dired buffer.

** Regular Expression File Name Substitution

*** `% m REGEXP RET' marks all files whose names match the regular
expression REGEXP.

Only the non-directory part of the file name is used in matching.  Use
`^' and `$' to anchor matches.  Exclude subdirs by hiding them.

*** `% d REGEXP RET' flags for deletion all files whose names match
the regular expression REGEXP.

*** `% R', `% C', `% H', `% S'

These four commands rename, copy, make hard links and make soft links,
in each case computing the new name by regular expression substitution
from the name of the old file.  They  effectively perform
`query-replace-regexp' on the selected file names in the Dired buffer.

The commands read two arguments: a regular expression, and a
substitution pattern.  Each selected file name is matched against the
regular expression, and then the part which matched is replaced with
the substitution pattern.  You can use `\&' and `\DIGIT' in the
substitution pattern to refer to all or part of the old file name.

If the regular expression matches more than once in a file name,
only the first match is replaced.

Normally, the replacement process does not consider the directory names;
it operates on the file name within the directory.  If you specify a
prefix argument of zero, then replacement affects entire file name.

To apply the command to all files matching the same regexp that you
use in the command, mark those files with `% m REGEXP RET', then use
the same regular expression in `% R'.  To make this easier, `% R' uses
as a default the last regular expression specified in a `%' command.

** Dired Case Conversion

*** `% u' renames each of the selected files to an upper case name.

*** `% l' renames each of the selected files to a lower case name.

** File Comparison with Dired

*** `=' compares the current file with another file (the file at the
mark), by running the `diff' program.  The file at the mark is given
to `diff' first.

*** `M-=' compares the current file with its backup file.  If there
are several numerical backups, it uses the most recent one.  If this
file is a backup, it is compared with its original.

The backup file is the first file given to `diff'.

** Subdirectories in Dired

You can display more than one directory in one Dired buffer.
The simplest way to do this is to specify the options `-lR' for
running `ls'.  That produces a recursive directory listing showing
all subdirectories, all within the same Dired buffer.

You can also insert the contents of a particular subdirectory with the
`i' command.  Use this command on the line that describes a file which
is a directory.  Inserted subdirectory contents follow the top-level
directory of the Dired buffer, just as they do in `ls -lR' output.

If the subdirectory's contents are already present in the buffer, the
`i' command just moves to it (type `l' to refresh it).  It sets the
Emacs mark before moving, so C-x C-x takes you back to the old
position in the buffer.

When you have subdirectories in the Dired buffer, you can use the page
motion commands C-x [ and C-x ] to move by entire directories.

The following commands move up and down in the tree of directories
in one Dired buffer:

*** C-M-u  Go up to the parent directory's headerline.

*** C-M-d  Go down in the tree, to the first subdirectory's
headerline.

*** C-M-n  Go to next subdirectory headerline, regardless of level.

*** C-M-p  Go to previous subdirectory headerline, regardless of
level.

** Hiding Subdirectories

"Hiding" a subdirectory means to make it invisible, except for its
headerline.  Files inside a hidden subdirectory are never considered
by Dired.  For example, the commands to operate on marked files ignore
files in hidden directories even if they are marked.

*** `$' hides or unhides the current subdirectory and move to next
subdirectory.  A prefix argument serves as a repeat count.

*** `M-$' hides all subdirectories, leaving only their header lines.
Or, if at least one subdirectory is currently hidden, it makes
everything visible again.  You can use this command to get an overview
in very deep directory trees or to move quickly to subdirectories far
away.

** Editing the Dired Buffer

*** `l' updates the specified files in a Dired buffer.  This means
reading their current status from the file system and changing the
buffer to reflect it properly.

If you use this command on a subdirectory header line, it updates the
contents of the subdirectory.

*** `g' updates the entire contents of the Dired buffer.  It preserves
all marks except for those on files that have vanished.  Hidden
subdirectories are updated but remain hidden.

*** `k' kills all marked lines (not the files).  With a prefix
argument, it kills that many lines starting with the current line.

This command does not delete files; it just deletes text from the Dired
buffer.

If you kill the line for a file that is a directory, then its contents
are also deleted from the buffer.  Typing `C-u k' on the header line
for a subdirectory is another way to delete a subdirectory from the
Dired buffer.

** `find' and Dired.

To search for files with names matching a wildcard pattern use
`find-name-dired'.  Its arguments are DIRECTORY and
PATTERN.  It selects all the files in DIRECTORY or its
subdirectories whose own names match PATTERN.

The files thus selected are displayed in a Dired buffer in which the
ordinary Dired commands are available.

If you want to test the contents of files, rather than their names, use
`find-grep-dired'.  This command takes two minibuffer arguments,
DIRECTORY and REGEXP; it selects all the files in
DIRECTORY or its subdirectories that contain a match for
REGEXP.  It works by running `find' and `grep'.

The most general command in this series is `find-dired', which lets
you specify any condition that `find' can test.  It takes two
minibuffer arguments, DIRECTORY and FIND-ARGS; it runs `find' in
DIRECTORY with using FIND-ARGS as the arguments to `find' specifying
which files to accept.  To use this command, you need to know how to
use `find'.

* New amusements and novelties.

** `M-x mpuz' displays a multiplication puzzle, in which each letter
stands for a digit, and you must determine which digit.  The puzzles
are determined randomly, so they are always different.

** `M-x gomoku' plays the game Gomoku with you.  It needs more work.

** `M-x spook' adds a line of randomly chosen keywords to an outgoing
mail message.  The keywords are chosen from a list of words that
suggest you are discussing something subversive.

The idea is that the NSA reads all messages that contain keywords
suggesting they might be interested, and that adding these lines could
help to overload them.  I would guess that they have modified their
program by now to ignore these lines of keywords; perhaps the program
can be updated if some clever hacker can determine what criterion they
actually use now.

* Installation changes

** The configure script has been provided to help with the
installation process.  It takes the place of editing the Makefiles and
src/config.h, and can often guess the appropriate operating system to
use for a particular machine type.  See INSTALL for a more detailed
description of the steps required for installation.

** If you create a Lisp file named `site-start.el', Emacs loads the file
whenever it starts up.

** A new Lisp variable, `data-directory', indicates the directory
containing the DOC file, tutorial, copying agreement, and other
familiar `etc' files.  The value of `data-directory' is a simple string.
The default should be set at build time, and the person installing
Emacs should place all the data files in this directory.  The `help.el'
functions that look for docstrings and information files check this
variable.  All Emacs Lisp packages should also be coded so that they
refer to `data-directory' to find data files.

** The PURESIZE definition has been moved from config.h to its own
file, puresize.h.  Since almost every file of C source in the
distribution depends on config.h, but only alloc.c and data.c depend
on puresize.h, this means that changing the value of PURESIZE causes
only those two files to be recompiled.

** The makefile at the top of the Emacs source tree now supports a
`dist' target, which creates a compressed tar file suitable for
distribution, using the contents of the source tree.  Object files,
old file versions, executables, DOC files, and other
architecture-specific or easy-to-recreate files are not included in
the tar file.

For older news, see the file ONEWS.
For Lisp changes in Emacs 19, see the file news.texi.

----------------------------------------------------------------------
Copyright information:

Copyright (C) 1993 Free Software Foundation, Inc.

   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 this permission notice are preserved,
   thus giving the recipient permission to redistribute in turn.

   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.

Local variables:
mode: text
end:
