(easy-mmode-define-navigation): Only use `ding' for interactive use

[emacs.git] / etc / OOOOONEWS

Old GNU Emacs NEWS -- history of user-visible changes thru version 15.
Copyright (C) 1985 Richard M. Stallman.
See the end for copying conditions.
\f
Changes in Emacs 15

* Emacs now runs on Sun and Megatest 68000 systems;
 also on at least one 16000 system running 4.2.

* Emacs now alters the output-start and output-stop characters
 to prevent C-s and C-q from being considered as flow control
 by cretinous rlogin software in 4.2.

* It is now possible convert Mocklisp code (for Gosling Emacs) to Lisp code
 that can run in GNU Emacs.  M-x convert-mocklisp-buffer
 converts the contents of the current buffer from Mocklisp to
 GNU Emacs Lisp.  You should then save the converted buffer with C-x C-w
 under a name ending in ".el"

 There are probably some Mocklisp constructs that are not handled.
 If you encounter one, feel free to report the failure as a bug.
 The construct will be handled in a future Emacs release, if that is not
 not too hard to do.

 Note that lisp code converted from Mocklisp code will not necessarily
 run as fast as code specifically written for GNU Emacs, nor will it use
 the many features of GNU Emacs which are not present in Gosling's emacs.
 (In particular, the byte-compiler (m-x byte-compile-file) knows little
 about compilation of code directly converted from mocklisp.)
 It is envisaged that old mocklisp code will be incrementally converted
 to GNU lisp code, with M-x convert-mocklisp-buffer being the first
 step in this process.

* Control-x n (narrow-to-region) is now by default a disabled command.

 This means that, if you issue this command, it will ask whether
 you really mean it.  You have the opportunity to enable the
 command permanently at that time, so you will not be asked again.
 This will place the form "(put 'narrow-to-region 'disabled nil)" in your
 .emacs file.

* Tags now prompts for the tag table file name to use.

 All the tags commands ask for the tag table file name
 if you have not yet specified one.

 Also, the command M-x visit-tag-table can now be used to
 specify the tag table file name initially, or to switch
 to a new tag table.

* If truncate-partial-width-windows is non-nil (as it intially is),
 all windows less than the full screen width (that is,
 made by side-by-side splitting) truncate lines rather than continuing
 them.

* Emacs now checks for Lisp stack overflow to avoid fatal errors.
 The depth in eval, apply and funcall may not exceed max-lisp-eval-depth.
 The depth in variable bindings and unwind-protects may not exceed
 max-specpdl-size.  If either limit is exceeded, an error occurs.
 You can set the limits to larger values if you wish, but if you make them
 too large, you are vulnerable to a fatal error if you invoke
 Lisp code that does infinite recursion.

* New hooks  find-file-hook  and  write-file-hook.
 Both of these variables if non-nil should be functions of no arguments.
 At the time they are called (current-buffer) will be the buffer being
 read or written respectively.

 find-file-hook  is called whenever a file is read into its own buffer,
 such as by calling  find-file,  revert-buffer, etc.  It is not called by
 functions such as  insert-file  which do not read the file into a buffer of
 its own.
 find-file-hook  is called after the file has been read in and its
 local variables (if any) have been processed.

 write-file-hook  is called just before writing out a file from a buffer.

* The initial value of shell-prompt-pattern is now  "^[^#$%>]*[#$%>] *"

* If the .emacs file sets inhibit-startup-message to non-nil,
 the messages normally printed by Emacs at startup time
 are inhibited.

* Facility for run-time conditionalization on the basis of emacs features.

 The new variable  features  is a list of symbols which represent "features"
 of the executing emacs, for use in run-time conditionalization.

 The function  featurep  of one argument may be used to test for the
 presence of a feature. It is just the same as
 (not (null (memq FEATURE features))) where FEATURE is its argument.
 For example, (if (featurep 'magic-window-hack)
                  (transmogrify-window 'vertical)
                (split-window-vertically))

 The function  provide  of one argument "announces" that FEATURE is present.
 It is much the same as (if (not (featurep FEATURE))
                            (setq features (cons FEATURE features)))

 The function  require  with arguments FEATURE and FILE-NAME loads FILE-NAME
 (which should contain the form (provide FEATURE)) unless FEATURE is present.
 It is much the same as (if (not (featurep FEATURE))
                            (progn (load FILE-NAME)
                                   (if (not featurep FEATURE) (error ...))))
 FILE-NAME is optional and defaults to FEATURE.

* New function load-average.

 This returns a list of three integers, which are
 the current 1 minute, 5 minute and 15 minute load averages,
 each multiplied by a hundred (since normally they are floating
 point numbers).

* Per-terminal libraries loaded automatically.

 Emacs when starting up on terminal type T automatically loads
 a library named term-T.  T is the value of the TERM environment variable.
 Thus, on terminal type vt100, Emacs would do (load "term-vt100" t t).
 Such libraries are good places to set the character translation table.

 It is a bad idea to redefine lots of commands in a per-terminal library,
 since this affects all users.  Instead, define a command to do the
 redefinitions and let the user's init file, which is loaded later,
 call that command or not, as the user prefers.

* Programmer's note: detecting killed buffers.

 Buffers are eliminated by explicitly killing them, using
 the function kill-buffer.  This does not eliminate or affect
 the pointers to the buffer which may exist in list structure.
 If you have a pointer to a buffer and wish to tell whether
 the buffer has been killed, use the function buffer-name.
 It returns nil on a killed buffer, and a string on a live buffer.

* New ways to access the last command input character.

 The function last-key-struck, which used to return the last
 input character that was read by command input, is eliminated.
 Instead, you can find this information as the value of the
 variable last-command-char.  (This variable used to be called
 last-key).

 Another new variable, last-input-char, holds the last character
 read from the command input stream regardless of what it was
 read for.  last-input-char and last-command-char are different
 only inside a command that has called read-char to read input.

* The new switch -kill causes Emacs to exit after processing the
 preceding command line arguments.  Thus,
    emacs -l lib data -e do-it -kill
 means to load lib, find file data, call do-it on no arguments,
 and then exit.

* The config.h file has been modularized.

 Options that depend on the machine you are running on are defined
 in a file whose name starts with "m-", such as m-vax.h.
 Options that depend on the operating system software version you are
 running on are defined in a file whose name starts with "s-",
 such as s-bsd4.2.h.

 config.h includes one m- file and one s- file.  It also defines a
 few other options whose values do not follow from the machine type
 and system type being used.  Installers normally will have to
 select the correct m- and s- files but will never have to change their
 contents.

* Termcap AL and DL strings are understood.

 If the termcap entry defines AL and DL strings, for insertion
 and deletion of multiple lines in one blow, Emacs now uses them.
 This matters most on certain bit map display terminals for which
 scrolling is comparatively slow.

* Bias against scrolling screen far on fast terminals.

 Emacs now prefers to redraw a few lines rather than
 shift them a long distance on the screen, when the terminal is fast.

* New major mode, mim-mode.

 This major mode is for editing MDL code.  Perhaps a MDL
 user can explain why it is not called mdl-mode.
 You must load the library mim-mode explicitly to use this.

* GNU documentation formatter `texinfo'.

 The `texinfo' library defines a format for documentation
 files which can be passed through Tex to make a printed manual
 or passed through texinfo to make an Info file.  Texinfo is
 documented fully by its own Info file; compare this file
 with its source, texinfo.texinfo, for additional guidance.

 All documentation files for GNU utilities should be written
 in texinfo input format.

 Tex processing of texinfo files requires the Botex macro package.
 This is not ready for distribution yet, but will appear at
 a later time.

* New function read-from-string (emacs 15.29)

 read-from-string takes three arguments: a string to read from,
 and optionally start and end indices which delimit a substring
 from which to read.  (They default to 0 and the length of the string,
 respectively.)

 This function returns a cons cell whose car is the object produced
 by reading from the string and whose cdr is a number giving the
 index in the string of the first character not read. That index may
 be passed as the second argument to a later call to  read-from-string
 to read the next form represented by the string.

 In addition, the function  read  now accepts a string as its argument.
 In this case, it calls  read-from-string  on the whole string, and
 returns the car of the result. (ie the actual object read.)
\f
Changes in Emacs 14

* Completion now prints various messages such as [Sole Completion]
 or [Next Character Not Unique] to describe the results obtained.
 These messages appear after the text in the minibuffer, and remain
 on the screen until a few seconds go by or you type a key.

* The buffer-read-only flag is implemented.
 Setting or binding this per-buffer variable to a non-nil value
 makes illegal any operation which would modify the textual content of
 the buffer.  (Such operations signal a  buffer-read-only  error)
 The read-only state of a buffer may be altered using toggle-read-only
 (C-x C-q)
 The buffers used by Rmail, Dired, Rnews, and Info are now read-only
 by default to prevent accidental damage to the information in those
 buffers.

* Functions car-safe and cdr-safe.
 These functions are like car and cdr when the argument is a cons.
 Given an argument not a cons, car-safe always returns nil, with
 no error; the same for cdr-safe.

* The new function user-real-login-name returns the name corresponding
 to the real uid of the Emacs process.  This is usually the same
 as what user-login-name returns; however, when Emacs is invoked
 from su, user-real-login-name returns "root" but user-login-name
 returns the name of the user who invoked su.
\f
Changes in Emacs 13

* There is a new version numbering scheme.

 What used to be the first version number, which was 1,
 has been discarded since it does not seem that I need three
 levels of version number.

 However, a new third version number has been added to represent
 changes by user sites.  This number will always be zero in
 Emacs when I distribute it; it will be incremented each time
 Emacs is built at another site.

* There is now a reader syntax for Meta characters:
 \M-CHAR means CHAR or'ed with the Meta bit.  For example:

    ?\M-x   is   (+ ?x 128)
    ?\M-\n  is   (+ ?\n 128)
    ?\M-\^f is   (+ ?\^f 128)

 This syntax can be used in strings too.  Note, however, that
 Meta characters are not meaningful in key sequences being passed
 to define-key or lookup-key; you must use ESC characters (\e)
 in them instead.

 ?\C- can be used likewise for control characters.  (13.9)

* Installation change
 The string "../lisp" now adds to the front of the load-path
 used for searching for Lisp files during Emacs initialization.
 It used to replace the path specified in paths.h entirely.
 Now the directory ../lisp is searched first and the directoris
 specified in paths.h are searched afterward.
\f
Changes in Emacs 1.12

* There is a new installation procedure.
 See the file INSTALL that comes in the top level
 directory in the tar file or tape.

* The Meta key is now supported on terminals that have it.
 This is a shift key which causes the high bit to be turned on
 in all input characters typed while it is held down.

 read-char now returns a value in the range 128-255 if
 a Meta character is typed.  When interpreted as command
 input, a Meta character is equivalent to a two character
 sequence, the meta prefix character followed by the un-metized
 character (Meta-G unmetized is G).

 The meta prefix character
 is specified by the value of the variable meta-prefix-char.
 If this character (normally Escape) has been redefined locally
 with a non-prefix definition (such as happens in completing
 minibuffers) then the local redefinition is suppressed when
 the character is not the last one in a key sequence.
 So the local redefinition is effective if you type the character
 explicitly, but not effective if the character comes from
 the use of the Meta key.

* `-' is no longer a completion command in the minibuffer.
 It is an ordinary self-inserting character.

* The list load-path of directories load to search for Lisp files
 is now controlled by the EMACSLOADPATH environment variable
[[ Note this was originally EMACS-LOAD-PATH and has been changed
 again; sh does not deal properly with hyphens in env variable names]]
 rather than the EPATH environment variable.  This is to avoid
 conflicts with other Emacses.

 While Emacs is being built initially, the load-path
 is now just ("../lisp"), ignoring paths.h.  It does not
 ignore EMACSLOADPATH, however; you should avoid having
 this variable set while building Emacs.

* You can now specify a translation table for keyboard
 input characters, as a way of exchanging or substituting
 keys on the keyboard.

 If the value of keyboard-translate-table is a string,
 every character received from the keyboard is used as an
 index in that string, and the character at that index in
 the string is used as input instead of what was actually
 typed.  If the actual input character is >= the length of
 the string, it is used unchanged.

 One way this feature can be used is to fix bad keyboard
 designes.  For example, on some terminals, Delete is 
 Shift-Underscore.  Since Delete is a more useful character
 than Underscore, it is an improvement to make the unshifted
 character Delete and the shifted one Underscore.  This can
 be done with

  ;; First make a translate table that does the identity translation.
  (setq keyboard-translate-table (make-string 128 0))
  (let ((i 0))
    (while (< i 128)
      (aset keyboard-translate-table i i)
      (setq i (1+ i))))

  ;; Now alter translations of some characters.
  (aset keyboard-translate-table ?\_ ?\^?)
  (aset keyboard-translate-table ?\^? ?\_)

 If your terminal has a Meta key and can therefore send
 codes up to 255, Meta characters are translated through
 elements 128 through 255 of the translate table, and therefore
 are translated independently of the corresponding non-Meta
 characters.  You must therefore establish translations
 independently for the Meta characters if you want them too:

  ;; First make a translate table that does the identity translation.
  (setq keyboard-translate-table (make-string 256 0))
  (let ((i 0))
    (while (< i 256)
      (aset keyboard-translate-table i i)
      (setq i (1+ i))))

  ;; Now alter translations of some characters.
  (aset keyboard-translate-table ?\_ ?\^?)
  (aset keyboard-translate-table ?\^? ?\_)

  ;; Now alter translations of some Meta characters.
  (aset keyboard-translate-table (+ 128 ?\_) (+ 128 ?\^?))
  (aset keyboard-translate-table (+ 128 ?\^?) (+ 128 ?\_))

* (process-kill-without-query PROCESS)

This marks the process so that, when you kill Emacs,
you will not on its account be queried about active subprocesses.
\f
Changes in Emacs 1.11

* The commands C-c and C-z have been interchanged,
 for greater compatibility with normal Unix usage.
 C-z now runs suspend-emacs and C-c runs exit-recursive-edit.

* The value returned by file-name-directory now ends
 with a slash.  (file-name-directory "foo/bar") => "foo/".
 This avoids confusing results when dealing with files
 in the root directory.

 The value of the per-buffer variable default-directory
 is also supposed to have a final slash now.

* There are now variables to control the switches passed to
 `ls' by the C-x C-d command (list-directory).
 list-directory-brief-switches is a string, initially "-CF",
 used for brief listings, and list-directory-verbose-switches
 is a string, initially "-l", used for verbose ones.

* For Ann Arbor Ambassador terminals, the termcap "ti" string
 is now used to initialize the screen geometry on entry to Emacs,
 and the "te" string is used to set it back on exit.
 If the termcap entry does not define the "ti" or "te" string,
 Emacs does what it used to do.
\f
Changes in Emacs 1.10

* GNU Emacs has been made almost 1/3 smaller.
 It now dumps out as only 530kbytes on Vax 4.2bsd.

* The term "checkpoint" has been replaced by "auto save"
 throughout the function names, variable names and documentation
 of GNU Emacs.

* The function load now tries appending ".elc" and ".el"
 to the specified filename BEFORE it tries the filename
 without change.

* rmail now makes the mode line display the total number
 of messages and the current message number.
 The "f" command now means forward a message to another user.
 The command to search through all messages for a string is now "F".
 The "u" command now means to move back to the previous
 message and undelete it.  To undelete the selected message, use Meta-u.

* The hyphen character is now equivalent to a Space while
 in completing minibuffers.  Both mean to complete an additional word.

* The Lisp function error now takes args like format
 which are used to construct the error message.

* Redisplay will refuse to start its display at the end of the buffer.
 It will pick a new place to display from, rather than use that.

* The value returned by garbage-collect has been changed.
 Its first element is no longer a number but a cons,
 whose car is the number of cons cells now in use,
 and whose cdr is the number of cons cells that have been
 made but are now free.
 The second element is similar but describes symbols rather than cons cells.
 The third element is similar but describes markers.

* The variable buffer-name has been eliminated.
 The function buffer-name still exists.  This is to prevent
 user programs from changing buffer names without going
 through the rename-buffer function.
\f
Changes in Emacs 1.9

* When a fill prefix is in effect, paragraphs are started
 or separated by lines that do not start with the fill prefix.
 Also, a line which consists of the fill prefix followed by
 white space separates paragraphs.

* C-x C-v runs the new function find-alternate-file.
 It finds the specified file, switches to that buffer,
 and kills the previous current buffer.  (It requires
 confirmation if that buffer had changes.)  This is
 most useful after you find the wrong file due to a typo.

* Exiting the minibuffer moves the cursor to column 0,
 to show you that it has really been exited.

* Meta-g (fill-region) now fills each paragraph in the
 region individually.  To fill the region as if it were
 a single paragraph (for when the paragraph-delimiting mechanism
 does the wrong thing), use fill-region-as-paragraph.

* Tab in text mode now runs the function tab-to-tab-stop.
 A new mode called indented-text-mode is like text-mode
 except that in it Tab runs the function indent-relative,
 which indents the line under the previous line.
 If auto fill is enabled while in indented-text-mode,
 the new lines that it makes are indented.

* Functions kill-rectangle and yank-rectangle.
 kill-rectangle deletes the rectangle specified by dot and mark
 (or by two arguments) and saves it in the variable killed-rectangle.
 yank-rectangle inserts the rectangle in that variable.

 Tab characters in a rectangle being saved are replaced
 by spaces in such a way that their appearance will
 not be changed if the rectangle is later reinserted
 at a different column position.

* `+' in a regular expression now means
 to repeat the previous expression one or more times.
 `?' means to repeat it zero or one time.
 They are in all regards like `*' except for the
 number of repetitions they match.

 \< in a regular expression now matches the null string
 when it is at the beginning of a word; \> matches
 the null string at the end of a word.

* C-x p narrows the buffer so that only the current page
 is visible.

* C-x ) with argument repeats the kbd macro just
 defined that many times, counting the definition
 as one repetition.

* C-x ( with argument begins defining a kbd macro
 starting with the last one defined.  It executes that
 previous kbd macro initially, just as if you began
 by typing it over again.

* C-x q command queries the user during kbd macro execution.
 With prefix argument, enters recursive edit,
  reading keyboard commands even within a kbd macro.
  You can give different commands each time the macro executes.
 Without prefix argument, reads a character.  Your options are:
  Space -- execute the rest of the macro.
  Delete -- skip the rest of the macro; start next repetition.
  C-d -- skip rest of the macro and don't repeat it any more.
  C-r -- enter a recursive edit, then on exit ask again for a character
  C-l -- redisplay screen and ask again."

* write-kbd-macro and append-kbd-macro are used to save
 a kbd macro definition in a file (as Lisp code to
 redefine the macro when the file is loaded).
 These commands differ in that write-kbd-macro
 discards the previous contents of the file.
 If given a prefix argument, both commands
 record the keys which invoke the macro as well as the
 macro's definition.

* The variable global-minor-modes is used to display
 strings in the mode line of all buffers.  It should be
 a list of elements thaht are conses whose cdrs are strings
 to be displayed.  This complements the variable
 minor-modes, which has the same effect but has a separate
 value in each buffer.

* C-x = describes horizontal scrolling in effect, if any.

* Return now auto-fills the line it is ending, in auto fill mode.
 Space with zero as argument auto-fills the line before it
 just like Space without an argument.
\f
Changes in Emacs 1.8

This release mostly fixes bugs.  There are a few new features:

* apropos now sorts the symbols before displaying them.
 Also, it returns a list of the symbols found.

 apropos now accepts a second arg PRED which should be a function
 of one argument; if PRED is non-nil, each symbol is tested
 with PRED and only symbols for which PRED returns non-nil
 appear in the output or the returned list.

 If the third argument to apropos is non-nil, apropos does not
 display anything; it merely returns the list of symbols found.

 C-h a now runs the new function command-apropos rather than
 apropos, and shows only symbols with definitions as commands.

* M-x shell sends the command 
    if (-f ~/.emacs_NAME)source ~/.emacs_NAME
 invisibly to the shell when it starts.  Here NAME
 is replaced by the name of shell used,
 as it came from your ESHELL or SHELL environment variable
 but with directory name, if any, removed.

* M-, now runs the command tags-loop-continue, which is used
 to resume a terminated tags-search or tags-query-replace.
\f
Changes in Emacs 1.7

It's Beat CCA Week.

* The initial buffer is now called "*scratch*" instead of "scratch",
 so that all buffer names used automatically by Emacs now have *'s.

* Undo information is now stored separately for each buffer.
 The Undo command (C-x u) always applies to the current
 buffer only.

 C-_ is now a synonym for C-x u.

 (buffer-flush-undo BUFFER) causes undo information not to
 be kept for BUFFER, and frees the space that would have
 been used to hold it.  In any case, no undo information is
 kept for buffers whose names start with spaces.  (These
 buffers also do not appear in the C-x C-b display.)

* Rectangle operations are now implemented.
 C-x r stores the rectangle described by dot and mark
 into a register; it reads the register name from the keyboard.
 C-x 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.

* Side-by-side windows are allowed.  Use C-x 5 to split the
 current window into two windows side by side.
 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.

 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.

* Horizontal scrolling of the lines in a window is now 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.

* 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'.

* C-t at the end of a line now exchanges the two preceding characters.

 All the transpose commands now interpret zero as an argument
 to mean to transpose the textual unit after or around dot
 with the one after or around the mark.

* 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.

* The mode line will now say "Def" after the major mode
 while a keyboard macro is being defined.

* The variable fill-prefix is now used by Meta-q.
 Meta-q removes the fill prefix from lines that start with it
 before filling, and inserts the fill prefix on each line
 after filling.

 The command C-x . sets the fill prefix equal to the text
 on the current line before dot.

* The new command Meta-j (indent-new-comment-line),
 is like Linefeed (indent-new-line) except when dot is inside a comment;
 in that case, Meta-j inserts a comment starter on the new line,
 indented under the comment starter above.  It also inserts
 a comment terminator at the end of the line above,
 if the language being edited calls for one.

* Rmail should work correctly now, and has some C-h m documentation.
\f
Changes in Emacs 1.6

* save-buffers-kill-emacs is now on C-x C-c
 while C-x C-z does suspend-emacs.  This is to make
 C-x C-c like the normal Unix meaning of C-c
 and C-x C-z linke the normal Unix meaning of C-z.

* M-ESC (eval-expression) is now a disabled command by default.
 This prevents users who type ESC ESC accidentally from
 getting confusing results.  Put
    (put 'eval-expression 'disabled nil)
 in your ~/.emacs file to enable the command.

* Self-inserting text is grouped into bunches for undoing.
 Each C-x u command undoes up to 20 consecutive self-inserting
 characters.

* Help f now uses as a default the function being called
 in the innermost Lisp expression that dot is in.
 This makes it more convenient to use while writing
 Lisp code to run in Emacs.
 (If the text around dot does not appear to be a call
 to a Lisp function, there is no default.)

 Likewise, Help v uses the symbol around or before dot
 as a default, if that is a variable name.

* Commands that read filenames now insert the default
 directory in the minibuffer, to become part of your input.
 This allows you to see what the default is.
 You may type a filename which goes at the end of the
 default directory, or you may edit the default directory
 as you like to create the input you want to give.
 You may also type an absolute pathname (starting with /)
 or refer to a home directory (input starting with ~)
 after the default; the presence of // or /~ causes
 everything up through the slash that precedes your
 type-in to be ignored.

 Returning the default directory without change,
 including the terminating slash, requests the use
 of the default file name (usually the visited file's name).

 Set the variable insert-default-directory to nil
 to turn off this feature.

* M-x shell now uses the environment variable ESHELL,
 if it exists, as the file name of the shell to run.
 If there is no ESHELL variable, the SHELL variable is used.
 This is because some shells do not work properly as inferiors
 of Emacs (or anything like Emacs).

* A new variable minor-modes now exists, with a separate value
 in each buffer.  Its value should be an alist of elements
 (MODE-FUNCTION-SYMBOL . PRETTY-NAME-STRING), one for each
 minor mode that is turned on in the buffer.  The pretty
 name strings are displayed in the mode line after the name of the
 major mode (with spaces between them).  The mode function
 symbols should be symbols whose function definitions will
 turn on the minor mode if given 1 as an argument; they are present
 so that Help m can find their documentation strings.

* The format of tag table files has been changed.
 The new format enables Emacs to find tags much faster.

 A new program, etags, exists to make the kind of
 tag table that Emacs wants.  etags is invoked just
 like ctags; in fact, if you give it any switches,
 it does exactly what ctags would do.  Give it the
 empty switch ("-") to make it act like ctags with no switches.

 etags names the tag table file "TAGS" rather than "tags",
 so that these tag tables and the standard Unix ones
 can coexist.

 The tags library can no longer use standard ctags-style
 tag tables files.

* The file of Lisp code Emacs reads on startup is now
 called ~/.emacs rather than ~/.emacs_pro.

* copy-file now gives the copied file the same mode bits
 as the original file.

* Output from a process inserted into the process's buffer
 no longer sets the buffer's mark.  Instead it sets a
 marker associated with the process to point to the end
 of the inserted text.  You can access this marker with
    (process-mark PROCESS)
 and then either examine its position with marker-position
 or set its position with set-marker.

* completing-read takes a new optional fifth argument which,
 if non-nil, should be a string of text to insert into
 the minibuffer before reading user commands.

* The Lisp function elt now exists:
 (elt ARRAY N) is like (aref ARRAY N),
 (elt LIST N) is like (nth N LIST).

* rplaca is now a synonym for setcar, and rplacd for setcdr.
 eql is now a synonym for eq; it turns out that the Common Lisp
 distinction between eq and eql is insignificant in Emacs.
 numberp is a new synonym for integerp.

* auto-save has been renamed to auto-save-mode.

* Auto save file names for buffers are now created by the
 function make-auto-save-file-name.  This is so you can
 redefine that function to change the way auto save file names
 are chosen.

* expand-file-name no longer discards a final slash.
    (expand-file-name "foo" "/lose") => "/lose/foo"
    (expand-file-name "foo/" "/lose") => "/lose/foo/"

 Also, expand-file-name no longer substitutes $ constructs.
 A new function substitute-in-file-name does this.  Reading
 a file name with read-file-name or the `f' or`F' option
 of interactive calling uses substitute-in-file-name
 on the file name that was read and returns the result.

 All I/O primitives including insert-file-contents and
 delete-file call expand-file-name on the file name supplied.
 This change makes them considerably faster in the usual case.

* Interactive calling spec strings allow the new code letter 'D'
 which means to read a directory name.  It is like 'f' except
 that the default if the user makes no change in the minibuffer
 is to return the current default directory rather than the
 current visited file name.
\f
Changes in Emacs 1.5

* suspend-emacs now accepts an optional argument
 which is a string to be stuffed as terminal input
 to be read by Emacs's superior shell after Emacs exits.

 A library called ledit exists which uses this feature
 to transmit text to a Lisp job running as a sibling of
 Emacs.

* If find-file is given the name of a directory,
 it automatically invokes dired on that directory
 rather than reading in the binary data that make up
 the actual contents of the directory according to Unix.

* Saving an Emacs buffer now preserves the file modes
 of any previously existing file with the same name.
 This works using new Lisp functions file-modes and
 set-file-modes, which can be used to read or set the mode
 bits of any file.

* The Lisp function  cond  now exists, with its traditional meaning.

* defvar and defconst now permit the documentation string
 to be omitted.  defvar also permits the initial value
 to be omitted; then it acts only as a comment.
\f
Changes in Emacs 1.4

* Auto-filling now normally indents the new line it creates
 by calling indent-according-to-mode.  This function, meanwhile,
 has in Fundamental and Text modes the effect of making the line
 have an indentation of the value of left-margin, a per-buffer variable.

 Tab no longer precisely does indent-according-to-mode;
 it does that in all modes that supply their own indentation routine,
 but in Fundamental, Text and allied modes it inserts a tab character.

* The command M-x grep now invokes grep (on arguments
 supplied by the user) and reads the output from grep
 asynchronously into a buffer.  The command C-x ` can
 be used to move to the lines that grep has found.
 This is an adaptation of the mechanism used for
 running compilations and finding the loci of error messages.

 You can now use C-x ` even while grep or compilation
 is proceeding; as more matches or error messages arrive,
 C-x ` will parse them and be able to find them.

* M-x mail now provides a command to send the message
 and "exit"--that is, return to the previously selected
 buffer.  It is C-z C-z.

* Tab in C mode now tries harder to adapt to all indentation styles.
 If the line being indented is a statement that is not the first
 one in the containing compound-statement, it is aligned under
 the beginning of the first statement.

* The functions screen-width and screen-height return the
 total width and height of the screen as it is now being used.
 set-screen-width and set-screen-height tell Emacs how big
 to assume the screen is; they each take one argument,
 an integer.

* The Lisp function 'function' now exists.  function is the
 same as quote, except that it serves as a signal to the
 Lisp compiler that the argument should be compiled as
 a function.  Example:
   (mapcar (function (lambda (x) (+ x 5))) list)

* The function set-key has been renamed to global-set-key.
 undefine-key and local-undefine-key has been renamed to
 global-unset-key and local-unset-key.

* Emacs now collects input from asynchronous subprocesses
 while waiting in the functions sleep-for and sit-for.

* Shell mode's Newline command attempts to distinguish subshell
 prompts from user input when issued in the middle of the buffer.
 It no longer reexecutes from dot to the end of the line;
 it reeexecutes the entire line minus any prompt.
 The prompt is recognized by searching for the value of
 shell-prompt-pattern, starting from the beginning of the line.
 Anything thus skipped is not reexecuted.
\f
Changes in Emacs 1.3

* An undo facility exists now.  Type C-x u to undo a batch of
 changes (usually one command's changes, but some commands
 such as query-replace divide their changes into multiple
 batches.  You can repeat C-x u to undo further.  As long
 as no commands other than C-x u intervene, each one undoes
 another batch.  A numeric argument to C-x u acts as a repeat
 count.

 If you keep on undoing, eventually you may be told that
 you have used up all the recorded undo information.
 Some actions, such as reading in files, discard all
 undo information.

 The undo information is not currently stored separately
 for each buffer, so it is mainly good if you do something
 totally spastic.  [This has since been fixed.]

* A learn-by-doing tutorial introduction to Emacs now exists.
 Type C-h t to enter it.

* An Info documentation browser exists.  Do M-x info to enter it.
 It contains a tutorial introduction so that no more documentation
 is needed here.  As of now, the only documentation in it
 is that of Info itself.

* Help k and Help c are now different.  Help c prints just the
 name of the function which the specified key invokes.  Help k
 prints the documentation of the function as well.

* A document of the differences between GNU Emacs and Twenex Emacs
 now exists.  It is called DIFF, in the same directory as this file.

* C mode can now indent comments better, including multi-line ones.
 Meta-Control-q now reindents comment lines within the expression
 being aligned.

* Insertion of a close-parenthesis now shows the matching open-parenthesis
 even if it is off screen, by printing the text following it on its line
 in the minibuffer.

* A file can now contain a list of local variable values
 to be in effect when the file is edited.  See the file DIFF
 in the same directory as this file for full details.

* A function nth is defined.  It means the same thing as in Common Lisp.

* The function install-command has been renamed to set-key.
 It now takes the key sequence as the first argument
 and the definition for it as the second argument.
 Likewise, local-install-command has been renamed to local-set-key.
\f
Changes in Emacs 1.2

* A Lisp single-stepping and debugging facility exists.
 To cause the debugger to be entered when an error
 occurs, set the variable debug-on-error non-nil.

 To cause the debugger to be entered whenever function foo
 is called, do (debug-on-entry 'foo).  To cancel this,
 do (cancel-debug-on-entry 'foo).  debug-on-entry does
 not work for primitives (written in C), only functions
 written in Lisp.  Most standard Emacs commands are in Lisp.

 When the debugger is entered, the selected window shows
 a buffer called " *Backtrace" which displays a series
 of stack frames, most recently entered first.  For each
 frame, the function name called is shown, usually followed
 by the argument values unless arguments are still being
 calculated.  At the beginning of the buffer is a description
 of why the debugger was entered: function entry, function exit,
 error, or simply that the user called the function `debug'.

 To exit the debugger and return to top level, type `q'.

 In the debugger, you can evaluate Lisp expressions by 
 typing `e'.  This is equivalent to `M-ESC'.

 When the debugger is entered due to an error, that is
 all you can do.  When it is entered due to function entry
 (such as, requested by debug-on-entry), you have two
 options:
  Continue execution and reenter debugger after the
    completion of the function being entered.  Type `c'.
  Continue execution but enter the debugger before
    the next subexpression.  Type `d'.

 You will see that some stack frames are marked with *.
 This means the debugger will be entered when those
 frames exit.  You will see the value being returned
 in the first line of the backtrace buffer.  Your options:
  Continue execution, and return that value.  Type `c'.
  Continue execution, and return a specified value.  Type `r'.

 You can mark a frame to enter the debugger on exit
 with the `b' command, or clear such a mark with `u'.

* Lisp macros now exist.
 For example, you can write
    (defmacro cadr (arg) (list 'car (list 'cdr arg)))
 and then the expression
    (cadr foo)
 will expand into
    (car (cdr foo))
\f
Changes in Emacs 1.1

* The initial buffer is now called "scratch" and is in a
 new major mode, Lisp Interaction mode.  This mode is
 intended for typing Lisp expressions, evaluating them,
 and having the values printed into the buffer.

  Type Linefeed after a Lisp expression, to evaluate the
 expression and have its value printed into the buffer,
 advancing dot.

 The other commands of Lisp mode are available.

* The C-x C-e command for evaluating the Lisp expression
 before dot has been changed to print the value in the
 minibuffer line rather than insert it in the buffer.
 A numeric argument causes the printed value to appear
 in the buffer instead.

* In Lisp mode, the command M-C-x evaluates the defun
 containing or following dot.  The value is printed in
 the minibuffer.

* The value of a Lisp expression evaluated using M-ESC
 is now printed in the minibuffer.

* M-q now runs fill-paragraph, independent of major mode.

* C-h m now prints documentation on the current buffer's
 major mode.  What it prints is the documentation of the
 major mode name as a function.  All major modes have been
 equipped with documentation that describes all commands
 peculiar to the major mode, for this purpose.

* You can display a Unix manual entry with
 the M-x manual-entry command.

* You can run a shell, displaying its output in a buffer,
 with the M-x shell command.  The Return key sends input
 to the subshell.  Output is printed inserted automatically
 in the buffer.  Commands C-c, C-d, C-u, C-w and C-z are redefined
 for controlling the subshell and its subjobs.
 "cd", "pushd" and "popd" commands are recognized as you
 enter them, so that the default directory of the Emacs buffer
 always remains the same as that of the subshell.

* C-x $ (that's a real dollar sign) controls line-hiding based
 on indentation.  With a numeric arg N > 0, it causes all lines
 indented by N or more columns to become invisible.
 They are, effectively, tacked onto the preceding line, where
 they are represented by " ..." on the screen.
 (The end of the preceding visible line corresponds to a
 screen cursor position before the "...".  Anywhere in the
 invisible lines that follow appears on the screen as a cursor
 position after the "...".)
 Currently, all editing commands treat invisible lines just
 like visible ones, except for C-n and C-p, which have special
 code to count visible lines only.
 C-x $ with no argument turns off this mode, which in any case
 is remembered separately for each buffer.

* Outline mode is another form of selective display.
 It is a major mode invoked with M-x outline-mode.
 It is intended for editing files that are structured as
 outlines, with heading lines (lines that begin with one
 or more asterisks) and text lines (all other lines).
 The number of asterisks in a heading line are its level;
 the subheadings of a heading line are all following heading
 lines at higher levels, until but not including the next 
 heading line at the same or a lower level, regardless
 of intervening text lines.

  In outline mode, you have commands to hide (remove from display)
 or show the text or subheadings under each heading line
 independently.  Hidden text or subheadings are invisibly
 attached to the end of the preceding heading line, so that
 if you kill the hading line and yank it back elsewhere
 all the invisible lines accompany it.

  All editing commands treat hidden outline-mode lines
 as part of the preceding visible line.
 
* C-x C-z runs save-buffers-kill-emacs
 offers to save each file buffer, then exits.

* C-c's function is now called suspend-emacs.

* The command C-x m runs mail, which switches to a buffer *mail*
 and lets you compose a message to send.  C-x 4 m runs mail in
 another window.  Type C-z C-s in the mail buffer to send the
 message according to what you have entered in the buffer.

  You must separate the headers from the message text with
 an empty line.

* You can now dired partial directories (specified with names
 containing *'s, etc, all processed by the shell).  Also, you
 can dired more than one directory; dired names the buffer
 according to the filespec or directory name.  Reinvoking
 dired on a directory already direded just switches back to
 the same directory used last time; do M-x revert if you want
 to read in the current contents of the directory.

  C-x d runs dired, and C-x 4 d runs dired in another window.

  C-x C-d (list-directory) also allows partial directories now.
\f
Lisp programming changes

* t as an output stream now means "print to the minibuffer".
 If there is already text in the minibuffer printed via t
 as an output stream, the new text is appended to the old
 (or is truncated and lost at the margin).  If the minibuffer
 contains text put there for some other reason, it is cleared
 first.

  t is now the top-level value of standard-output.

  t as an input stream now means "read via the minibuffer".
 The minibuffer is used to read a line of input, with editing,
 and this line is then parsed.  Any excess not used by `read'
 is ignored; each `read' from t reads fresh input.
 t is now the top-level value of standard-input.

* A marker may be used as an input stream or an output stream.
 The effect is to grab input from where the marker points,
 advancing it over the characters read, or to insert output
 at the marker and advance it.

* Output from an asynchronous subprocess is now inserted at
 the end of the associated buffer, not at the buffer's dot,
 and the buffer's mark is set to the end of the inserted output
 each time output is inserted.

* (pos-visible-in-window-p POS WINDOW)
 returns t if position POS in WINDOW's buffer is in the range
 that is being displayed in WINDOW; nil if it is scrolled
 vertically out of visibility.

  If display in WINDOW is not currently up to date, this function
 calculates carefully whether POS would appear if display were
 done immediately based on the current (window-start WINDOW).

  POS defaults to (dot), and WINDOW to (selected-window).

* Variable buffer-alist replaced by function (buffer-list).
 The actual alist of buffers used internally by Emacs is now
 no longer accessible, to prevent the user from crashing Emacs
 by modifying it.  The function buffer-list returns a list
 of all existing buffers.  Modifying this list cannot hurt anything
 as a new list is constructed by each call to buffer-list.

* load now takes an optional third argument NOMSG which, if non-nil,
 prevents load from printing a message when it starts and when
 it is done.

* byte-recompile-directory is a new function which finds all
 the .elc files in a directory, and regenerates each one which
 is older than the corresponding .el (Lisp source) file.
\f
----------------------------------------------------------------------
Copyright information:

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