merge trun

42 files changed, 2089 insertions, 1805 deletions

diff --git a/doc/emacs/ChangeLog b/doc/emacs/ChangeLog
index 90beb08233d..ea5621e7ccf 100644
--- a/doc/emacs/ChangeLog
+++ b/doc/emacs/ChangeLog
@@ -1,3 +1,53 @@
+2012-10-29  Chong Yidong  <cyd@gnu.org>
+
+        * dired.texi (Shell Commands in Dired): Document changes to the
+        dired-do-async-shell-command.
+
+2012-10-28  Glenn Morris  <rgm@gnu.org>
+
+        * ack.texi (Acknowledgments): Mention gv.el.
+
+2012-10-27  Bastien Guerry  <bzg@gnu.org>
+
+        * screen.texi (Menu Bar): Fix typo.
+
+2012-10-27  Chong Yidong  <cyd@gnu.org>
+
+        * frames.texi (Mouse Avoidance): Mention new variable
+        mouse-avoidance-banish-position.
+
+        * programs.texi (Which Function): Which Function mode now works in
+        all major modes by default.
+
+        * mule.texi (Recognize Coding): Remove an unreferenced vindex.
+
+        * files.texi (Misc File Ops): Symbolic links on Windows only work
+        on Vista and later.
+
+        * building.texi (Compilation): Document compilation-always-kill.
+
+        * search.texi (Symbol Search): New node.
+
+        * package.texi (Package Menu): Document the "new" status.
+
+        * windows.texi (Window Choice): Don't refer to the obsolete
+        special-display feature.
+
+2012-10-24  Chong Yidong  <cyd@gnu.org>
+
+        * mule.texi (Text Coding): set-buffer-file-coding-system can now
+        be invoked from the mode line.
+
+        * dired.texi (Dired Deletion, Marks vs Flags): Document Emacs 24.3
+        changes to the mark and unmark commands.
+        (Comparison in Dired): Document chages to dired-diff.  Remove M-=,
+        which is no longer bound to dired-backup-diff.
+
+2012-10-23  Bastien Guerry  <bzg@gnu.org>
+
+        * text.texi (Org Authoring): Use a comma after @ref to avoid the
+        insertion of a period in the Info output.
+
 2012-10-23  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * custom.texi (Hooks): Clarify that -hooks is deprecated.
diff --git a/doc/emacs/ack.texi b/doc/emacs/ack.texi
index 8d1e4221a6c..79710f4992b 100644
--- a/doc/emacs/ack.texi
+++ b/doc/emacs/ack.texi
@@ -835,8 +835,9 @@ diffs; @file{css-mode.el} for Cascading Style Sheets;
 client for the ``Music Player Daemon''; @file{smie.el}, a generic
 indentation engine; and @file{pcase.el}, implementing ML-style pattern
 matching.  In Emacs 24, he integrated the lexical binding code,
-and cleaned up the CL namespace (making it acceptable to use CL
-functions at runtime).
+cleaned up the CL namespace (making it acceptable to use CL
+functions at runtime), and added generalized variables to core Emacs
+Lisp.
 
 @item
 Morioka Tomohiko wrote several packages for MIME support in Gnus and
diff --git a/doc/emacs/building.texi b/doc/emacs/building.texi
index eaee16ac8d5..3a3630138de 100644
--- a/doc/emacs/building.texi
+++ b/doc/emacs/building.texi
@@ -108,11 +108,14 @@ directory, which is the directory in which the previous compilation
 was started.
 
 @findex kill-compilation
+@vindex compilation-always-kill
   Starting a new compilation also kills any compilation already
 running in @file{*compilation*}, as the buffer can only handle one
 compilation at any time.  However, @kbd{M-x compile} asks for
-confirmation before actually killing a compilation that is running.
-You can also kill the compilation process with @kbd{M-x
+confirmation before actually killing a compilation that is running; to
+always automatically kill the compilation without asking, change the
+variable @code{compilation-always-kill} to @code{t}.  You can also
+kill a compilation process with the command @kbd{M-x
 kill-compilation}.
 
   To run two compilations at once, start the first one, then rename
diff --git a/doc/emacs/dired.texi b/doc/emacs/dired.texi
index 0dcded78364..c08dc02b04b 100644
--- a/doc/emacs/dired.texi
+++ b/doc/emacs/dired.texi
@@ -167,13 +167,14 @@ deletion, then delete the files that were flagged.
 
 @table @kbd
 @item d
-Flag this file for deletion.
+Flag this file for deletion (@code{dired-flag-file-deletion}).
 @item u
-Remove deletion flag on this line.
+Remove the deletion flag (@code{dired-unmark}).
 @item @key{DEL}
-Move point to previous line and remove the deletion flag on that line.
+Move point to previous line and remove the deletion flag on that line
+(@code{dired-unmark-backward}).
 @item x
-Delete the files that are flagged for deletion.
+Delete files flagged for deletion (@code{dired-do-flagged-delete}).
 @end table
 
 @kindex d @r{(Dired)}
@@ -182,8 +183,12 @@ Delete the files that are flagged for deletion.
 the file and typing @kbd{d} (@code{dired-flag-file-deletion}).  The
 deletion flag is visible as a @samp{D} at the beginning of the line.
 This command moves point to the next line, so that repeated @kbd{d}
-commands flag successive files.  A numeric argument serves as a repeat
-count.
+commands flag successive files.  A numeric prefix argument serves as a
+repeat count; a negative count means to flag preceding files.
+
+  If the region is active, the @kbd{d} command flags all files in the
+region for deletion; in this case, the command does not move point,
+and ignores any prefix argument.
 
 @kindex u @r{(Dired deletion)}
 @kindex DEL @r{(Dired)}
@@ -194,14 +199,17 @@ can remove deletion flags using the commands @kbd{u} and @key{DEL}.
 @kbd{u} (@code{dired-unmark}) works just like @kbd{d}, but removes
 flags rather than making flags.  @key{DEL}
 (@code{dired-unmark-backward}) moves upward, removing flags; it is
-like @kbd{u} with argument @minus{}1.
+like @kbd{u} with argument @minus{}1.  A numeric prefix argument to
+either command serves as a repeat count, with a negative count meaning
+to unflag in the opposite direction.  If the region is active, these
+commands instead unflag all files in the region, without moving point.
 
 @kindex x @r{(Dired)}
 @findex dired-do-flagged-delete
-  To delete the flagged files, type @kbd{x}
-(@code{dired-do-flagged-delete}).  This command first displays a list
-of all the file names flagged for deletion, and requests confirmation
-with @kbd{yes}.  If you confirm, Dired deletes the flagged files, then
+  To delete flagged files, type @kbd{x}
+(@code{dired-do-flagged-delete}).  This command displays a list of all
+the file names flagged for deletion, and requests confirmation with
+@kbd{yes}.  If you confirm, Dired deletes the flagged files, then
 deletes their lines from the text of the Dired buffer.  The Dired
 buffer, with somewhat fewer lines, remains selected.
 
@@ -387,10 +395,11 @@ and unflag files.)
 @kindex m @r{(Dired)}
 @kindex * m @r{(Dired)}
 @findex dired-mark
-Mark the current file with @samp{*} (@code{dired-mark}).  With a numeric
-argument @var{n}, mark the next @var{n} files starting with the current
-file.  (If @var{n} is negative, mark the previous @minus{}@var{n}
-files.)
+Mark the current file with @samp{*} (@code{dired-mark}).  If the
+region is active, mark all files in the region instead; otherwise, if
+a numeric argument @var{n} is supplied, mark the next @var{n} files
+instead, starting with the current file (if @var{n} is negative, mark
+the previous @minus{}@var{n} files).
 
 @item * *
 @kindex * * @r{(Dired)}
@@ -426,7 +435,11 @@ and @file{..} (@code{dired-mark-subdir-files}).
 @kindex u @r{(Dired)}
 @kindex * u @r{(Dired)}
 @findex dired-unmark
-Remove any mark on this line (@code{dired-unmark}).
+Remove any mark on this line (@code{dired-unmark}).  If the region is
+active, unmark all files in the region instead; otherwise, if a
+numeric argument @var{n} is supplied, unmark the next @var{n} files
+instead, starting with the current file (if @var{n} is negative,
+unmark the previous @minus{}@var{n} files).
 
 @item @key{DEL}
 @itemx * @key{DEL}
@@ -434,7 +447,11 @@ Remove any mark on this line (@code{dired-unmark}).
 @findex dired-unmark-backward
 @cindex unmarking files (in Dired)
 Move point to previous line and remove any mark on that line
-(@code{dired-unmark-backward}).
+(@code{dired-unmark-backward}).  If the region is active, unmark all
+files in the region instead; otherwise, if a numeric argument @var{n}
+is supplied, unmark the @var{n} preceding files instead, starting with
+the current file (if @var{n} is negative, unmark the next
+@minus{}@var{n} files).
 
 @item * !
 @itemx U
@@ -782,15 +799,20 @@ more matches.  @xref{Tags Search}.
 @kindex ! @r{(Dired)}
 @kindex X @r{(Dired)}
 The Dired command @kbd{!} (@code{dired-do-shell-command}) reads a
-shell command string in the minibuffer and runs that shell command on
+shell command string in the minibuffer, and runs that shell command on
 one or more files.  The files that the shell command operates on are
 determined in the usual way for Dired commands (@pxref{Operating on
 Files}).  The command @kbd{X} is a synonym for @kbd{!}.
 
   The command @kbd{&} (@code{dired-do-async-shell-command}) does the
-same, except that it runs the shell command asynchronously.  You can
+same, except that it runs the shell command asynchronously.  (You can
 also do this with @kbd{!}, by appending a @samp{&} character to the
-end of the shell command.
+end of the shell command.)  When the command operates on more than one
+file, it runs multiple parallel copies of the specified shell command,
+one for each file.  As an exception, if the specified shell command
+ends in @samp{;} or @samp{;&}, the shell command is run in the
+background on each file sequentially; Emacs waits for each invoked
+shell command to terminate before running the next one.
 
   For both @kbd{!} and @kbd{&}, the working directory for the shell
 command is the top-level directory of the Dired buffer.
@@ -936,32 +958,19 @@ default.
 @cindex file comparison (in Dired)
 @cindex compare files (in Dired)
 
-  Here are two Dired commands that compare specified files using
-@code{diff}.  They show the output in a buffer using Diff mode
-(@pxref{Comparing Files}).
-
-@table @kbd
-@item =
 @findex dired-diff
 @kindex = @r{(Dired)}
-Compare the current file (the file at point) with another file (the
-file at the mark) using the @code{diff} program (@code{dired-diff}).
-The file at the mark is the first argument of @code{diff}, and the
-file at point is the second argument.  This refers to the ordinary
-Emacs mark, not Dired marks; use @kbd{C-@key{SPC}}
-(@code{set-mark-command}) to set the mark at the first file's line
-(@pxref{Setting Mark}).
-
-@findex dired-backup-diff
-@kindex M-= @r{(Dired)}
-@item M-=
-Compare the current file with its latest backup file
-(@code{dired-backup-diff}).  If the current file is itself a backup,
-compare it with the file it is a backup of; this way, you can compare
-a file with any one of its backups.
-
-The backup file is the first file given to @code{diff}.
-@end table
+  The @kbd{=} (@code{dired-diff}) command compares the current file
+(the file at point) with another file (read using the minibuffer)
+using the @command{diff} program.  The file specified with the
+minibuffer is the first argument of @command{diff}, and file at point
+is the second argument.  The output of the @command{diff} program is
+shown in a buffer using Diff mode (@pxref{Comparing Files}).
+
+  If the region is active, the default for the file read using the
+minibuffer is the file at the mark (i.e.@: the ordinary Emacs mark,
+not a Dired mark; @pxref{Setting Mark}).  Otherwise, if the file at
+point has a backup file (@pxref{Backup}), that is the default.
 
 @node Subdirectories in Dired
 @section Subdirectories in Dired
diff --git a/doc/emacs/emacs.texi b/doc/emacs/emacs.texi
index a2eaaf673e5..e7e0feb9e88 100644
--- a/doc/emacs/emacs.texi
+++ b/doc/emacs/emacs.texi
@@ -373,6 +373,7 @@ Searching and Replacement
 * Incremental Search::     Search happens as you type the string.
 * Nonincremental Search::  Specify entire string and then search.
 * Word Search::            Search for sequence of words.
+* Symbol Search::          Search for a source code symbol.
 * Regexp Search::          Search for match for a regexp.
 * Regexps::                Syntax of regular expressions.
 * Regexp Backslash::       Regular expression constructs starting with `\'.
diff --git a/doc/emacs/files.texi b/doc/emacs/files.texi
index e12bb385653..36cd3658e2d 100644
--- a/doc/emacs/files.texi
+++ b/doc/emacs/files.texi
@@ -1564,9 +1564,8 @@ open file @var{linkname} will refer to whatever file is named
 @var{target} at the time the opening is done, or will get an error if
 the name @var{target} is nonexistent at that time.  This command does
 not expand the argument @var{target}, so that it allows you to specify
-a relative name as the target of the link.  Not all systems support
-symbolic links; on systems that don't support them, this command is
-not defined.
+a relative name as the target of the link.  On MS-Windows, this
+command works only on MS Windows Vista and later.
 
 @kindex C-x i
 @findex insert-file
diff --git a/doc/emacs/frames.texi b/doc/emacs/frames.texi
index e1b849e630e..0ce5c64c0eb 100644
--- a/doc/emacs/frames.texi
+++ b/doc/emacs/frames.texi
@@ -1092,17 +1092,19 @@ to various values to move the mouse in several ways:
 
 @table @code
 @item banish
-Move the mouse to the upper-right corner on any key-press;
+Move the pointer to a corner of the frame on any key-press.  You can
+customize the variable @code{mouse-avoidance-banish-position} to
+specify where the pointer goes when it is banished.
 @item exile
-Move the mouse to the corner only if the cursor gets too close,
-and allow it to return once the cursor is out of the way;
+Banish the pointer only if the cursor gets too close, and allow it to
+return once the cursor is out of the way.
 @item jump
-If the cursor gets too close to the mouse, displace the mouse
-a random distance & direction;
+If the cursor gets too close to the pointer, displace the pointer by a
+random distance and direction.
 @item animate
-As @code{jump}, but shows steps along the way for illusion of motion;
+As @code{jump}, but shows steps along the way for illusion of motion.
 @item cat-and-mouse
-The same as @code{animate};
+The same as @code{animate}.
 @item proteus
 As @code{animate}, but changes the shape of the mouse pointer too.
 @end table
diff --git a/doc/emacs/mule.texi b/doc/emacs/mule.texi
index 1dfae79c788..ff0d43c566a 100644
--- a/doc/emacs/mule.texi
+++ b/doc/emacs/mule.texi
@@ -920,7 +920,6 @@ Unlike the previous two, this variable does not override any
 @samp{-*-coding:-*-} tag.
 
 @c FIXME?  This seems somewhat out of place.  Move to the Rmail section?
-@vindex rmail-decode-mime-charset
 @vindex rmail-file-coding-system
   When you get new mail in Rmail, each message is translated
 automatically from the coding system it is written in, as if it were a
@@ -1040,12 +1039,16 @@ decoding it using coding system @var{right} instead.
 @findex set-buffer-file-coding-system
   The command @kbd{C-x @key{RET} f}
 (@code{set-buffer-file-coding-system}) sets the file coding system for
-the current buffer---in other words, it says which coding system to
-use when saving or reverting the visited file.  You specify which
-coding system using the minibuffer.  If you specify a coding system
-that cannot handle all of the characters in the buffer, Emacs warns
-you about the troublesome characters when you actually save the
-buffer.
+the current buffer (i.e.@: the coding system to use when saving or
+reverting the file).  You specify which coding system using the
+minibuffer.  You can also invoke this command by clicking with
+@kbd{Mouse-3} on the coding system indicator in the mode line
+(@pxref{Mode Line}).
+
+  If you specify a coding system that cannot handle all the characters
+in the buffer, Emacs will warn you about the troublesome characters,
+and ask you to choose another coding system, when you try to save the
+buffer (@pxref{Output Coding}).
 
 @cindex specify end-of-line conversion
   You can also use this command to specify the end-of-line conversion
diff --git a/doc/emacs/package.texi b/doc/emacs/package.texi
index 4435590536f..df87cf9cb23 100644
--- a/doc/emacs/package.texi
+++ b/doc/emacs/package.texi
@@ -62,8 +62,12 @@ The package's status---normally one of @samp{available} (can be
 downloaded from the package archive), @samp{installed}, or
 @samp{built-in} (included in Emacs by default).
 
-In some instances, the status can be @samp{held}, @samp{disabled}, or
-@samp{obsolete}.  @xref{Package Installation}.
+The status can also be @samp{new}.  This is equivalent to
+@samp{available}, except that it means the package became newly
+available on the package archive after your last invocation of
+@kbd{M-x list-packages}.  In other instances, a package may have the
+status @samp{held}, @samp{disabled}, or @samp{obsolete}.
+@xref{Package Installation}.
 
 @item
 A short description of the package.
diff --git a/doc/emacs/programs.texi b/doc/emacs/programs.texi
index e5340655770..b5bb33ad666 100644
--- a/doc/emacs/programs.texi
+++ b/doc/emacs/programs.texi
@@ -326,12 +326,13 @@ as you move around in a buffer.
 @findex which-function-mode
 @vindex which-func-modes
   To either enable or disable Which Function mode, use the command
-@kbd{M-x which-function-mode}.  Although Which Function mode is a
-global minor mode, it takes effect only in certain major modes: those
-listed in the variable @code{which-func-modes}.  If the value of
-@code{which-func-modes} is @code{t} rather than a list of modes, then
-Which Function mode applies to all major modes that know how to
-support it---in other words, all the major modes that support Imenu.
+@kbd{M-x which-function-mode}.  Which Function mode is a global minor
+mode.  By default, it takes effect in all major modes major modes that
+know how to support it (i.e.@: all the major modes that support
+Imenu).  You can restrict it to a specific list of major modes by
+changing the value of the variable @code{which-func-modes} from
+@code{t} (which means to support all available major modes) to a list
+of major mode names.
 
 @node Program Indent
 @section Indentation for Programs
diff --git a/doc/emacs/screen.texi b/doc/emacs/screen.texi
index 989cf998bfd..2b8edaf9375 100644
--- a/doc/emacs/screen.texi
+++ b/doc/emacs/screen.texi
@@ -314,5 +314,5 @@ the echo area.  You can use the up and down arrow keys to move through
 the menu to different items, and then you can type @key{RET} to select
 the item.  Each menu item is also designated by a letter or digit
 (usually the initial of some word in the item's name).  This letter or
-digit is separated from the item name by @samp{=>}.  You can type the
+digit is separated from the item name by @samp{==>}.  You can type the
 item's letter or digit to select the item.
diff --git a/doc/emacs/search.texi b/doc/emacs/search.texi
index 7e46e416219..7dc5855cdfc 100644
--- a/doc/emacs/search.texi
+++ b/doc/emacs/search.texi
@@ -21,6 +21,7 @@ thing, but search for patterns instead of fixed strings.
 * Incremental Search::        Search happens as you type the string.
 * Nonincremental Search::     Specify entire string and then search.
 * Word Search::               Search for sequence of words.
+* Symbol Search::             Search for a source code symbol.
 * Regexp Search::             Search for match for a regexp.
 * Regexps::                   Syntax of regular expressions.
 * Regexp Backslash::          Regular expression constructs starting with `\'.
@@ -467,6 +468,47 @@ the search string can match part of a word, so that the matching
 proceeds incrementally as you type.  This additional laxity does not
 apply to the lazy highlight, which always matches whole words.
 
+@node Symbol Search
+@section Symbol Search
+@cindex symbol search
+
+  A @dfn{symbol search} is much like an ordinary search, except that
+the boundaries of the search must match the boundaries of a symbol.
+The meaning of @dfn{symbol} in this context depends on the major mode,
+and usually refers to a source code token, such as a Lisp symbol in
+Emacs Lisp mode.  For instance, if you perform an incremental symbol
+search for the Lisp symbol @code{forward-word}, it would not match
+@code{isearch-forward-word}.  This feature is thus mainly useful for
+searching source code.
+
+@table @kbd
+@item M-s _
+If incremental search is active, toggle symbol search mode
+(@code{isearch-toggle-symbol}); otherwise, begin an incremental
+forward symbol search (@code{isearch-forward-symbol}).
+@item M-s _ @key{RET} @var{symbol} @key{RET}
+Search forward for @var{symbol}, nonincrementally.
+@item M-s _ C-r @key{RET} @var{symbol} @key{RET}
+Search backward for @var{symbol}, nonincrementally.
+@end table
+
+@kindex M-s _
+@findex isearch-forward-symbol
+  To begin a forward incremental symbol search, type @kbd{M-s _}.  If
+incremental search is not already active, this runs the command
+@code{isearch-forward-symbol}.  If incremental search is already
+active, @kbd{M-s _} switches to a symbol search, preserving the
+direction of the search and the current search string; you can disable
+symbol search by typing @kbd{M-s _} again.  In incremental symbol
+search, only the beginning of the search string is required to match
+the beginning of a symbol.
+
+  To begin a nonincremental symbol search, type @kbd{M-s _ @key{RET}}
+for a forward search, or @kbd{M-s _ C-r @key{RET}} or a backward
+search.  In nonincremental symbol searches, the beginning and end of
+the search string are required to match the beginning and end of a
+symbol, respectively.
+
 @node Regexp Search
 @section Regular Expression Search
 @cindex regexp search
diff --git a/doc/emacs/text.texi b/doc/emacs/text.texi
index f10e78e17ad..6e895d3ac3c 100644
--- a/doc/emacs/text.texi
+++ b/doc/emacs/text.texi
@@ -1399,7 +1399,7 @@ This is an example.
 #+end_example
 @end example
 
-  For further details, see @ref{Exporting,,,org, The Org Manual} and
+  For further details, @ref{Exporting,,,org, The Org Manual}, and
 @ref{Publishing,,,org, The Org Manual}.
 
 @node TeX Mode
diff --git a/doc/emacs/windows.texi b/doc/emacs/windows.texi
index 04d1353006f..f87da5f3913 100644
--- a/doc/emacs/windows.texi
+++ b/doc/emacs/windows.texi
@@ -384,12 +384,6 @@ Otherwise, if the buffer is already displayed in an existing window,
 are considered, but windows on other frames are also reusable if you
 change @code{pop-up-frames} (see below) to @code{t}.
 
-@item
-Otherwise, if you specified that the buffer should be displayed in a
-special frame by customizing @code{special-display-buffer-names} or
-@code{special-display-regexps}, do so.  @xref{Choosing Window
-Options,,, elisp, The Emacs Lisp Reference Manual}.
-
 @vindex pop-up-frames
 @item
 Otherwise, optionally create a new frame and display the buffer there.
diff --git a/doc/lispintro/ChangeLog b/doc/lispintro/ChangeLog
index 6c524f5a0ae..396e3857c58 100644
--- a/doc/lispintro/ChangeLog
+++ b/doc/lispintro/ChangeLog
@@ -1,3 +1,8 @@
+2012-10-24  Paul Eggert  <eggert@penguin.cs.ucla.edu>
+
+        * emacs-lisp-intro.texi (Files List):
+        Update manual for new time stamp format (Bug#12706).
+
 2012-10-17  Gregor Zattler  <grfz@gmx.de>  (tiny change)
 
         * emacs-lisp-intro.texi (Narrowing advantages):
diff --git a/doc/lispintro/emacs-lisp-intro.texi b/doc/lispintro/emacs-lisp-intro.texi
index 70ddb81c776..f885d6c15e8 100644
--- a/doc/lispintro/emacs-lisp-intro.texi
+++ b/doc/lispintro/emacs-lisp-intro.texi
@@ -238,7 +238,7 @@ GNU Press,               @hfill @uref{http://www.fsf.org/campaigns/gnu-press/}@*
 a division of the               @hfill email: @email{sales@@fsf.org}@*
 Free Software Foundation, Inc.  @hfill Tel: +1 (617) 542-5942@*
 51 Franklin Street, Fifth Floor @hfill Fax: +1 (617) 542-2652@*
-Boston, MA 02110-1301 USA       
+Boston, MA 02110-1301 USA
 @end iftex
 
 @ifnottex
@@ -249,7 +249,7 @@ GNU Press,                        http://www.fsf.org/campaigns/gnu-press/
 a division of the                 email: sales@@fsf.org
 Free Software Foundation, Inc.    Tel: +1 (617) 542-5942
 51 Franklin Street, Fifth Floor   Fax: +1 (617) 542-2652
-Boston, MA 02110-1301 USA          
+Boston, MA 02110-1301 USA
 @end example
 @end ifnottex
 
@@ -15680,11 +15680,11 @@ nil
 100
 @end group
 @group
-(17733 259)
-(17491 28834)
-(17596 62124)
-13157
-"-rw-rw-r--"
+(20615 27034 579989 697000)
+(17905 55681 0 0)
+(20615 26327 734791 805000)
+13188
+"-rw-r--r--"
 @end group
 @group
 nil
diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 26765e7a384..eca39e54203 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1,3 +1,86 @@
+2012-10-30  Glenn Morris  <rgm@gnu.org>
+
+        * variables.texi (Generalized Variables): Fix typo.
+
+2012-10-30  Chong Yidong  <cyd@gnu.org>
+
+        * symbols.texi (Symbol Plists): Document function-get.
+
+        * loading.texi (Autoload): Document autoloadp, autoload-do-load.
+
+        * frames.texi (Visibility of Frames): Document tty-top-frame.
+
+2012-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keymaps.texi (Format of Keymaps): Document the multiple
+        inheritance format.
+
+2012-10-28  Martin Rudalics  <rudalics@gmx.at>
+
+        * windows.texi (Basic Windows): Reformulate description of live,
+        internal and valid windows.
+        (Cyclic Window Ordering): Describe new argument of
+        get-lru-window and get-largest-window.  Add description of
+        window-in-direction.
+
+2012-10-27  Glenn Morris  <rgm@gnu.org>
+
+        * variables.texi (Generalized Variables): New section,
+        adapted from misc/cl.texi.
+        * elisp.texi (Top): Add Generalized Variables to menu.
+        * lists.texi (List Elements, List Variables):
+        Mention generalized variables.
+
+        * lists.texi (List Elements): Typo fix.
+
+2012-10-27  Chong Yidong  <cyd@gnu.org>
+
+        * minibuf.texi (High-Level Completion): Don't mention removed
+        function iswitchb-read-buffer.
+
+        * commands.texi (Event Input Misc): Remove last-input-char.
+        (Command Loop Info): Remove last-command-char.
+
+        * frames.texi (Initial Parameters): Don't mention the obsolete
+        special-display feature.
+
+        * windows.texi (Choosing Window): Don't mention the obsolete
+        special display feature.
+        (Choosing Window Options): Remove obsolete special-display
+        variables, and the functions special-display-p and
+        special-display-popup-frame.
+
+        * display.texi (Fringe Bitmaps): Add exclamation-mark bitmap.
+
+        * hooks.texi (Standard Hooks): Remove obsolete hooks.
+
+        * markers.texi (Information from Markers): Remove obsolete
+        function buffer-has-markers-at.
+
+        * text.texi (Yanking): Document yank-handled-properties.
+
+2012-10-24  Paul Eggert  <eggert@penguin.cs.ucla.edu>
+
+        Update manual for new time stamp format (Bug#12706).
+        * buffers.texi (Modification Time):
+        * files.texi (Testing Accessibility, File Attributes):
+        * intro.texi (Version Info):
+        * os.texi (Time of Day):
+        Update for new time stamp format (HIGH LOW MICROSEC PICOSEC).
+        These instances were missed the first time around.
+        Problem reported by Glenn Morris in <http://bugs.gnu.org/12706#25>.
+
+2012-10-24  Chong Yidong  <cyd@gnu.org>
+
+        * minibuf.texi (Text from Minibuffer): Document read-regexp
+        changes.
+
+        * nonascii.texi (Selecting a Representation): Document
+        set-buffer-multibyte changes.
+
+        * keymaps.texi (Toolkit Differences): Node deleted.
+        (Easy Menu): New node.
+
 2012-10-23  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * hooks.texi (Standard Hooks): Clarify that -hooks is deprecated.
diff --git a/doc/lispref/anti.texi b/doc/lispref/anti.texi
index f1f4a089f1b..6ece2149733 100644
--- a/doc/lispref/anti.texi
+++ b/doc/lispref/anti.texi
@@ -71,9 +71,8 @@ been removed, including @code{display-buffer-overriding-action} and
 related variables, as well as the @var{action} argument to
 @code{display-buffer} and other functions.  The way to
 programmatically control how Emacs chooses a window to display a
-buffer is to bind the right combination of
-@code{special-display-regexps}, @code{pop-up-frames}, and other
-variables.
+buffer is to bind the right combination of @code{pop-up-frames} and
+other variables.
 
 @item
 The standard completion interface has been simplified, eliminating the
diff --git a/doc/lispref/buffers.texi b/doc/lispref/buffers.texi
index b9666a79f5b..4a556895de7 100644
--- a/doc/lispref/buffers.texi
+++ b/doc/lispref/buffers.texi
@@ -634,7 +634,8 @@ file should not be done.
 @c Emacs 19 feature
 @defun visited-file-modtime
 This function returns the current buffer's recorded last file
-modification time, as a list of the form @code{(@var{high} @var{low})}.
+modification time, as a list of the form @code{(@var{high} @var{low}
+@var{microsec} @var{picosec})}.
 (This is the same format that @code{file-attributes} uses to return
 time values; see @ref{File Attributes}.)
 
@@ -664,9 +665,8 @@ is not @code{nil}, and otherwise to the last modification time of the
 visited file.
 
 If @var{time} is neither @code{nil} nor zero, it should have the form
-@code{(@var{high} . @var{low})} or @code{(@var{high} @var{low})}, in
-either case containing two integers, each of which holds 16 bits of the
-time.
+@code{(@var{high} @var{low} @var{microsec} @var{picosec})},
+the format used by @code{current-time} (@pxref{Time of Day}).
 
 This function is useful if the buffer was not read from the file
 normally, or if the file itself has been changed for some known benign
@@ -1237,4 +1237,3 @@ This function returns the current gap position in the current buffer.
 @defun gap-size
 This function returns the current gap size of the current buffer.
 @end defun
-
diff --git a/doc/lispref/commands.texi b/doc/lispref/commands.texi
index 9ffa2b74857..c42e4b3b6dc 100644
--- a/doc/lispref/commands.texi
+++ b/doc/lispref/commands.texi
@@ -186,7 +186,6 @@ buffer: } prompts the user with @samp{Frobnicate buffer: } to enter
 the name of an existing buffer, which becomes the second and final
 argument.
 
-@c Emacs 19 feature
 The prompt string can use @samp{%} to include previous argument values
 (starting with the first argument) in the prompt.  This is done using
 @code{format} (@pxref{Formatting Strings}).  For example, here is how
@@ -205,7 +204,6 @@ If @samp{*} appears at the beginning of the string, then an error is
 signaled if the buffer is read-only.
 
 @cindex @samp{@@} in @code{interactive}
-@c Emacs 19 feature
 If @samp{@@} appears at the beginning of the string, and if the key
 sequence used to invoke the command includes any mouse events, then
 the window associated with the first of those events is selected
@@ -910,7 +908,6 @@ up a menu.  It is also used internally by @code{y-or-n-p}
 @end defvar
 
 @defvar last-command-event
-@defvarx last-command-char
 This variable is set to the last input event that was read by the
 command loop as part of a command.  The principal use of this variable
 is in @code{self-insert-command}, which uses it to decide which
@@ -926,11 +923,8 @@ last-command-event
 
 @noindent
 The value is 5 because that is the @acronym{ASCII} code for @kbd{C-e}.
-
-The alias @code{last-command-char} is obsolete.
 @end defvar
 
-@c Emacs 19 feature
 @defvar last-event-frame
 This variable records which frame the last input event was directed to.
 Usually this is the frame that was selected when the event was
@@ -2386,7 +2380,6 @@ mouse on the window's mode line, you get two events, like this:
 @end example
 
 @defvar num-input-keys
-@c Emacs 19 feature
 This variable's value is the number of key sequences processed so far in
 this Emacs session.  This includes key sequences read from the terminal
 and key sequences read from keyboard macros being executed.
@@ -2539,7 +2532,6 @@ then continues to wait for a valid input character, or keyboard-quit.
 @code{keyboard-translate-table} (if applicable), before returning it
 from @code{read-event}.
 
-@c Emacs 19 feature
 @defvar extra-keyboard-modifiers
 This variable lets Lisp programs ``press'' the modifier keys on the
 keyboard.  The value is a character.  Only the modifiers of the
@@ -2755,7 +2747,6 @@ may return @code{t} when no input is available.
 @end defun
 
 @defvar last-input-event
-@defvarx last-input-char
 This variable records the last terminal input event read, whether
 as part of a command or explicitly by a Lisp program.
 
@@ -2774,8 +2765,6 @@ this expression) remains the value of @code{last-command-event}.
      @result{} 49
 @end group
 @end example
-
-The alias @code{last-input-char} is obsolete.
 @end defvar
 
 @defmac while-no-input body@dots{}
diff --git a/doc/lispref/display.texi b/doc/lispref/display.texi
index 0b5ada43744..68701a47126 100644
--- a/doc/lispref/display.texi
+++ b/doc/lispref/display.texi
@@ -3550,8 +3550,8 @@ Used to indicate buffer boundaries.
 @itemx @code{vertical-bar}, @code{horizontal-bar}
 Used for different types of fringe cursors.
 
-@item @code{empty-line}, @code{question-mark}, @code{exclamation-mark}
-Unused.
+@item @code{empty-line}, @code{exclamation-mark}, @code{question-mark}, @code{exclamation-mark}
+Not used by core Emacs features.
 @end table
 
 @noindent
diff --git a/doc/lispref/elisp.texi b/doc/lispref/elisp.texi
index d46cb071bf7..06a2ebfcaf8 100644
--- a/doc/lispref/elisp.texi
+++ b/doc/lispref/elisp.texi
@@ -486,6 +486,7 @@ Variables
 * Variable Aliases::        Variables that are aliases for other variables.
 * Variables with Restricted Values::  Non-constant variables whose value can
                                         @emph{not} be an arbitrary Lisp object.
+* Generalized Variables::   Extending the concept of variables.
 
 Scoping Rules for Variable Bindings
 
@@ -800,17 +801,14 @@ Menu Keymaps
 * Menu Bar::                How to customize the menu bar.
 * Tool Bar::                A tool bar is a row of images.
 * Modifying Menus::         How to add new items to a menu.
+* Easy Menu::               A convenience macro for defining menus.
 
 Defining Menus
 
-* Simple Menu Items::       A simple kind of menu key binding,
-                              limited in capabilities.
-* Extended Menu Items::     More powerful menu item definitions
-                              let you specify keywords to enable
-                              various features.
+* Simple Menu Items::       A simple kind of menu key binding.
+* Extended Menu Items::     More complex menu item definitions.
 * Menu Separators::         Drawing a horizontal line through a menu.
 * Alias Menu Items::        Using command aliases in menu items.
-* Toolkit Differences::     Not all toolkits provide the same features.
 
 Major and Minor Modes
 
diff --git a/doc/lispref/files.texi b/doc/lispref/files.texi
index 285e6406426..a5710c789e9 100644
--- a/doc/lispref/files.texi
+++ b/doc/lispref/files.texi
@@ -938,7 +938,7 @@ on the 19th, @file{aug-20} was written on the 20th, and the file
 @end example
 
 You can use @code{file-attributes} to get a file's last modification
-time as a list of two numbers.  @xref{File Attributes}.
+time as a list of four integers.  @xref{File Attributes}.
 @end defun
 
 @node Kinds of Files
@@ -1228,11 +1228,11 @@ so this time will always hold the midnight of the day of last access.
 
 @cindex modification time of file
 @item
-The time of last modification as a list of two integers (as above).
+The time of last modification as a list of four integers (as above).
 This is the last time when the file's contents were modified.
 
 @item
-The time of last status change as a list of two integers (as above).
+The time of last status change as a list of four integers (as above).
 This is the time of the last change to the file's access mode bits,
 its owner and group, and other information recorded in the filesystem
 for the file, beyond the file's contents.
@@ -1275,9 +1275,9 @@ For example, here are the file attributes for @file{files.texi}:
 @group
 (file-attributes "files.texi" 'string)
      @result{}  (nil 1 "lh" "users"
-          (19145 42977)
-          (19141 59576)
-          (18340 17300)
+          (20614 64019 50040 152000)
+          (20000 23 0 0)
+          (20614 64555 902289 872000)
           122295 "-rw-rw-rw-"
           nil  (5888 2 . 43978)
           (15479 . 46724))
@@ -1301,14 +1301,14 @@ is owned by the user with name "lh".
 @item "users"
 is in the group with name "users".
 
-@item (19145 42977)
-was last accessed on Oct 5 2009, at 10:01:37.
+@item (20614 64019 50040 152000)
+was last accessed on October 23, 2012, at 20:12:03.050040152 UTC.
 
-@item (19141 59576)
-last had its contents modified on Oct 2 2009, at 13:49:12.
+@item (20000 23 0 0)
+was last modified on July 15, 2001, at 08:53:43 UTC.
 
-@item (18340 17300)
-last had its status changed on Feb 2 2008, at 12:19:00.
+@item (20614 64555 902289 872000)
+last had its status changed on October 23, 2012, at 20:20:59.902289872 UTC.
 
 @item 122295
 is 122295 bytes long.  (It may not contain 122295 characters, though,
diff --git a/doc/lispref/frames.texi b/doc/lispref/frames.texi
index af6f4b4c079..f58d62675e5 100644
--- a/doc/lispref/frames.texi
+++ b/doc/lispref/frames.texi
@@ -437,13 +437,11 @@ Emacs frames---the first frame, and subsequent frames.  When using the X
 Window System, you can get the same results by means of X resources
 in many cases.
 
-Setting this variable does not affect existing frames.
+Setting this variable does not affect existing frames.  Furthermore,
+functions that display a buffer in a separate frame may override the
+default parameters by supplying their own parameters.
 @end defopt
 
-Functions that display a buffer in a separate frame can override the
-default parameters by supplying their own parameters.  @xref{Definition
-of special-display-frame-alist}.
-
 If you invoke Emacs with command-line options that specify frame
 appearance, those options take effect by adding elements to either
 @code{initial-frame-alist} or @code{default-frame-alist}.  Options
@@ -1495,8 +1493,9 @@ This function returns the visibility status of frame @var{frame}.  The
 value is @code{t} if @var{frame} is visible, @code{nil} if it is
 invisible, and @code{icon} if it is iconified.
 
-On a text terminal, all frames are considered visible, whether they
-are currently being displayed or not.
+On a text terminal, all frames are considered ``visible'' for the
+purposes of this function, even though only one frame is displayed.
+@xref{Raising and Lowering}.
 @end defun
 
 @deffn Command iconify-frame &optional frame
@@ -1552,9 +1551,21 @@ If this is non-@code{nil}, activation of the minibuffer raises the frame
 that the minibuffer window is in.
 @end defopt
 
-You can also enable auto-raise (raising automatically when a frame is
-selected) or auto-lower (lowering automatically when it is deselected)
-for any frame using frame parameters.  @xref{Management Parameters}.
+  On window systems, you can also enable auto-raising (on frame
+selection) or auto-lowering (on frame deselection) using frame
+parameters.  @xref{Management Parameters}.
+
+@cindex top frame
+  The concept of raising and lowering frames also applies to text
+terminal frames.  On each text terminal, only the top frame is
+displayed at any one time.
+
+@defun tty-top-frame terminal
+This function returns the top frame on @var{terminal}.  @var{terminal}
+should be a terminal object, a frame (meaning that frame's terminal),
+or @code{nil} (meaning the selected frame's terminal).  If it does not
+refer to a text terminal, the return value is @code{nil}.
+@end defun
 
 @node Frame Configurations
 @section Frame Configurations
diff --git a/doc/lispref/hooks.texi b/doc/lispref/hooks.texi
index a7f01243641..a6ac2c70e84 100644
--- a/doc/lispref/hooks.texi
+++ b/doc/lispref/hooks.texi
@@ -120,14 +120,7 @@ The command loop runs this soon after @code{post-command-hook} (q.v.).
 @item delete-terminal-functions
 @xref{Multiple Terminals}.
 
-@ignore
-@item disabled-command-function
-@xref{Disabling Commands}.
-@end ignore
-
-@item display-buffer-function
 @itemx pop-up-frame-function
-@itemx special-display-function
 @itemx split-window-preferred-function
 @xref{Choosing Window Options}.
 
@@ -272,7 +265,6 @@ deferred-action-function
 input-method-function
 load-read-function
 load-source-file-function
-macro-declaration-function
 read-buffer-function
 ring-bell-function
 select-safe-coding-system-function
diff --git a/doc/lispref/intro.texi b/doc/lispref/intro.texi
index e61e13662db..4770701b601 100644
--- a/doc/lispref/intro.texi
+++ b/doc/lispref/intro.texi
@@ -493,13 +493,13 @@ giving a prefix argument makes @var{here} non-@code{nil}.
 
 @defvar emacs-build-time
 The value of this variable indicates the time at which Emacs was
-built.  It is a list of three integers, like the value of
+built.  It is a list of four integers, like the value of
 @code{current-time} (@pxref{Time of Day}).
 
 @example
 @group
 emacs-build-time
-     @result{} (18846 52016 156039)
+     @result{} (20614 63694 515336 438000)
 @end group
 @end example
 @end defvar
diff --git a/doc/lispref/keymaps.texi b/doc/lispref/keymaps.texi
index 9fa6193a804..f658f7e66fb 100644
--- a/doc/lispref/keymaps.texi
+++ b/doc/lispref/keymaps.texi
@@ -210,6 +210,11 @@ Aside from elements that specify bindings for keys, a keymap can also
 have a string as an element.  This is called the @dfn{overall prompt
 string} and makes it possible to use the keymap as a menu.
 @xref{Defining Menus}.
+
+@item (keymap @dots{})
+If an element of a keymap is itself a keymap, it counts as if this inner keymap
+were inlined in the outer keymap.  This is used for multiple-inheritance, such
+as in @code{make-composed-keymap}.
 @end table
 
 When the binding is @code{nil}, it doesn't constitute a definition
@@ -1963,13 +1968,14 @@ is active for the next input event, that activates the keyboard menu
 feature.
 
 @menu
-* Defining Menus::              How to make a keymap that defines a menu.
-* Mouse Menus::                 How users actuate the menu with the mouse.
-* Keyboard Menus::              How users actuate the menu with the keyboard.
-* Menu Example::                Making a simple menu.
-* Menu Bar::                    How to customize the menu bar.
-* Tool Bar::                    A tool bar is a row of images.
-* Modifying Menus::             How to add new items to a menu.
+* Defining Menus::     How to make a keymap that defines a menu.
+* Mouse Menus::        How users actuate the menu with the mouse.
+* Keyboard Menus::     How users actuate the menu with the keyboard.
+* Menu Example::       Making a simple menu.
+* Menu Bar::           How to customize the menu bar.
+* Tool Bar::           A tool bar is a row of images.
+* Modifying Menus::    How to add new items to a menu.
+* Easy Menu::      A convenience macro for making menus.
 @end menu
 
 @node Defining Menus
@@ -2015,17 +2021,12 @@ an existing menu, you can specify its position in the menu using
 @code{define-key-after} (@pxref{Modifying Menus}).
 
 @menu
-* Simple Menu Items::       A simple kind of menu key binding,
-                              limited in capabilities.
-* Extended Menu Items::     More powerful menu item definitions
-                              let you specify keywords to enable
-                              various features.
+* Simple Menu Items::       A simple kind of menu key binding.
+* Extended Menu Items::     More complex menu item definitions.
 * Menu Separators::         Drawing a horizontal line through a menu.
 * Alias Menu Items::        Using command aliases in menu items.
-* Toolkit Differences::     Not all toolkits provide the same features.
 @end menu
 
-
 @node Simple Menu Items
 @subsubsection Simple Menu Items
 
@@ -2312,28 +2313,6 @@ itself).  To request this, give the alias symbol a non-@code{nil}
 causes menu items for @code{make-read-only} and @code{make-writable} to
 show the keyboard bindings for @code{read-only-mode}.
 
-@node Toolkit Differences
-@subsubsection Toolkit Differences
-
-The various toolkits with which you can build Emacs do not all support
-the same set of features for menus.  Some code works as expected with
-one toolkit, but not under another.
-
-One example is menu actions or buttons in a top-level menu bar.  The
-following works with the Lucid toolkit or on MS Windows, but not with
-GTK or Nextstep, where clicking on the item has no effect.
-
-@example
-(defun menu-action-greet ()
-   (interactive)
-   (message "Hello Emacs User!"))
-
-(defun top-level-menu ()
-  (interactive)
-  (define-key lisp-interaction-mode-map [menu-bar m]
-     '(menu-item "Action Button" menu-action-greet)))
-@end example
-
 @node Mouse Menus
 @subsection Menus and the Mouse
 
@@ -2813,3 +2792,125 @@ menu of Shell mode, after the item @code{break}:
   [work] '("Work" . work-command) 'break)
 @end example
 @end defun
+
+@node Easy Menu
+@subsection Easy Menu
+
+  The following macro provides a convenient way to define pop-up menus
+and/or menu bar menus.
+
+@defmac easy-menu-define symbol maps doc menu
+This macro defines a pop-up menu and/or menu bar submenu, whose
+contents are given by @var{menu}.
+
+If @var{symbol} is non-@code{nil}, it should be a symbol; then this
+macro defines @var{symbol} as a function for popping up the menu
+(@pxref{Pop-Up Menus}), with @var{doc} as its documentation string.
+@var{symbol} should not be quoted.
+
+Regardless of the value of @var{symbol}, if @var{maps} is a keymap,
+the menu is added to that keymap, as a top-level menu for the menu bar
+(@pxref{Menu Bar}).  It can also be a list of keymaps, in which case
+the menu is added separately to each of those keymaps.
+
+The first element of @var{menu} must be a string, which serves as the
+menu label.  It may be followed by any number of the following
+keyword-argument pairs:
+
+@table @code
+@item :filter @var{function}
+@var{function} must be a function which, if called with one
+argument---the list of the other menu items---returns the actual items
+to be displayed in the menu.
+
+@item :visible @var{include}
+@var{include} is an expression; if it evaluates to @code{nil}, the
+menu is made invisible.  @code{:included} is an alias for
+@code{:visible}.
+
+@item :active @var{enable}
+@var{enable} is an expression; if it evaluates to @code{nil}, the menu
+is not selectable.  @code{:enable} is an alias for @code{:active}.
+@end table
+
+The remaining elements in @var{menu} are menu items.
+
+A menu item can be a vector of three elements, @code{[@var{name}
+@var{callback} @var{enable}]}.  @var{name} is the menu item name (a
+string).  @var{callback} is a command to run, or an expression to
+evaluate, when the item is chosen.  @var{enable} is an expression; if
+it evaluates to @code{nil}, the item is disabled for selection.
+
+Alternatively, a menu item may have the form:
+
+@smallexample
+   [ @var{name} @var{callback} [ @var{keyword} @var{arg} ]... ]
+@end smallexample
+
+@noindent
+where @var{name} and @var{callback} have the same meanings as above,
+and each optional @var{keyword} and @var{arg} pair should be one of
+the following:
+
+@table @code
+@item :keys @var{keys}
+@var{keys} is a keyboard equivalent to the menu item (a string).  This
+is normally not needed, as keyboard equivalents are computed
+automatically.  @var{keys} is expanded with
+@code{substitute-command-keys} before it is displayed (@pxref{Keys in
+Documentation}).
+
+@item :key-sequence @var{keys}
+@var{keys} is a hint for speeding up Emacs's first display of the
+menu.  It should be nil if you know that the menu item has no keyboard
+equivalent; otherwise it should be a string or vector specifying a
+keyboard equivalent for the menu item.
+
+@item :active @var{enable}
+@var{enable} is an expression; if it evaluates to @code{nil}, the item
+is make unselectable..  @code{:enable} is an alias for @code{:active}.
+
+@item :visible @var{include}
+@var{include} is an expression; if it evaluates to @code{nil}, the
+item is made invisible.  @code{:included} is an alias for
+@code{:visible}.
+
+@item :label @var{form}
+@var{form} is an expression that is evaluated to obtain a value which
+serves as the menu item's label (the default is @var{name}).
+
+@item :suffix @var{form}
+@var{form} is an expression that is dynamically evaluated and whose
+value is concatenated with the menu entry's label.
+
+@item :style @var{style}
+@var{style} is a symbol describing the type of menu item; it should be
+@code{toggle} (a checkbox), or @code{radio} (a radio button), or
+anything else (meaning an ordinary menu item).
+
+@item :selected @var{selected}
+@var{selected} is an expression; the checkbox or radio button is
+selected whenever the expression's value is non-nil.
+
+@item :help @var{help}
+@var{help} is a string describing the menu item.
+@end table
+
+Alternatively, a menu item can be a string.  Then that string appears
+in the menu as unselectable text.  A string consisting of dashes is
+displayed as a separator (@pxref{Menu Separators}).
+
+Alternatively, a menu item can be a list with the same format as
+@var{menu}.  This is a submenu.
+@end defmac
+
+Here is an example of using @code{easy-menu-define} to define a menu
+similar to the one defined in the example in @ref{Menu Bar}:
+
+@example
+(easy-menu-define words-menu global-map
+  "Menu for word navigation commands."
+  '("Words"
+     ["Forward word" forward-word]
+     ["Backward word" backward-word]))
+@end example
diff --git a/doc/lispref/lists.texi b/doc/lispref/lists.texi
index 4a8740a5734..09948caaa13 100644
--- a/doc/lispref/lists.texi
+++ b/doc/lispref/lists.texi
@@ -236,6 +236,10 @@ This is in contrast to @code{cdr}, which signals an error if
 @defmac pop listname
 This macro is a way of examining the @sc{car} of a list,
 and taking it off the list, all at once.
+@c FIXME I don't think is a particularly good way to do it,
+@c but generalized variables have not been introduced yet.
+(In fact, this macro can act on generalized variables, not just lists.
+@xref{Generalized Variables}.)
 
 It operates on the list which is stored in the symbol @var{listname}.
 It removes this element from the list by setting @var{listname}
@@ -252,7 +256,7 @@ x
 @end example
 
 @noindent
-For the @code{pop} macro, which removes an element from a list,
+For the @code{push} macro, which adds an element to a list,
 @xref{List Variables}.
 @end defmac
 
@@ -682,6 +686,10 @@ to modify a list which is stored in a variable.
 @defmac push newelt listname
 This macro provides an alternative way to write
 @code{(setq @var{listname} (cons @var{newelt} @var{listname}))}.
+@c FIXME I don't think is a particularly good way to do it,
+@c but generalized variables have not been introduced yet.
+(In fact, this macro can act on generalized variables, not just lists.
+@xref{Generalized Variables}.)
 
 @example
 (setq l '(a b))
diff --git a/doc/lispref/loading.texi b/doc/lispref/loading.texi
index 77a31cfde7a..6a18bea2977 100644
--- a/doc/lispref/loading.texi
+++ b/doc/lispref/loading.texi
@@ -408,9 +408,9 @@ to load automatically from @var{filename}.  The string @var{filename}
 specifies the file to load to get the real definition of @var{function}.
 
 If @var{filename} does not contain either a directory name, or the
-suffix @code{.el} or @code{.elc}, then @code{autoload} insists on adding
-one of these suffixes, and it will not load from a file whose name is
-just @var{filename} with no added suffix.  (The variable
+suffix @code{.el} or @code{.elc}, this function insists on adding one
+of these suffixes, and it will not load from a file whose name is just
+@var{filename} with no added suffix.  (The variable
 @code{load-suffixes} specifies the exact required suffixes.)
 
 The argument @var{docstring} is the documentation string for the
@@ -442,10 +442,11 @@ and calls @code{define-key}; not even if the variable name is the same
 symbol @var{function}.
 
 @cindex function cell in autoload
-If @var{function} already has a non-void function definition that is not
-an autoload object, @code{autoload} does nothing and returns @code{nil}.
-If the function cell of @var{function} is void, or is already an autoload
-object, then it is defined as an autoload object like this:
+if @var{function} already has non-void function definition that is not
+an autoload object, this function does nothing and returns @code{nil}.
+Otherwise, it constructs an autoload object (@pxref{Autoload Type}),
+and stores it as the function definition for @var{function}.  The
+autoload object has this form:
 
 @example
 (autoload @var{filename} @var{docstring} @var{interactive} @var{type})
@@ -468,6 +469,16 @@ refers to the documentation string in the
 not a macro or a keymap.
 @end defun
 
+@defun autoloadp object
+This function returns non-@code{nil} if @var{object} is an autoload
+object.  For example, to check if @code{run-prolog} is defined as an
+autoloaded function, evaluate
+
+@smallexample
+(autoloadp (symbol-function 'run-prolog))
+@end smallexample
+@end defun
+
 @cindex autoload errors
   The autoloaded file usually contains other definitions and may require
 or provide one or more features.  If the file is not completely loaded
@@ -599,6 +610,19 @@ override that, e.g., in the ``Local Variables'' section of a
 assumed to contain a trailer starting with a formfeed character.
 @end defvar
 
+  The following function may be used to explicitly load the library
+specified by an autoload object:
+
+@defun autoload-do-load autoload &optional name macro-only
+This function performs the loading specified by @var{autoload}, which
+whould be an autoload object.  The optional argument @var{name}, if
+non-@code{nil}, should be a symbol whose function value is
+@var{autoload}; in that case, the return value of this function is the
+symbol's new function value.  If the value of the optional argument
+@var{macro-only} is @code{macro}, this function avoids loading a
+function, only a macro.
+@end defun
+
 @node Repeated Loading
 @section Repeated Loading
 @cindex repeated loading
diff --git a/doc/lispref/markers.texi b/doc/lispref/markers.texi
index 80136f2e6f4..fa884269b36 100644
--- a/doc/lispref/markers.texi
+++ b/doc/lispref/markers.texi
@@ -307,11 +307,6 @@ This function returns the buffer that @var{marker} points into, or
 @end example
 @end defun
 
-@defun buffer-has-markers-at position
-This function returns @code{t} if one or more markers
-point at position @var{position} in the current buffer.
-@end defun
-
 @node Marker Insertion Types
 @section Marker Insertion Types
 
diff --git a/doc/lispref/minibuf.texi b/doc/lispref/minibuf.texi
index 39b4fca3b25..7243f46b882 100644
--- a/doc/lispref/minibuf.texi
+++ b/doc/lispref/minibuf.texi
@@ -211,22 +211,25 @@ This function works by calling the
 @end smallexample
 @end defun
 
-@defun read-regexp prompt &optional default
+@defun read-regexp prompt &optional default history
 This function reads a regular expression as a string from the
 minibuffer and returns it.  The argument @var{prompt} is used as in
-@code{read-from-minibuffer}.  The keymap used is
-@code{minibuffer-local-map}, and @code{regexp-history} is used as the
-history list (@pxref{Minibuffer History, regexp-history}).
+@code{read-from-minibuffer}.
 
 The optional argument @var{default} specifies a default value to
 return if the user enters null input; it should be a string, or
 @code{nil}, which is equivalent to an empty string.
 
-In addition, @code{read-regexp} collects a few useful candidates for
-input and passes them to @code{read-from-minibuffer}, to make them
-available to the user as the ``future minibuffer history list''
-(@pxref{Minibuffer History, future list,, emacs, The GNU Emacs
-Manual}).  These candidates are:
+The optional argument @var{history}, if non-@code{nil}, is a symbol
+specifying a minibuffer history list to use (@pxref{Minibuffer
+History}).  If it is omitted or @code{nil}, the history list defaults
+to @code{regexp-history}.
+
+@code{read-regexp} also collects a few useful candidates for input and
+passes them to @code{read-from-minibuffer}, to make them available to
+the user as the ``future minibuffer history list'' (@pxref{Minibuffer
+History, future list,, emacs, The GNU Emacs Manual}).  These
+candidates are:
 
 @itemize @minus
 @item
@@ -1215,11 +1218,9 @@ Buffer name (default foo): @point{}
 @end defun
 
 @defopt read-buffer-function
-This variable specifies how to read buffer names.  The function is
-called with the arguments passed to @code{read-buffer}.  For example,
-if you set this variable to @code{iswitchb-read-buffer}, all Emacs
-commands that call @code{read-buffer} to read a buffer name will
-actually use the @code{iswitchb} package to read it.
+This variable, if non-@code{nil}, specifies a function for reading
+buffer names.  @code{read-buffer} calls this function instead of doing
+its usual work, with the same arguments passed to @code{read-buffer}.
 @end defopt
 
 @defopt read-buffer-completion-ignore-case
diff --git a/doc/lispref/nonascii.texi b/doc/lispref/nonascii.texi
index 2f6f516c587..e384d40176e 100644
--- a/doc/lispref/nonascii.texi
+++ b/doc/lispref/nonascii.texi
@@ -241,8 +241,12 @@ representation is in use.  It also adjusts various data in the buffer
 (including overlays, text properties and markers) so that they cover the
 same text as they did before.
 
-You cannot use @code{set-buffer-multibyte} on an indirect buffer,
-because indirect buffers always inherit the representation of the
+This function signals an error if the buffer is narrowed, since the
+narrowing might have occurred in the middle of multibyte character
+sequences.
+
+This function also signals an error if the buffer is an indirect
+buffer.  An indirect buffer always inherits the representation of its
 base buffer.
 @end defun
 
diff --git a/doc/lispref/os.texi b/doc/lispref/os.texi
index d3c3c6fd241..6c5f6e85683 100644
--- a/doc/lispref/os.texi
+++ b/doc/lispref/os.texi
@@ -1199,7 +1199,7 @@ Similarly, the fourth list element @var{picosec}, if present, gives
 the number of picoseconds from the start of that microsecond to the
 specified time.
 
-  The return value of @code{current-time} represents time using three
+  The return value of @code{current-time} represents time using four
 integers, as do the timestamps in the return value of
 @code{file-attributes} (@pxref{Definition of
 file-attributes}).  In function arguments, e.g.@: the @var{time-value}
diff --git a/doc/lispref/symbols.texi b/doc/lispref/symbols.texi
index d7497ab6f3f..326c6cd4ab2 100644
--- a/doc/lispref/symbols.texi
+++ b/doc/lispref/symbols.texi
@@ -487,6 +487,12 @@ using @code{eq}, so any object is a legitimate property.
 See @code{put} for an example.
 @end defun
 
+@defun function-get symbol property
+This function is identical to @code{get}, except that if @var{symbol}
+is the name of a function alias, it looks in the property list of the
+symbol naming the actual function.  @xref{Defining Functions}.
+@end defun
+
 @defun put symbol property value
 This function puts @var{value} onto @var{symbol}'s property list under
 the property name @var{property}, replacing any previous property value.
diff --git a/doc/lispref/text.texi b/doc/lispref/text.texi
index 50b97cd4204..57df02b74a0 100644
--- a/doc/lispref/text.texi
+++ b/doc/lispref/text.texi
@@ -899,31 +899,34 @@ In Lisp programs, it is better to use @code{kill-new} or
 @node Yanking
 @subsection Yanking
 
-  Yanking means inserting text from the kill ring, but it does
-not insert the text blindly.  Yank commands and some other commands
-use @code{insert-for-yank} to perform special processing on the
-text that they copy into the buffer.
+  Yanking means inserting text from the kill ring, but it does not
+insert the text blindly.  The @code{yank} command, and related
+commands, use @code{insert-for-yank} to perform special processing on
+the text before it is inserted.
 
 @defun insert-for-yank string
-This function normally works like @code{insert} except that it doesn't
-insert the text properties (@pxref{Text Properties}) in the list
-variable @code{yank-excluded-properties}.  However, if any part of
-@var{string} has a non-@code{nil} @code{yank-handler} text property,
-that property can do various special processing on that part of the
-text being inserted.
+This function works like @code{insert}, except that it processes the
+text in @var{string} according to the @code{yank-handler} text
+property, as well as the variables @code{yank-handled-properties} and
+@code{yank-excluded-properties} (see below), before inserting the
+result into the current buffer.
 @end defun
 
 @defun insert-buffer-substring-as-yank buf &optional start end
-This function resembles @code{insert-buffer-substring} except that it
-doesn't insert the text properties in the
-@code{yank-excluded-properties} list.
+This function resembles @code{insert-buffer-substring}, except that it
+processes the text according to @code{yank-handled-properties} and
+@code{yank-excluded-properties}.  (It does not handle the
+@code{yank-handler} property, which does not normally occur in buffer
+text anyway.)
 @end defun
 
-  You can put a @code{yank-handler} text property on all or part of
-the text to control how it will be inserted if it is yanked.  The
-@code{insert-for-yank} function looks for that property.  The property
-value must be a list of one to four elements, with the following
-format (where elements after the first may be omitted):
+  If you put a @code{yank-handler} text property on all or part of a
+string, that alters how @code{insert-for-yank} inserts the string.  If
+different parts of the string have different @code{yank-handler}
+values (comparison being done with @code{eq}), each substring is
+handled separately.  The property value must be a list of one to four
+elements, with the following format (where elements after the first
+may be omitted):
 
 @example
 (@var{function} @var{param} @var{noexclude} @var{undo})
@@ -933,22 +936,21 @@ format (where elements after the first may be omitted):
 
 @table @var
 @item function
-When @var{function} is present and non-@code{nil}, it is called instead of
-@code{insert} to insert the string.  @var{function} takes one
-argument---the string to insert.
+When @var{function} is non-@code{nil}, it is called instead of
+@code{insert} to insert the string, with one argument---the string to
+insert.
 
 @item param
 If @var{param} is present and non-@code{nil}, it replaces @var{string}
-(or the part of @var{string} being processed) as the object passed to
-@var{function} (or @code{insert}); for example, if @var{function} is
-@code{yank-rectangle}, @var{param} should be a list of strings to
-insert as a rectangle.
+(or the substring of @var{string} being processed) as the object
+passed to @var{function} (or @code{insert}).  For example, if
+@var{function} is @code{yank-rectangle}, @var{param} should be a list
+of strings to insert as a rectangle.
 
 @item noexclude
-If @var{noexclude} is present and non-@code{nil}, the normal removal of the
-yank-excluded-properties is not performed; instead @var{function} is
-responsible for removing those properties.  This may be necessary
-if @var{function} adjusts point before or after inserting the object.
+If @var{noexclude} is present and non-@code{nil}, that disables the
+normal action of @code{yank-handled-properties} and
+@code{yank-excluded-properties} on the inserted string.
 
 @item undo
 If @var{undo} is present and non-@code{nil}, it is a function that will be
@@ -959,14 +961,29 @@ the @var{undo} value.
 @end table
 
 @cindex yanking and text properties
+@defopt yank-handled-properties
+This variable specifies special text property handling conditions for
+yanked text.  It takes effect after the text has been inserted (either
+normally, or via the @code{yank-handler} property), and prior to
+@code{yank-excluded-properties} taking effect.
+
+The value should be an alist of elements @code{(@var{prop}
+. @var{fun})}.  Each alist element is handled in order.  The inserted
+text is scanned for stretches of text having text properties @code{eq}
+to @var{prop}; for each such stretch, @var{fun} is called with three
+arguments: the value of the property, and the start and end positions
+of the text.
+@end defopt
+
 @defopt yank-excluded-properties
-Yanking discards certain text properties from the yanked text, as
-described above.  The value of this variable is the list of properties
-to discard.  Its default value contains properties that might lead to
-annoying results, such as causing the text to respond to the mouse or
-specifying key bindings.
+The value of this variable is the list of properties to remove from
+inserted text.  Its default value contains properties that might lead
+to annoying results, such as causing the text to respond to the mouse
+or specifying key bindings.  It takes effect after
+@code{yank-handled-properties}.
 @end defopt
 
+
 @node Yank Commands
 @subsection Functions for Yanking
 
diff --git a/doc/lispref/variables.texi b/doc/lispref/variables.texi
index 1c0abcb8e66..580dd8258df 100644
--- a/doc/lispref/variables.texi
+++ b/doc/lispref/variables.texi
@@ -41,6 +41,7 @@ representing the variable.
 * Variable Aliases::            Variables that are aliases for other variables.
 * Variables with Restricted Values::  Non-constant variables whose value can
                                         @emph{not} be an arbitrary Lisp object.
+* Generalized Variables::       Extending the concept of variables.
 @end menu
 
 @node Global Variables
@@ -1946,3 +1947,105 @@ Attempting to assign them any other value will result in an error:
 (setq undo-limit 1000.0)
 @error{} Wrong type argument: integerp, 1000.0
 @end example
+
+@c FIXME?  Not sure this is the right place for this section.
+@node Generalized Variables
+@section Generalized Variables
+
+A @dfn{generalized variable} or @dfn{place form} is one of the many places
+in Lisp memory where values can be stored.  The simplest place form is
+a regular Lisp variable.  But the @sc{car}s and @sc{cdr}s of lists, elements
+of arrays, properties of symbols, and many other locations are also
+places where Lisp values are stored.
+
+@c FIXME?  Not sure this is a useful analogy...
+Generalized variables are analogous to ``lvalues'' in the C
+language, where @samp{x = a[i]} gets an element from an array
+and @samp{a[i] = x} stores an element using the same notation.
+Just as certain forms like @code{a[i]} can be lvalues in C, there
+is a set of forms that can be generalized variables in Lisp.
+
+The @code{setf} macro is the most basic way to operate on generalized
+variables.  The @code{setf} form is like @code{setq}, except that it
+accepts arbitrary place forms on the left side rather than just
+symbols.  For example, @code{(setf (car a) b)} sets the car of
+@code{a} to @code{b}, doing the same operation as @code{(setcar a b)},
+but without having to remember two separate functions for setting and
+accessing every type of place.
+
+@defmac setf [place form]@dots{}
+This macro evaluates @var{form} and stores it in @var{place}, which
+must be a valid generalized variable form.  If there are several
+@var{place} and @var{form} pairs, the assignments are done sequentially
+just as with @code{setq}.  @code{setf} returns the value of the last
+@var{form}.
+@end defmac
+
+The following Lisp forms will work as generalized variables, and
+so may appear in the @var{place} argument of @code{setf}:
+
+@itemize
+@item
+A symbol naming a variable.  In other words, @code{(setf x y)} is
+exactly equivalent to @code{(setq x y)}, and @code{setq} itself is
+strictly speaking redundant given that @code{setf} exists.  Many
+programmers continue to prefer @code{setq} for setting simple
+variables, though, purely for stylistic or historical reasons.
+The macro @code{(setf x y)} actually expands to @code{(setq x y)},
+so there is no performance penalty for using it in compiled code.
+
+@item
+A call to any of the following standard Lisp functions:
+
+@smallexample
+car            cdr            nth            nthcdr
+caar           cadr           cdar           cddr
+aref           elt            get            gethash
+symbol-function        symbol-value          symbol-plist
+@end smallexample
+
+@item
+The following Emacs-specific functions are also @code{setf}-able:
+
+@smallexample
+default-value                 process-get
+frame-parameter               process-sentinel
+terminal-parameter            window-buffer
+keymap-parent                 window-display-table
+match-data                    window-dedicated-p
+overlay-get                   window-hscroll
+overlay-start                 window-parameter
+overlay-end                   window-point
+process-buffer                window-start
+process-filter
+@end smallexample
+@end itemize
+
+@noindent
+Using any forms other than these in the @var{place} argument to
+@code{setf} will signal an error.
+
+@c And for cl-lib's cl-getf.
+Note that for @code{nthcdr}, the list argument of the function must
+itself be a valid @var{place} form.  For example, @code{(setf (nthcdr
+0 foo) 7)} will set @code{foo} itself to 7.
+@c The use of @code{nthcdr} as a @var{place} form is an extension
+@c to standard Common Lisp.
+
+@c FIXME I don't think is a particularly good way to do it,
+@c but these macros are introduced before gvs are.
+The macros @code{push} (@pxref{List Variables}) and @code{pop}
+(@pxref{List Elements}) can manipulate generalized variables,
+not just lists.  @code{(pop @var{place})} removes and returns the first
+element of the list stored in @var{place}.  It is analogous to
+@code{(prog1 (car @var{place}) (setf @var{place} (cdr @var{place})))},
+except that it takes care to evaluate all subforms only once.
+@code{(push @var{x} @var{place})} inserts @var{x} at the front of
+the list stored in @var{place}.  It is analogous to @code{(setf
+@var{place} (cons @var{x} @var{place}))}, except for evaluation of the
+subforms.  Note that @code{push} and @code{pop} on an @code{nthcdr}
+place can be used to insert or delete at any position in a list.
+
+The @file{cl-lib} library defines various extensions for generalized
+variables, including additional @code{setf} places.
+@xref{Generalized Variables,,, cl, Common Lisp Extensions}.
diff --git a/doc/lispref/windows.texi b/doc/lispref/windows.texi
index ea48a46359c..d0e149eb165 100644
--- a/doc/lispref/windows.texi
+++ b/doc/lispref/windows.texi
@@ -76,30 +76,35 @@ within the area of the frame.  When a window is created, resized, or
 deleted, the change in window space is taken from or given to the
 adjacent windows, so that the total area of the frame is unchanged.
 
-@cindex live windows
-@cindex internal windows
-  A @dfn{live window} is one that is actually displaying a buffer in a
-frame.  Such a window can be @dfn{deleted}, i.e. removed from the
-frame (@pxref{Deleting Windows}); then it is no longer live, but the
-Lisp object representing it might be still referenced from other Lisp
-objects.  A deleted window may be brought back to life by restoring a
-saved window configuration (@pxref{Window Configurations}).
-
 @defun windowp object
 This function returns @code{t} if @var{object} is a window (whether or
-not it is live).  Otherwise, it returns @code{nil}.
+not it displays a buffer).  Otherwise, it returns @code{nil}.
 @end defun
 
+@cindex live windows
+A @dfn{live window} is one that is actually displaying a buffer in a
+frame.
+
 @defun window-live-p object
 This function returns @code{t} if @var{object} is a live window and
 @code{nil} otherwise.  A live window is one that displays a buffer.
 @end defun
 
-  The windows in each frame are organized into a @dfn{window tree}.
-@xref{Windows and Frames}.  The leaf nodes of each window tree are
-live windows---the ones actually displaying buffers.  The internal
-nodes of the window tree are internal windows, which are not live.
-You can distinguish internal windows from deleted windows with
+@cindex internal windows
+The windows in each frame are organized into a @dfn{window tree}.
+@xref{Windows and Frames}.  The leaf nodes of each window tree are live
+windows---the ones actually displaying buffers.  The internal nodes of
+the window tree are @dfn{internal windows}, which are not live.
+
+@cindex valid windows
+   A @dfn{valid window} is one that is either live or internal.  A valid
+window can be @dfn{deleted}, i.e. removed from its frame
+(@pxref{Deleting Windows}); then it is no longer valid, but the Lisp
+object representing it might be still referenced from other Lisp
+objects.  A deleted window may be made valid again by restoring a saved
+window configuration (@pxref{Window Configurations}).
+
+   You can distinguish valid windows from deleted windows with
 @code{window-valid-p}.
 
 @defun window-valid-p object
@@ -1317,31 +1322,37 @@ meaning as for @code{next-window}.
 criterion, without selecting it:
 
 @cindex least recently used window
-@defun get-lru-window &optional all-frames dedicated
+@defun get-lru-window &optional all-frames dedicated not-selected
 This function returns a live window which is heuristically the ``least
 recently used'' window.  The optional argument @var{all-frames} has
 the same meaning as in @code{next-window}.
 
 If any full-width windows are present, only those windows are
-considered.  The selected window is never returned, unless it is the
-only candidate.  A minibuffer window is never a candidate.  A
-dedicated window (@pxref{Dedicated Windows}) is never a candidate
-unless the optional argument @var{dedicated} is non-@code{nil}.
+considered.  A minibuffer window is never a candidate.  A dedicated
+window (@pxref{Dedicated Windows}) is never a candidate unless the
+optional argument @var{dedicated} is non-@code{nil}.  The selected
+window is never returned, unless it is the only candidate.  However, if
+the optional argument @var{not-selected} is non-@code{nil}, this
+function returns @code{nil} in that case.
 @end defun
 
 @cindex largest window
-@defun get-largest-window &optional all-frames dedicated
+@defun get-largest-window &optional all-frames dedicated not-selected
 This function returns the window with the largest area (height times
-width).  A minibuffer window is never a candidate.  A dedicated window
+width).  The optional argument @var{all-frames} specifies the windows to
+search, and has the same meaning as in @code{next-window}.
+
+A minibuffer window is never a candidate.  A dedicated window
 (@pxref{Dedicated Windows}) is never a candidate unless the optional
-argument @var{dedicated} is non-@code{nil}.
+argument @var{dedicated} is non-@code{nil}.  The selected window is not
+a candidate if the optional argument @var{not-selected} is
+non-@code{nil}.  If the optional argument @var{not-selected} is
+non-@code{nil} and the selected window is the only candidate, this
+function returns @code{nil}.
 
 If there are two candidate windows of the same size, this function
 prefers the one that comes first in the cyclic ordering of windows,
 starting from the selected window.
-
-The optional argument @var{all-frames} specifies the windows to
-search, and has the same meaning as in @code{next-window}.
 @end defun
 
 @cindex window that satisfies a predicate
@@ -1359,6 +1370,26 @@ windows to search, and have the same meanings as in
 @code{next-window}.
 @end defun
 
+@cindex window in direction
+@defun window-in-direction direction &optional window ignore
+This function returns the nearest window in direction @var{direction} as
+seen from the position of @code{window-point} in window @var{window}.
+The argument @var{direction} must be one of @code{above}, @code{below},
+@code{left} or @code{right}.  The optional argument @var{window} must
+denote a live window and defaults to the selected one.
+
+This function does not return a window whose @code{no-other-window}
+parameter is non-@code{nil}.  If the nearest window's
+@code{no-other-window} parameter is non-@code{nil}, this function tries
+to find another window in the indicated direction whose
+@code{no-other-window} parameter is @code{nil}.  If the optional
+argument @var{ignore} is non-@code{nil}, a window may be returned even
+if its @code{no-other-window} parameter is non-@code{nil}.
+
+If it doesn't find a suitable window, this function returns @code{nil}.
+@end defun
+
+
 @node Buffers and Windows
 @section Buffers and Windows
 @cindex examining windows
@@ -1632,11 +1663,6 @@ The variable @code{display-buffer-overriding-action}.
 The user option @code{display-buffer-alist}.
 
 @item
-A special action for handling @code{special-display-buffer-names} and
-@code{special-display-regexps}, if either of those variables is
-non-@code{nil}.  @xref{Choosing Window Options}.
-
-@item
 The @var{action} argument.
 
 @item
@@ -1864,91 +1890,6 @@ Parameters}), which is used by the default function in
 @code{nil}.
 @end defopt
 
-@defopt special-display-buffer-names
-A list of buffer names identifying buffers that should be displayed
-specially.  If the name of @var{buffer-or-name} is in this list,
-@code{display-buffer} handles the buffer specially.  By default, special
-display means to give the buffer a dedicated frame.
-
-If an element is a list, instead of a string, then the @sc{car} of that
-list is the buffer name, and the rest of that list says how to create
-the frame.  There are two possibilities for the rest of that list (its
-@sc{cdr}): It can be an alist, specifying frame parameters, or it can
-contain a function and arguments to give to it.  (The function's first
-argument is always the buffer to be displayed; the arguments from the
-list come after that.)
-
-For example:
-
-@example
-(("myfile" (minibuffer) (menu-bar-lines . 0)))
-@end example
-
-@noindent
-specifies to display a buffer named @samp{myfile} in a dedicated frame
-with specified @code{minibuffer} and @code{menu-bar-lines} parameters.
-
-The list of frame parameters can also use the phony frame parameters
-@code{same-frame} and @code{same-window}.  If the specified frame
-parameters include @code{(same-window . @var{value})} and @var{value}
-is non-@code{nil}, that means to display the buffer in the current
-selected window.  Otherwise, if they include @code{(same-frame .
-@var{value})} and @var{value} is non-@code{nil}, that means to display
-the buffer in a new window in the currently selected frame.
-@end defopt
-
-@defopt special-display-regexps
-A list of regular expressions specifying buffers that should be
-displayed specially.  If the buffer's name matches any of the regular
-expressions in this list, @code{display-buffer} handles the buffer
-specially.  By default, special display means to give the buffer a
-dedicated frame.
-
-If an element is a list, instead of a string, then the @sc{car} of the
-list is the regular expression, and the rest of the list says how to
-create the frame.  See @code{special-display-buffer-names} above.
-@end defopt
-
-@defun special-display-p buffer-name
-This function returns non-@code{nil} if displaying a buffer
-named @var{buffer-name} with @code{display-buffer} would
-create a special frame.  The value is @code{t} if it would
-use the default frame parameters, or else the specified list
-of frame parameters.
-@end defun
-
-@defopt special-display-function
-This variable holds the function to call to display a buffer specially.
-It receives the buffer as an argument, and should return the window in
-which it is displayed.  The default value of this variable is
-@code{special-display-popup-frame}, see below.
-@end defopt
-
-@defun special-display-popup-frame buffer &optional args
-This function tries to make @var{buffer} visible in a frame of its own.
-If @var{buffer} is already displayed in some window, it makes that
-window's frame visible and raises it.  Otherwise, it creates a frame
-that is dedicated to @var{buffer}.  The return value is the window used
-to display @var{buffer}.
-
-If @var{args} is an alist, it specifies frame parameters for the new
-frame.  If @var{args} is a list whose @sc{car} is a symbol, then
-@code{(car @var{args})} is a function to actually create and
-set up the frame; it is called with @var{buffer} as first argument, and
-@code{(cdr @var{args})} as additional arguments.
-
-This function always uses an existing window displaying @var{buffer},
-whether or not it is in a frame of its own; but if you set up the above
-variables in your init file, before @var{buffer} was created, then
-presumably the window was previously made by this function.
-@end defun
-
-@defopt special-display-frame-alist
-@anchor{Definition of special-display-frame-alist}
-This variable holds frame parameters for
-@code{special-display-popup-frame} to use when it creates a frame.
-@end defopt
-
 @defopt same-window-buffer-names
 A list of buffer names for buffers that should be displayed in the
 selected window.  If a buffer's name is in this list,
@@ -1969,19 +1910,6 @@ named @var{buffer-name} with @code{display-buffer} would
 put it in the selected window.
 @end defun
 
-@c Emacs 19 feature
-@defopt display-buffer-function
-This variable is the most flexible way to customize the behavior of
-@code{display-buffer}.  If it is non-@code{nil}, it should be a function
-that @code{display-buffer} calls to do the work.  The function should
-accept two arguments, the first two arguments that @code{display-buffer}
-received.  It should choose or create a window, display the specified
-buffer in it, and then return the window.
-
-This variable takes precedence over all the other options described
-above.
-@end defopt
-
 @node Window History
 @section Window History
 @cindex window history
diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog
index cda4f272ca2..941c430ce74 100644
--- a/doc/misc/ChangeLog
+++ b/doc/misc/ChangeLog
@@ -1,3 +1,96 @@
+2012-10-30  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Modify Macros): Update for cl-letf changes.
+        (Obsolete Lexical Macros): Say a little more about letf/cl-letf.
+        (Setf Extensions): Partially restore note about cl-getf,
+        mainly moved to lispref/variables.texi.
+        (Property Lists): Fix cl-getf typos.
+        (Mapping over Sequences): Mention cl-mapc naming oddity.
+
+2012-10-29  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Organization): More details on cl-lib.el versus cl.el.
+        (Setf Extensions): Remove `apply' setf since it seems to be disabled.
+        (Customizing Setf): Move contents to "Obsolete Setf Customization".
+        (Modify Macros, Multiple Values, Other Clauses):
+        Remove mentions of obsolete features.
+        (Obsolete Setf Customization): Don't mention `apply' setf.
+
+2012-10-28  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Multiple Values, Common Lisp Compatibility):
+        More namespace updates.
+        (Obsolete Features): Copyedits.
+        (Obsolete Lexical Macros, Obsolete Setf Customization):
+        New subsections.
+
+        * cl.texi (Porting Common Lisp, Lexical Bindings):
+        Add some xrefs to the Elisp manual.
+
+        * cl.texi (Lexical Bindings): Move to appendix of obsolete features.
+        (Porting Common Lisp): Emacs Lisp can do true lexical binding now.
+        (Obsolete Features): New appendix.  Move Lexical Bindings here.
+
+2012-10-27  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi: Use defmac for macros rather than defspec.
+        (Efficiency Concerns): Related copyedit.
+
+        * cl.texi (Control Structure): Update for setf now being in core.
+        (Setf Extensions): Rename from Basic Setf.  Move much of the
+        former content to lispref/variables.texi.
+        (Modify Macros): Move pop, push details to lispref/variables.texi.
+        (Customizing Setf): Copyedits for setf etc being in core.
+        (Modify Macros, Efficiency Concerns, Porting Common Lisp):
+        Further namespaces updates.
+
+2012-10-26  Bastien Guerry  <bzg@gnu.org>
+
+        * org.texi (Installation): Update the link to Org's ELPA.  Also
+        don't mention org-install.el anymore as the replacement file
+        org-loaddefs.el is now loaded by org.el.
+
+2012-10-25  Michael Albinus  <michael.albinus@gmx.de>
+
+        * tramp.texi (Frequently Asked Questions): Mention
+        `tramp-completion-reread-directory-timeout' for performance
+        improvement.
+
+2012-10-25  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi: Don't mess with the TeX section number counter.
+        Use Texinfo recommended convention for quotes+punctuation.
+        (Overview, Sequence Functions): Rephrase for better line-breaking.
+        (Time of Evaluation, Type Predicates, Modify Macros, Function Bindings)
+        (Macro Bindings, Conditionals, Iteration, Loop Basics)
+        (Random Numbers, Mapping over Sequences, Structures)
+        (Porting Common Lisp): Further updates for cl-lib namespace.
+        (Modify Macros, Declarations, Macro Bindings, Structures):
+        Break long lines in examples.
+        (Dynamic Bindings): Update for changed progv behavior.
+        (Loop Examples, Efficiency Concerns): Markup fixes.
+        (Structures): Remove TeX margin change.
+        (Declarations): Fix typos.
+
+2012-10-24  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Overview, Multiple Values, Creating Symbols)
+        (Numerical Functions): Say less/nothing about the original cl.el.
+        (Old CL Compatibility): Remove.
+        (Assertions): Remove ignore-errors (standard Elisp for some time).
+
+        * cl.texi (Basic Setf, Macros, Declarations, Symbols, Numbers)
+        (Sequences, Lists, Structures, Assertions, Efficiency Concerns)
+        (Efficiency Concerns, Efficiency Concerns)
+        (Common Lisp Compatibility, Old CL Compatibility):
+        Further updates for cl-lib namespace.
+
+2012-10-24  Paul Eggert  <eggert@penguin.cs.ucla.edu>
+
+        Update manual for new time stamp format (Bug#12706).
+        * emacs-mime.texi (time-date): Update for new format.
+        Also, fix bogus time stamp and modernize a bit.
+
 2012-10-23  Glenn Morris  <rgm@gnu.org>
 
         * cl.texi: Include emacsver.texi.  Use Emacs version number rather
diff --git a/doc/misc/cl.texi b/doc/misc/cl.texi
index 12fd76e2e1c..8cee1cf9639 100644
--- a/doc/misc/cl.texi
+++ b/doc/misc/cl.texi
@@ -57,7 +57,7 @@ developing GNU and promoting software freedom.''
 * Overview::             Basics, usage, etc.
 * Program Structure::    Arglists, @code{cl-eval-when}, @code{defalias}.
 * Predicates::           @code{cl-typep} and @code{cl-equalp}.
-* Control Structure::    @code{setf}, @code{cl-do}, @code{cl-loop}, etc.
+* Control Structure::    @code{cl-do}, @code{cl-loop}, etc.
 * Macros::               Destructuring, @code{cl-define-compiler-macro}.
 * Declarations::         @code{cl-proclaim}, @code{cl-declare}, etc.
 * Symbols::              Property lists, @code{cl-gensym}.
@@ -65,12 +65,12 @@ developing GNU and promoting software freedom.''
 * Sequences::            Mapping, functions, searching, sorting.
 * Lists::                @code{cl-caddr}, @code{cl-sublis}, @code{cl-member}, @code{cl-assoc}, etc.
 * Structures::           @code{cl-defstruct}.
-* Assertions::           @code{cl-check-type}, @code{cl-assert}, @code{ignore-errors}.
+* Assertions::           @code{cl-check-type}, @code{cl-assert}.
 
 * Efficiency Concerns::         Hints and techniques.
 * Common Lisp Compatibility::   All known differences with Steele.
-* Old CL Compatibility::        All known differences with old cl.el.
 * Porting Common Lisp::         Hints for porting Common Lisp code.
+* Obsolete Features::           Obsolete features.
 
 * GNU Free Documentation License:: The license for this documentation.
 * Function Index::
@@ -116,19 +116,16 @@ features.
 
 @end itemize
 
-The package described here was originally written by Dave Gillespie,
-@file{daveg@@synaptics.com}, as a total rewrite of an earlier
-1986 @file{cl.el} package by Cesar Quiroz.  Most features of the
-Quiroz package were retained; any incompatibilities are
-noted in the descriptions below.  Care has been taken in this
-version to ensure that each function is defined efficiently,
-concisely, and with minimal impact on the rest of the Emacs
-environment.  Stefan Monnier added the file @file{cl-lib.el} and
-rationalized the namespace for Emacs 24.3.
+This package was originally written by Dave Gillespie,
+@file{daveg@@synaptics.com}, as a total rewrite of an earlier 1986
+@file{cl.el} package by Cesar Quiroz.  Care has been taken to ensure
+that each function is defined efficiently, concisely, and with minimal
+impact on the rest of the Emacs environment.  Stefan Monnier added the
+file @file{cl-lib.el} and rationalized the namespace for Emacs 24.3.
 
 @menu
 * Usage::                How to use the CL package.
-* Organization::         The package's five component files.
+* Organization::         The package's component files.
 * Naming Conventions::   Notes on CL function names.
 @end menu
 
@@ -185,25 +182,37 @@ All you have to do is @code{(require 'cl-lib)}, and @file{cl-lib.el}
 will take care of pulling in the other files when they are
 needed.
 
-There is another file, @file{cl.el}, which was the main entry point
-to the CL package prior to Emacs 24.3.  Nowadays, it is replaced
-by @file{cl-lib.el}.  The two provide the same features, but use
-different function names (in fact, @file{cl.el} just defines aliases
-to the @file{cl-lib.el} definitions).  In particular, the old @file{cl.el}
-does not use a clean namespace.  For this reason, Emacs has a policy
-that packages distributed with Emacs must not load @code{cl} at run time.
-(It is ok for them to load @code{cl} at @emph{compile} time, with
-@code{eval-when-compile}, and use the macros it provides.)  There is
-no such restriction on the use of @code{cl-lib}.  New code should use
-@code{cl-lib} rather than @code{cl}.  @xref{Naming Conventions}.
+There is another file, @file{cl.el}, which was the main entry point to
+the CL package prior to Emacs 24.3.  Nowadays, it is replaced by
+@file{cl-lib.el}.  The two provide the same features (in most cases),
+but use different function names (in fact, @file{cl.el} mainly just
+defines aliases to the @file{cl-lib.el} definitions).  Where
+@file{cl-lib.el} defines a function called, for example,
+@code{cl-incf}, @file{cl.el} uses the same name but without the
+@samp{cl-} prefix, e.g. @code{incf} in this example.  There are a few
+exceptions to this.  First, functions such as @code{cl-defun} where
+the unprefixed version was already used for a standard Emacs Lisp
+function.  In such cases, the @file{cl.el} version adds a @samp{*}
+suffix, e.g. @code{defun*}.  Second, there are some obsolete features
+that are only implemented in @file{cl.el}, not in @file{cl-lib.el},
+because they are replaced by other standard Emacs Lisp features.
+Finally, in a very few cases the old @file{cl.el} versions do not
+behave in exactly the same way as the @file{cl-lib.el} versions.
+@xref{Obsolete Features}.
+@c There is also cl-mapc, which was called cl-mapc even before cl-lib.el.
+@c But not autoloaded, so maybe not much used?
+
+Since the old @file{cl.el} does not use a clean namespace, Emacs has a
+policy that packages distributed with Emacs must not load @code{cl} at
+run time.  (It is ok for them to load @code{cl} at @emph{compile}
+time, with @code{eval-when-compile}, and use the macros it provides.)
+There is no such restriction on the use of @code{cl-lib}.  New code
+should use @code{cl-lib} rather than @code{cl}.
 
 There is one more file, @file{cl-compat.el}, which defines some
-routines from the older CL package that are not otherwise
-present in the new package.  This includes internal routines
-like @code{setelt} and @code{zip-lists}, deprecated features
-like @code{defkeyword}, and an emulation of the old-style
-multiple-values feature.  This file is obsolete and should not be used
-in new code.  @xref{Old CL Compatibility}.
+routines from the older Quiroz CL package that are not otherwise
+present in the new package.  This file is obsolete and should not be
+used in new code.
 
 @node Naming Conventions
 @section Naming Conventions
@@ -217,7 +226,6 @@ Internal function and variable names in the package are prefixed
 by @code{cl--}.  Here is a complete list of functions prefixed by
 @code{cl-} that were not taken from Common Lisp:
 
-@c FIXME lexical-let lexical-let*
 @example
 cl-callf         cl-callf2        cl-defsubst
 cl-floatp-safe   cl-letf          cl-letf*
@@ -260,10 +268,6 @@ and the @code{cl-eval-when} construct.
 * Time of Evaluation::   The @code{cl-eval-when} construct.
 @end menu
 
-@iftex
-@secno=1
-@end iftex
-
 @node Argument Lists
 @section Argument Lists
 
@@ -279,14 +283,14 @@ this package to implement Common Lisp argument lists seamlessly.
 Instead, this package defines alternates for several Lisp forms
 which you must use if you need Common Lisp argument lists.
 
-@defspec cl-defun name arglist body...
+@defmac cl-defun name arglist body...
 This form is identical to the regular @code{defun} form, except
 that @var{arglist} is allowed to be a full Common Lisp argument
 list.  Also, the function body is enclosed in an implicit block
 called @var{name}; @pxref{Blocks and Exits}.
-@end defspec
+@end defmac
 
-@defspec cl-defsubst name arglist body...
+@defmac cl-defsubst name arglist body...
 This is just like @code{cl-defun}, except that the function that
 is defined is automatically proclaimed @code{inline}, i.e.,
 calls to it may be expanded into in-line code by the byte compiler.
@@ -296,9 +300,9 @@ works in all versions of Emacs, and also generates somewhat more
 efficient inline expansions.  In particular, @code{cl-defsubst}
 arranges for the processing of keyword arguments, default values,
 etc., to be done at compile-time whenever possible.
-@end defspec
+@end defmac
 
-@defspec cl-defmacro name arglist body...
+@defmac cl-defmacro name arglist body...
 This is identical to the regular @code{defmacro} form,
 except that @var{arglist} is allowed to be a full Common Lisp
 argument list.  The @code{&environment} keyword is supported as
@@ -307,13 +311,13 @@ within destructured lists (see below); top-level @code{&whole}
 cannot be implemented with the current Emacs Lisp interpreter.
 The macro expander body is enclosed in an implicit block called
 @var{name}.
-@end defspec
+@end defmac
 
-@defspec cl-function symbol-or-lambda
+@defmac cl-function symbol-or-lambda
 This is identical to the regular @code{function} form,
 except that if the argument is a @code{lambda} form then that
 form may use a full Common Lisp argument list.
-@end defspec
+@end defmac
 
 Also, all forms (such as @code{cl-flet} and @code{cl-labels}) defined
 in this package that include @var{arglist}s in their syntax allow
@@ -502,7 +506,7 @@ For example, the compiler effectively evaluates @code{defmacro} forms
 at compile-time so that later parts of the file can refer to the
 macros that are defined.
 
-@defspec cl-eval-when (situations...) forms...
+@defmac cl-eval-when (situations...) forms...
 This form controls when the body @var{forms} are evaluated.
 The @var{situations} list may contain any set of the symbols
 @code{compile}, @code{load}, and @code{eval} (or their long-winded
@@ -572,19 +576,19 @@ last four would have been equivalent to the corresponding @code{setq}s.
 Note that @code{(cl-eval-when (load eval) @dots{})} is equivalent
 to @code{(progn @dots{})} in all contexts.  The compiler treats
 certain top-level forms, like @code{defmacro} (sort-of) and
-@code{require}, as if they were wrapped in @code{(eval-when
+@code{require}, as if they were wrapped in @code{(cl-eval-when
 (compile load eval) @dots{})}.
-@end defspec
+@end defmac
 
 Emacs includes two special forms related to @code{cl-eval-when}.
 One of these, @code{eval-when-compile}, is not quite equivalent to
-any @code{eval-when} construct and is described below.
+any @code{cl-eval-when} construct and is described below.
 
 The other form, @code{(eval-and-compile @dots{})}, is exactly
-equivalent to @samp{(eval-when (compile load eval) @dots{})} and
+equivalent to @samp{(cl-eval-when (compile load eval) @dots{})} and
 so is not itself defined by this package.
 
-@defspec eval-when-compile forms...
+@defmac eval-when-compile forms...
 The @var{forms} are evaluated at compile-time; at execution time,
 this form acts like a quoted constant of the resulting value.  Used
 at top-level, @code{eval-when-compile} is just like @samp{eval-when
@@ -593,9 +597,9 @@ allows code to be evaluated once at compile-time for efficiency
 or other reasons.
 
 This form is similar to the @samp{#.} syntax of true Common Lisp.
-@end defspec
+@end defmac
 
-@defspec cl-load-time-value form
+@defmac cl-load-time-value form
 The @var{form} is evaluated at load-time; at execution time,
 this form acts like a quoted constant of the resulting value.
 
@@ -636,7 +640,7 @@ Byte-compiled, the above defun will result in the following code
           ", and loaded on: "
           --temp--))
 @end example
-@end defspec
+@end defmac
 
 @node Predicates
 @chapter Predicates
@@ -653,10 +657,6 @@ facts are true or false.
 @node Type Predicates
 @section Type Predicates
 
-@noindent
-The @code{CL} package defines a version of the Common Lisp @code{typep}
-predicate.
-
 @defun cl-typep object type
 Check if @var{object} is of type @var{type}, where @var{type} is a
 (quoted) type name of the sort used by Common Lisp.  For example,
@@ -737,7 +737,7 @@ related to @code{cl-typep}.
 @defun cl-coerce object type
 This function attempts to convert @var{object} to the specified
 @var{type}.  If @var{object} is already of that type as determined by
-@code{typep}, it is simply returned.  Otherwise, certain types of
+@code{cl-typep}, it is simply returned.  Otherwise, certain types of
 conversions will be made:  If @var{type} is any sequence type
 (@code{string}, @code{list}, etc.) then @var{object} will be
 converted to that type if possible.  If @var{type} is
@@ -748,7 +748,7 @@ floats.  In all other circumstances, @code{cl-coerce} signals an
 error.
 @end defun
 
-@defspec cl-deftype name arglist forms...
+@defmac cl-deftype name arglist forms...
 This macro defines a new type called @var{name}.  It is similar
 to @code{defmacro} in many ways; when @var{name} is encountered
 as a type name, the body @var{forms} are evaluated and should
@@ -776,7 +776,7 @@ unsigned-byte  @equiv{}  (integer 0 *)
 The last example shows how the Common Lisp @code{unsigned-byte}
 type specifier could be implemented if desired; this package does
 not implement @code{unsigned-byte} by default.
-@end defspec
+@end defmac
 
 The @code{cl-typecase} and @code{cl-check-type} macros also use type
 names.  @xref{Conditionals}.  @xref{Assertions}.  The @code{cl-map},
@@ -816,23 +816,21 @@ In Emacs, use @code{memq} (or @code{cl-member}) and @code{assq} (or
 
 @noindent
 The features described in the following sections implement
-various advanced control structures, including the powerful
-@c FIXME setf is now in gv.el, not cl.
-@code{setf} facility and a number of looping and conditional
+various advanced control structures, including extensions to the
+standard @code{setf} facility, and a number of looping and conditional
 constructs.
 
-@c FIXME setf, push are standard now.
-@c lexical-let is obsolete; flet is not cl-flet.
-@c values is not cl-values.
+@c FIXME
+@c flet is not cl-flet.
 @menu
 * Assignment::             The @code{cl-psetq} form.
-* Generalized Variables::  @code{setf}, @code{cl-incf}, @code{push}, etc.
-* Variable Bindings::      @code{cl-progv}, @code{lexical-let}, @code{flet}, @code{cl-macrolet}.
+* Generalized Variables::  Extensions to generalized variables.
+* Variable Bindings::      @code{cl-progv}, @code{flet}, @code{cl-macrolet}.
 * Conditionals::           @code{cl-case}, @code{cl-typecase}.
 * Blocks and Exits::       @code{cl-block}, @code{cl-return}, @code{cl-return-from}.
 * Iteration::              @code{cl-do}, @code{cl-dotimes}, @code{cl-dolist}, @code{cl-do-symbols}.
 * Loop Facility::          The Common Lisp @code{cl-loop} macro.
-* Multiple Values::        @code{values}, @code{cl-multiple-value-bind}, etc.
+* Multiple Values::        @code{cl-values}, @code{cl-multiple-value-bind}, etc.
 @end menu
 
 @node Assignment
@@ -842,7 +840,7 @@ constructs.
 The @code{cl-psetq} form is just like @code{setq}, except that multiple
 assignments are done in parallel rather than sequentially.
 
-@defspec cl-psetq [symbol form]@dots{}
+@defmac cl-psetq [symbol form]@dots{}
 This special form (actually a macro) is used to assign to several
 variables simultaneously.  Given only one @var{symbol} and @var{form},
 it has the same effect as @code{setq}.  Given several @var{symbol}
@@ -870,132 +868,79 @@ provides an even more convenient way to swap two variables;
 @pxref{Modify Macros}.)
 
 @code{cl-psetq} always returns @code{nil}.
-@end defspec
+@end defmac
 
-@c FIXME now in gv.el.
 @node Generalized Variables
 @section Generalized Variables
 
-@noindent
-A ``generalized variable'' or ``place form'' is one of the many places
-in Lisp memory where values can be stored.  The simplest place form is
-a regular Lisp variable.  But the cars and cdrs of lists, elements
-of arrays, properties of symbols, and many other locations are also
-places where Lisp values are stored.
-
-The @code{setf} form is like @code{setq}, except that it accepts
-arbitrary place forms on the left side rather than just
-symbols.  For example, @code{(setf (car a) b)} sets the car of
-@code{a} to @code{b}, doing the same operation as @code{(setcar a b)}
-but without having to remember two separate functions for setting
-and accessing every type of place.
-
-Generalized variables are analogous to ``lvalues'' in the C
-language, where @samp{x = a[i]} gets an element from an array
-and @samp{a[i] = x} stores an element using the same notation.
-Just as certain forms like @code{a[i]} can be lvalues in C, there
-is a set of forms that can be generalized variables in Lisp.
+A @dfn{generalized variable} or @dfn{place form} is one of the many
+places in Lisp memory where values can be stored.  The simplest place
+form is a regular Lisp variable.  But the cars and cdrs of lists,
+elements of arrays, properties of symbols, and many other locations
+are also places where Lisp values are stored.  For basic information,
+@pxref{Generalized Variables,,,elisp,GNU Emacs Lisp Reference Manual}.
+This package provides several additional features related to
+generalized variables.
 
 @menu
-* Basic Setf::         @code{setf} and place forms.
-* Modify Macros::      @code{cl-incf}, @code{push}, @code{cl-rotatef}, @code{letf}, @code{cl-callf}, etc.
-* Customizing Setf::   @code{define-modify-macro}, @code{defsetf}, @code{define-setf-method}.
+* Setf Extensions::    Additional @code{setf} places.
+* Modify Macros::      @code{cl-incf}, @code{cl-rotatef}, @code{cl-letf}, @code{cl-callf}, etc.
 @end menu
 
-@node Basic Setf
-@subsection Basic Setf
-
-@noindent
-The @code{setf} macro is the most basic way to operate on generalized
-variables.
-
-@defspec setf [place form]@dots{}
-This macro evaluates @var{form} and stores it in @var{place}, which
-must be a valid generalized variable form.  If there are several
-@var{place} and @var{form} pairs, the assignments are done sequentially
-just as with @code{setq}.  @code{setf} returns the value of the last
-@var{form}.
-
-The following Lisp forms will work as generalized variables, and
-so may appear in the @var{place} argument of @code{setf}:
+@node Setf Extensions
+@subsection Setf Extensions
 
-@itemize @bullet
-@item
-A symbol naming a variable.  In other words, @code{(setf x y)} is
-exactly equivalent to @code{(setq x y)}, and @code{setq} itself is
-strictly speaking redundant now that @code{setf} exists.  Many
-programmers continue to prefer @code{setq} for setting simple
-variables, though, purely for stylistic or historical reasons.
-The macro @code{(setf x y)} actually expands to @code{(setq x y)},
-so there is no performance penalty for using it in compiled code.
+Several standard (e.g. @code{car}) and Emacs-specific
+(e.g. @code{window-point}) Lisp functions are @code{setf}-able by default.
+This package defines @code{setf} handlers for several additional functions:
 
+@itemize
 @item
-A call to any of the following Lisp functions:
-
+Functions from @code{CL} itself:
 @smallexample
-car                 cdr                 caar .. cddddr
-nth                 rest                first .. tenth
-aref                elt                 nthcdr
-symbol-function     symbol-value        symbol-plist
-get                 get*                getf
-gethash             subseq
+cl-caaar .. cl-cddddr         cl-first .. cl-tenth
+cl-rest     cl-get            cl-getf     cl-subseq
 @end smallexample
 
 @noindent
-Note that for @code{nthcdr} and @code{getf}, the list argument
-of the function must itself be a valid @var{place} form.  For
-example, @code{(setf (nthcdr 0 foo) 7)} will set @code{foo} itself
-to 7.  Note that @code{push} and @code{pop} on an @code{nthcdr}
-place can be used to insert or delete at any position in a list.
-The use of @code{nthcdr} as a @var{place} form is an extension
-to standard Common Lisp.
+Note that for @code{cl-getf} (as for @code{nthcdr}), the list argument
+of the function must itself be a valid @var{place} form.
 
 @item
-The following Emacs-specific functions are also @code{setf}-able.
-
+General Emacs Lisp functions:
 @smallexample
-buffer-file-name                  marker-position
-buffer-modified-p                 match-data
-buffer-name                       mouse-position
-buffer-string                     overlay-end
-buffer-substring                  overlay-get
-current-buffer                    overlay-start
-current-case-table                point
-current-column                    point-marker
-current-global-map                point-max
-current-input-mode                point-min
-current-local-map                 process-buffer
-current-window-configuration      process-filter
-default-file-modes                process-sentinel
-default-value                     read-mouse-position
-documentation-property            screen-height
-extent-data                       screen-menubar
-extent-end-position               screen-width
-extent-start-position             selected-window
-face-background                   selected-screen
-face-background-pixmap            selected-frame
-face-font                         standard-case-table
-face-foreground                   syntax-table
-face-underline-p                  window-buffer
-file-modes                        window-dedicated-p
-frame-height                      window-display-table
-frame-parameters                  window-height
-frame-visible-p                   window-hscroll
-frame-width                       window-point
-get-register                      window-start
-getenv                            window-width
-global-key-binding                x-get-secondary-selection
-keymap-parent                     x-get-selection
-local-key-binding                 
-mark                              
-mark-marker
+buffer-file-name                   getenv
+buffer-modified-p                  global-key-binding
+buffer-name                        local-key-binding
+buffer-string                      mark
+buffer-substring                   mark-marker
+current-buffer                     marker-position
+current-case-table                 mouse-position
+current-column                     point
+current-global-map                 point-marker
+current-input-mode                 point-max
+current-local-map                  point-min
+current-window-configuration       read-mouse-position
+default-file-modes                 screen-height
+documentation-property             screen-width
+face-background                    selected-window
+face-background-pixmap             selected-screen
+face-font                          selected-frame
+face-foreground                    standard-case-table
+face-underline-p                   syntax-table
+file-modes                         visited-file-modtime
+frame-height                       window-height
+frame-parameters                   window-width
+frame-visible-p                    x-get-secondary-selection
+frame-width                        x-get-selection
+get-register
 @end smallexample
 
 Most of these have directly corresponding ``set'' functions, like
 @code{use-local-map} for @code{current-local-map}, or @code{goto-char}
 for @code{point}.  A few, like @code{point-min}, expand to longer
-sequences of code when they are @code{setf}'d (@code{(narrow-to-region
-x (point-max))} in this case).
+sequences of code when they are used with @code{setf}
+(@code{(narrow-to-region x (point-max))} in this case).
 
 @item
 A call of the form @code{(substring @var{subplace} @var{n} [@var{m}])},
@@ -1022,6 +967,10 @@ a
 The generalized variable @code{buffer-substring}, listed above,
 also works in this way by replacing a portion of the current buffer.
 
+@c FIXME? Also `eq'? (see cl-lib.el)
+
+@c Currently commented out in cl.el.
+@ignore
 @item
 A call of the form @code{(apply '@var{func} @dots{})} or
 @code{(apply (function @var{func}) @dots{})}, where @var{func}
@@ -1030,6 +979,8 @@ in the sense described in Steele's book; since none of the standard
 Emacs place functions are suitable in this sense, this feature is
 only interesting when used with places you define yourself with
 @code{define-setf-method} or the long form of @code{defsetf}.
+@xref{Obsolete Setf Customization}.
+@end ignore
 
 @item
 A macro call, in which case the macro is expanded and @code{setf}
@@ -1037,21 +988,21 @@ is applied to the resulting form.
 
 @item
 Any form for which a @code{defsetf} or @code{define-setf-method}
-has been made.
+has been made.  @xref{Obsolete Setf Customization}.
 @end itemize
 
-Using any forms other than these in the @var{place} argument to
-@code{setf} will signal an error.
-
+@c FIXME should this be in lispref?  It seems self-evident.
+@c Contrast with the cl-incf example later on.
+@c Here it really only serves as a constrast to wrong-order.
 The @code{setf} macro takes care to evaluate all subforms in
 the proper left-to-right order; for example,
 
 @example
-(setf (aref vec (incf i)) i)
+(setf (aref vec (cl-incf i)) i)
 @end example
 
 @noindent
-looks like it will evaluate @code{(incf i)} exactly once, before the
+looks like it will evaluate @code{(cl-incf i)} exactly once, before the
 following access to @code{i}; the @code{setf} expander will insert
 temporary variables as necessary to ensure that it does in fact work
 this way no matter what setf-method is defined for @code{aref}.
@@ -1071,35 +1022,34 @@ will be preserved.  Adapting an example from Steele, given
 the form @code{(setf (wrong-order @var{a} @var{b}) 17)} will
 evaluate @var{b} first, then @var{a}, just as in an actual call
 to @code{wrong-order}.
-@end defspec
 
 @node Modify Macros
 @subsection Modify Macros
 
 @noindent
-This package defines a number of other macros besides @code{setf}
-that operate on generalized variables.  Many are interesting and
-useful even when the @var{place} is just a variable name.
+This package defines a number of macros that operate on generalized
+variables.  Many are interesting and useful even when the @var{place}
+is just a variable name.
 
-@defspec psetf [place form]@dots{}
+@defmac cl-psetf [place form]@dots{}
 This macro is to @code{setf} what @code{cl-psetq} is to @code{setq}:
 When several @var{place}s and @var{form}s are involved, the
 assignments take place in parallel rather than sequentially.
 Specifically, all subforms are evaluated from left to right, then
 all the assignments are done (in an undefined order).
-@end defspec
+@end defmac
 
-@defspec incf place &optional x
+@defmac cl-incf place &optional x
 This macro increments the number stored in @var{place} by one, or
 by @var{x} if specified.  The incremented value is returned.  For
-example, @code{(incf i)} is equivalent to @code{(setq i (1+ i))}, and
-@code{(incf (car x) 2)} is equivalent to @code{(setcar x (+ (car x) 2))}.
+example, @code{(cl-incf i)} is equivalent to @code{(setq i (1+ i))}, and
+@code{(cl-incf (car x) 2)} is equivalent to @code{(setcar x (+ (car x) 2))}.
 
-Once again, care is taken to preserve the ``apparent'' order of
-evaluation.  For example,
+As with @code{setf}, care is taken to preserve the ``apparent'' order
+of evaluation.  For example,
 
 @example
-(incf (aref vec (incf i)))
+(cl-incf (aref vec (cl-incf i)))
 @end example
 
 @noindent
@@ -1109,93 +1059,81 @@ does, which means the above form is @emph{not} equivalent to the
 ``obvious'' expansion,
 
 @example
-(setf (aref vec (incf i)) (1+ (aref vec (incf i))))   ; Wrong!
+(setf (aref vec (cl-incf i))
+      (1+ (aref vec (cl-incf i))))   ; wrong!
 @end example
 
 @noindent
 but rather to something more like
 
 @example
-(let ((temp (incf i)))
+(let ((temp (cl-incf i)))
   (setf (aref vec temp) (1+ (aref vec temp))))
 @end example
 
 @noindent
-Again, all of this is taken care of automatically by @code{incf} and
+Again, all of this is taken care of automatically by @code{cl-incf} and
 the other generalized-variable macros.
 
-As a more Emacs-specific example of @code{incf}, the expression
-@code{(incf (point) @var{n})} is essentially equivalent to
+As a more Emacs-specific example of @code{cl-incf}, the expression
+@code{(cl-incf (point) @var{n})} is essentially equivalent to
 @code{(forward-char @var{n})}.
-@end defspec
+@end defmac
 
-@defspec decf place &optional x
+@defmac cl-decf place &optional x
 This macro decrements the number stored in @var{place} by one, or
 by @var{x} if specified.
-@end defspec
-
-@defspec pop place
-This macro removes and returns the first element of the list stored
-in @var{place}.  It is analogous to @code{(prog1 (car @var{place})
-(setf @var{place} (cdr @var{place})))}, except that it takes care
-to evaluate all subforms only once.
-@end defspec
+@end defmac
 
-@defspec push x place
-This macro inserts @var{x} at the front of the list stored in
-@var{place}.  It is analogous to @code{(setf @var{place} (cons
-@var{x} @var{place}))}, except for evaluation of the subforms.
-@end defspec
-
-@defspec pushnew x place @t{&key :test :test-not :key}
+@defmac cl-pushnew x place @t{&key :test :test-not :key}
 This macro inserts @var{x} at the front of the list stored in
 @var{place}, but only if @var{x} was not @code{eql} to any
 existing element of the list.  The optional keyword arguments
-are interpreted in the same way as for @code{adjoin}.
+are interpreted in the same way as for @code{cl-adjoin}.
 @xref{Lists as Sets}.
-@end defspec
+@end defmac
 
-@defspec shiftf place@dots{} newvalue
+@defmac cl-shiftf place@dots{} newvalue
 This macro shifts the @var{place}s left by one, shifting in the
 value of @var{newvalue} (which may be any Lisp expression, not just
 a generalized variable), and returning the value shifted out of
-the first @var{place}.  Thus, @code{(shiftf @var{a} @var{b} @var{c}
+the first @var{place}.  Thus, @code{(cl-shiftf @var{a} @var{b} @var{c}
 @var{d})} is equivalent to
 
 @example
 (prog1
     @var{a}
-  (psetf @var{a} @var{b}
-         @var{b} @var{c}
-         @var{c} @var{d}))
+  (cl-psetf @var{a} @var{b}
+            @var{b} @var{c}
+            @var{c} @var{d}))
 @end example
 
 @noindent
 except that the subforms of @var{a}, @var{b}, and @var{c} are actually
 evaluated only once each and in the apparent order.
-@end defspec
+@end defmac
 
-@defspec rotatef place@dots{}
+@defmac cl-rotatef place@dots{}
 This macro rotates the @var{place}s left by one in circular fashion.
-Thus, @code{(rotatef @var{a} @var{b} @var{c} @var{d})} is equivalent to
+Thus, @code{(cl-rotatef @var{a} @var{b} @var{c} @var{d})} is equivalent to
 
 @example
-(psetf @var{a} @var{b}
-       @var{b} @var{c}
-       @var{c} @var{d}
-       @var{d} @var{a})
+(cl-psetf @var{a} @var{b}
+          @var{b} @var{c}
+          @var{c} @var{d}
+          @var{d} @var{a})
 @end example
 
 @noindent
-except for the evaluation of subforms.  @code{rotatef} always
-returns @code{nil}.  Note that @code{(rotatef @var{a} @var{b})}
+except for the evaluation of subforms.  @code{cl-rotatef} always
+returns @code{nil}.  Note that @code{(cl-rotatef @var{a} @var{b})}
 conveniently exchanges @var{a} and @var{b}.
-@end defspec
+@end defmac
 
 The following macros were invented for this package; they have no
 analogues in Common Lisp.
 
-@defspec letf (bindings@dots{}) forms@dots{}
+@defmac cl-letf (bindings@dots{}) forms@dots{}
 This macro is analogous to @code{let}, but for generalized variables
 rather than just symbols.  Each @var{binding} should be of the form
 @code{(@var{place} @var{value})}; the original contents of the
@@ -1208,294 +1146,91 @@ error.
 For example,
 
 @example
-(letf (((point) (point-min))
-       (a 17))
-  ...)
+(cl-letf (((point) (point-min))
+          (a 17))
+     ...)
 @end example
 
 @noindent
-moves ``point'' in the current buffer to the beginning of the buffer,
+moves point in the current buffer to the beginning of the buffer,
 and also binds @code{a} to 17 (as if by a normal @code{let}, since
 @code{a} is just a regular variable).  After the body exits, @code{a}
 is set back to its original value and point is moved back to its
 original position.
 
-Note that @code{letf} on @code{(point)} is not quite like a
+Note that @code{cl-letf} on @code{(point)} is not quite like a
 @code{save-excursion}, as the latter effectively saves a marker
 which tracks insertions and deletions in the buffer.  Actually,
-a @code{letf} of @code{(point-marker)} is much closer to this
+a @code{cl-letf} of @code{(point-marker)} is much closer to this
 behavior.  (@code{point} and @code{point-marker} are equivalent
 as @code{setf} places; each will accept either an integer or a
 marker as the stored value.)
 
 Since generalized variables look like lists, @code{let}'s shorthand
 of using @samp{foo} for @samp{(foo nil)} as a @var{binding} would
-be ambiguous in @code{letf} and is not allowed.
+be ambiguous in @code{cl-letf} and is not allowed.
 
 However, a @var{binding} specifier may be a one-element list
 @samp{(@var{place})}, which is similar to @samp{(@var{place}
 @var{place})}.  In other words, the @var{place} is not disturbed
-on entry to the body, and the only effect of the @code{letf} is
-to restore the original value of @var{place} afterwards.  (The
-redundant access-and-store suggested by the @code{(@var{place}
+on entry to the body, and the only effect of the @code{cl-letf} is
+to restore the original value of @var{place} afterwards.
+@c I suspect this may no longer be true; either way it's
+@c implementation detail and so not essential to document.
+@ignore
+(The redundant access-and-store suggested by the @code{(@var{place}
 @var{place})} example does not actually occur.)
-
-In most cases, the @var{place} must have a well-defined value on
-entry to the @code{letf} form.  The only exceptions are plain
-variables and calls to @code{symbol-value} and @code{symbol-function}.
-If the symbol is not bound on entry, it is simply made unbound by
-@code{makunbound} or @code{fmakunbound} on exit.
-@end defspec
-
-@defspec letf* (bindings@dots{}) forms@dots{}
-This macro is to @code{letf} what @code{let*} is to @code{let}:
+@end ignore
+
+Note that in this case, and in fact almost every case, @var{place}
+must have a well-defined value outside the @code{cl-letf} body.
+There is essentially only one exception to this, which is @var{place}
+a plain variable with a specified @var{value} (such as @code{(a 17)}
+in the above example).
+@c See http://debbugs.gnu.org/12758
+@c Some or all of this was true for cl.el, but not for cl-lib.el.
+@ignore
+The only exceptions are plain variables and calls to
+@code{symbol-value} and @code{symbol-function}.  If the symbol is not
+bound on entry, it is simply made unbound by @code{makunbound} or
+@code{fmakunbound} on exit.
+@end ignore
+@end defmac
+
+@defmac cl-letf* (bindings@dots{}) forms@dots{}
+This macro is to @code{cl-letf} what @code{let*} is to @code{let}:
 It does the bindings in sequential rather than parallel order.
-@end defspec
+@end defmac
 
-@defspec callf @var{function} @var{place} @var{args}@dots{}
+@defmac cl-callf @var{function} @var{place} @var{args}@dots{}
 This is the ``generic'' modify macro.  It calls @var{function},
 which should be an unquoted function name, macro name, or lambda.
 It passes @var{place} and @var{args} as arguments, and assigns the
-result back to @var{place}.  For example, @code{(incf @var{place}
-@var{n})} is the same as @code{(callf + @var{place} @var{n})}.
+result back to @var{place}.  For example, @code{(cl-incf @var{place}
+@var{n})} is the same as @code{(cl-callf + @var{place} @var{n})}.
 Some more examples:
 
 @example
-(callf abs my-number)
-(callf concat (buffer-name) "<" (int-to-string n) ">")
-(callf union happy-people (list joe bob) :test 'same-person)
+(cl-callf abs my-number)
+(cl-callf concat (buffer-name) "<" (number-to-string n) ">")
+(cl-callf cl-union happy-people (list joe bob) :test 'same-person)
 @end example
 
-@xref{Customizing Setf}, for @code{define-modify-macro}, a way
-to create even more concise notations for modify macros.  Note
-again that @code{callf} is an extension to standard Common Lisp.
-@end defspec
+Note again that @code{cl-callf} is an extension to standard Common Lisp.
+@end defmac
 
-@defspec callf2 @var{function} @var{arg1} @var{place} @var{args}@dots{}
-This macro is like @code{callf}, except that @var{place} is
+@defmac cl-callf2 @var{function} @var{arg1} @var{place} @var{args}@dots{}
+This macro is like @code{cl-callf}, except that @var{place} is
 the @emph{second} argument of @var{function} rather than the
 first.  For example, @code{(push @var{x} @var{place})} is
-equivalent to @code{(callf2 cons @var{x} @var{place})}.
-@end defspec
+equivalent to @code{(cl-callf2 cons @var{x} @var{place})}.
+@end defmac
 
-The @code{callf} and @code{callf2} macros serve as building
-blocks for other macros like @code{incf}, @code{pushnew}, and
-@code{define-modify-macro}.  The @code{letf} and @code{letf*}
-macros are used in the processing of symbol macros;
-@pxref{Macro Bindings}.
+The @code{cl-callf} and @code{cl-callf2} macros serve as building
+blocks for other macros like @code{cl-incf}, and @code{cl-pushnew}.
+The @code{cl-letf} and @code{cl-letf*} macros are used in the processing
+of symbol macros; @pxref{Macro Bindings}.
 
-@node Customizing Setf
-@subsection Customizing Setf
-
-@noindent
-Common Lisp defines three macros, @code{define-modify-macro},
-@code{defsetf}, and @code{define-setf-method}, that allow the
-user to extend generalized variables in various ways.
-
-@defspec define-modify-macro name arglist function [doc-string]
-This macro defines a ``read-modify-write'' macro similar to
-@code{incf} and @code{decf}.  The macro @var{name} is defined
-to take a @var{place} argument followed by additional arguments
-described by @var{arglist}.  The call
-
-@example
-(@var{name} @var{place} @var{args}...)
-@end example
-
-@noindent
-will be expanded to
-
-@example
-(callf @var{func} @var{place} @var{args}...)
-@end example
-
-@noindent
-which in turn is roughly equivalent to
-
-@example
-(setf @var{place} (@var{func} @var{place} @var{args}...))
-@end example
-
-For example:
-
-@example
-(define-modify-macro incf (&optional (n 1)) +)
-(define-modify-macro concatf (&rest args) concat)
-@end example
-
-Note that @code{&key} is not allowed in @var{arglist}, but
-@code{&rest} is sufficient to pass keywords on to the function.
-
-Most of the modify macros defined by Common Lisp do not exactly
-follow the pattern of @code{define-modify-macro}.  For example,
-@code{push} takes its arguments in the wrong order, and @code{pop}
-is completely irregular.  You can define these macros ``by hand''
-using @code{get-setf-method}, or consult the source file
-@file{cl-macs.el} to see how to use the internal @code{setf}
-building blocks.
-@end defspec
-
-@defspec defsetf access-fn update-fn
-This is the simpler of two @code{defsetf} forms.  Where
-@var{access-fn} is the name of a function which accesses a place,
-this declares @var{update-fn} to be the corresponding store
-function.  From now on,
-
-@example
-(setf (@var{access-fn} @var{arg1} @var{arg2} @var{arg3}) @var{value})
-@end example
-
-@noindent
-will be expanded to
-
-@example
-(@var{update-fn} @var{arg1} @var{arg2} @var{arg3} @var{value})
-@end example
-
-@noindent
-The @var{update-fn} is required to be either a true function, or
-a macro which evaluates its arguments in a function-like way.  Also,
-the @var{update-fn} is expected to return @var{value} as its result.
-Otherwise, the above expansion would not obey the rules for the way
-@code{setf} is supposed to behave.
-
-As a special (non-Common-Lisp) extension, a third argument of @code{t}
-to @code{defsetf} says that the @code{update-fn}'s return value is
-not suitable, so that the above @code{setf} should be expanded to
-something more like
-
-@example
-(let ((temp @var{value}))
-  (@var{update-fn} @var{arg1} @var{arg2} @var{arg3} temp)
-  temp)
-@end example
-
-Some examples of the use of @code{defsetf}, drawn from the standard
-suite of setf methods, are:
-
-@example
-(defsetf car setcar)
-(defsetf symbol-value set)
-(defsetf buffer-name rename-buffer t)
-@end example
-@end defspec
-
-@defspec defsetf access-fn arglist (store-var) forms@dots{}
-This is the second, more complex, form of @code{defsetf}.  It is
-rather like @code{defmacro} except for the additional @var{store-var}
-argument.  The @var{forms} should return a Lisp form which stores
-the value of @var{store-var} into the generalized variable formed
-by a call to @var{access-fn} with arguments described by @var{arglist}.
-The @var{forms} may begin with a string which documents the @code{setf}
-method (analogous to the doc string that appears at the front of a
-function).
-
-For example, the simple form of @code{defsetf} is shorthand for
-
-@example
-(defsetf @var{access-fn} (&rest args) (store)
-  (append '(@var{update-fn}) args (list store)))
-@end example
-
-The Lisp form that is returned can access the arguments from
-@var{arglist} and @var{store-var} in an unrestricted fashion;
-macros like @code{setf} and @code{incf} which invoke this
-setf-method will insert temporary variables as needed to make
-sure the apparent order of evaluation is preserved.
-
-Another example drawn from the standard package:
-
-@example
-(defsetf nth (n x) (store)
-  (list 'setcar (list 'nthcdr n x) store))
-@end example
-@end defspec
-
-@defspec define-setf-method access-fn arglist forms@dots{}
-This is the most general way to create new place forms.  When
-a @code{setf} to @var{access-fn} with arguments described by
-@var{arglist} is expanded, the @var{forms} are evaluated and
-must return a list of five items:
-
-@enumerate
-@item
-A list of @dfn{temporary variables}.
-
-@item
-A list of @dfn{value forms} corresponding to the temporary variables
-above.  The temporary variables will be bound to these value forms
-as the first step of any operation on the generalized variable.
-
-@item
-A list of exactly one @dfn{store variable} (generally obtained
-from a call to @code{gensym}).
-
-@item
-A Lisp form which stores the contents of the store variable into
-the generalized variable, assuming the temporaries have been
-bound as described above.
-
-@item
-A Lisp form which accesses the contents of the generalized variable,
-assuming the temporaries have been bound.
-@end enumerate
-
-This is exactly like the Common Lisp macro of the same name,
-except that the method returns a list of five values rather
-than the five values themselves, since Emacs Lisp does not
-support Common Lisp's notion of multiple return values.
-
-Once again, the @var{forms} may begin with a documentation string.
-
-A setf-method should be maximally conservative with regard to
-temporary variables.  In the setf-methods generated by
-@code{defsetf}, the second return value is simply the list of
-arguments in the place form, and the first return value is a
-list of a corresponding number of temporary variables generated
-by @code{gensym}.  Macros like @code{setf} and @code{incf} which
-use this setf-method will optimize away most temporaries that
-turn out to be unnecessary, so there is little reason for the
-setf-method itself to optimize.
-@end defspec
-
-@defun get-setf-method place &optional env
-This function returns the setf-method for @var{place}, by
-invoking the definition previously recorded by @code{defsetf}
-or @code{define-setf-method}.  The result is a list of five
-values as described above.  You can use this function to build
-your own @code{incf}-like modify macros.  (Actually, it is
-better to use the internal functions @code{cl-setf-do-modify}
-and @code{cl-setf-do-store}, which are a bit easier to use and
-which also do a number of optimizations; consult the source
-code for the @code{incf} function for a simple example.)
-
-The argument @var{env} specifies the ``environment'' to be
-passed on to @code{macroexpand} if @code{get-setf-method} should
-need to expand a macro in @var{place}.  It should come from
-an @code{&environment} argument to the macro or setf-method
-that called @code{get-setf-method}.
-
-See also the source code for the setf-methods for @code{apply}
-and @code{substring}, each of which works by calling
-@code{get-setf-method} on a simpler case, then massaging
-the result in various ways.
-@end defun
-
-Modern Common Lisp defines a second, independent way to specify
-the @code{setf} behavior of a function, namely ``@code{setf}
-functions'' whose names are lists @code{(setf @var{name})}
-rather than symbols.  For example, @code{(defun (setf foo) @dots{})}
-defines the function that is used when @code{setf} is applied to
-@code{foo}.  This package does not currently support @code{setf}
-functions.  In particular, it is a compile-time error to use
-@code{setf} on a form which has not already been @code{defsetf}'d
-or otherwise declared; in newer Common Lisps, this would not be
-an error since the function @code{(setf @var{func})} might be
-defined later.
-
-@iftex
-@secno=4
-@end iftex
 
 @node Variable Bindings
 @section Variable Bindings
@@ -1504,14 +1239,13 @@ defined later.
 These Lisp forms make bindings to variables and function names,
 analogous to Lisp's built-in @code{let} form.
 
-@xref{Modify Macros}, for the @code{letf} and @code{letf*} forms which
+@xref{Modify Macros}, for the @code{cl-letf} and @code{cl-letf*} forms which
 are also related to variable bindings.
 
 @menu
-* Dynamic Bindings::     The @code{progv} form.
-* Lexical Bindings::     @code{lexical-let} and lexical closures.
+* Dynamic Bindings::     The @code{cl-progv} form.
 * Function Bindings::    @code{flet} and @code{labels}.
-* Macro Bindings::       @code{macrolet} and @code{symbol-macrolet}.
+* Macro Bindings::       @code{cl-macrolet} and @code{cl-symbol-macrolet}.
 @end menu
 
 @node Dynamic Bindings
@@ -1519,134 +1253,20 @@ are also related to variable bindings.
 
 @noindent
 The standard @code{let} form binds variables whose names are known
-at compile-time.  The @code{progv} form provides an easy way to
+at compile-time.  The @code{cl-progv} form provides an easy way to
 bind variables whose names are computed at run-time.
 
-@defspec progv symbols values forms@dots{}
+@defmac cl-progv symbols values forms@dots{}
 This form establishes @code{let}-style variable bindings on a
 set of variables computed at run-time.  The expressions
 @var{symbols} and @var{values} are evaluated, and must return lists
 of symbols and values, respectively.  The symbols are bound to the
 corresponding values for the duration of the body @var{form}s.
 If @var{values} is shorter than @var{symbols}, the last few symbols
-are made unbound (as if by @code{makunbound}) inside the body.
+are bound to @code{nil}.
 If @var{symbols} is shorter than @var{values}, the excess values
 are ignored.
-@end defspec
-
-@node Lexical Bindings
-@subsection Lexical Bindings
-
-@noindent
-The @code{CL} package defines the following macro which
-more closely follows the Common Lisp @code{let} form:
-
-@defspec lexical-let (bindings@dots{}) forms@dots{}
-This form is exactly like @code{let} except that the bindings it
-establishes are purely lexical.  Lexical bindings are similar to
-local variables in a language like C:  Only the code physically
-within the body of the @code{lexical-let} (after macro expansion)
-may refer to the bound variables.
-
-@example
-(setq a 5)
-(defun foo (b) (+ a b))
-(let ((a 2)) (foo a))
-     @result{} 4
-(lexical-let ((a 2)) (foo a))
-     @result{} 7
-@end example
-
-@noindent
-In this example, a regular @code{let} binding of @code{a} actually
-makes a temporary change to the global variable @code{a}, so @code{foo}
-is able to see the binding of @code{a} to 2.  But @code{lexical-let}
-actually creates a distinct local variable @code{a} for use within its
-body, without any effect on the global variable of the same name.
-
-The most important use of lexical bindings is to create @dfn{closures}.
-A closure is a function object that refers to an outside lexical
-variable.  For example:
-
-@example
-(defun make-adder (n)
-  (lexical-let ((n n))
-    (function (lambda (m) (+ n m)))))
-(setq add17 (make-adder 17))
-(funcall add17 4)
-     @result{} 21
-@end example
-
-@noindent
-The call @code{(make-adder 17)} returns a function object which adds
-17 to its argument.  If @code{let} had been used instead of
-@code{lexical-let}, the function object would have referred to the
-global @code{n}, which would have been bound to 17 only during the
-call to @code{make-adder} itself.
-
-@example
-(defun make-counter ()
-  (lexical-let ((n 0))
-    (function* (lambda (&optional (m 1)) (incf n m)))))
-(setq count-1 (make-counter))
-(funcall count-1 3)
-     @result{} 3
-(funcall count-1 14)
-     @result{} 17
-(setq count-2 (make-counter))
-(funcall count-2 5)
-     @result{} 5
-(funcall count-1 2)
-     @result{} 19
-(funcall count-2)
-     @result{} 6
-@end example
-
-@noindent
-Here we see that each call to @code{make-counter} creates a distinct
-local variable @code{n}, which serves as a private counter for the
-function object that is returned.
-
-Closed-over lexical variables persist until the last reference to
-them goes away, just like all other Lisp objects.  For example,
-@code{count-2} refers to a function object which refers to an
-instance of the variable @code{n}; this is the only reference
-to that variable, so after @code{(setq count-2 nil)} the garbage
-collector would be able to delete this instance of @code{n}.
-Of course, if a @code{lexical-let} does not actually create any
-closures, then the lexical variables are free as soon as the
-@code{lexical-let} returns.
-
-Many closures are used only during the extent of the bindings they
-refer to; these are known as ``downward funargs'' in Lisp parlance.
-When a closure is used in this way, regular Emacs Lisp dynamic
-bindings suffice and will be more efficient than @code{lexical-let}
-closures:
-
-@example
-(defun add-to-list (x list)
-  (mapcar (lambda (y) (+ x y))) list)
-(add-to-list 7 '(1 2 5))
-     @result{} (8 9 12)
-@end example
-
-@noindent
-Since this lambda is only used while @code{x} is still bound,
-it is not necessary to make a true closure out of it.
-
-You can use @code{defun} or @code{flet} inside a @code{lexical-let}
-to create a named closure.  If several closures are created in the
-body of a single @code{lexical-let}, they all close over the same
-instance of the lexical variable.
-
-The @code{lexical-let} form is an extension to Common Lisp.  In
-true Common Lisp, all bindings are lexical unless declared otherwise.
-@end defspec
-
-@defspec lexical-let* (bindings@dots{}) forms@dots{}
-This form is just like @code{lexical-let}, except that the bindings
-are made sequentially in the manner of @code{let*}.
-@end defspec
+@end defmac
 
 @node Function Bindings
 @subsection Function Bindings
@@ -1655,12 +1275,12 @@ are made sequentially in the manner of @code{let*}.
 These forms make @code{let}-like bindings to functions instead
 of variables.
 
-@defspec flet (bindings@dots{}) forms@dots{}
+@defmac flet (bindings@dots{}) forms@dots{}
 This form establishes @code{let}-style bindings on the function
 cells of symbols rather than on the value cells.  Each @var{binding}
 must be a list of the form @samp{(@var{name} @var{arglist}
 @var{forms}@dots{})}, which defines a function exactly as if
-it were a @code{defun*} form.  The function @var{name} is defined
+it were a @code{cl-defun} form.  The function @var{name} is defined
 accordingly for the duration of the body of the @code{flet}; then
 the old function definition, or lack thereof, is restored.
 
@@ -1696,12 +1316,12 @@ handling.  Attempts to redefine such functions using @code{flet} will
 fail if byte-compiled.  In such cases, use @code{labels} instead.
 
 Functions defined by @code{flet} may use the full Common Lisp
-argument notation supported by @code{defun*}; also, the function
-body is enclosed in an implicit block as if by @code{defun*}.
+argument notation supported by @code{cl-defun}; also, the function
+body is enclosed in an implicit block as if by @code{cl-defun}.
 @xref{Program Structure}.
-@end defspec
+@end defmac
 
-@defspec labels (bindings@dots{}) forms@dots{}
+@defmac labels (bindings@dots{}) forms@dots{}
 The @code{labels} form is like @code{flet}, except that it
 makes lexical bindings of the function names rather than
 dynamic bindings.  (In true Common Lisp, both @code{flet} and
@@ -1722,29 +1342,33 @@ functions.
 A ``reference'' to a function name is either a call to that
 function, or a use of its name quoted by @code{quote} or
 @code{function} to be passed on to, say, @code{mapcar}.
-@end defspec
+@end defmac
 
 @node Macro Bindings
 @subsection Macro Bindings
 
 @noindent
-These forms create local macros and ``symbol macros.''
+These forms create local macros and ``symbol macros''.
 
-@defspec macrolet (bindings@dots{}) forms@dots{}
+@defmac cl-macrolet (bindings@dots{}) forms@dots{}
 This form is analogous to @code{flet}, but for macros instead of
 functions.  Each @var{binding} is a list of the same form as the
-arguments to @code{defmacro*} (i.e., a macro name, argument list,
+arguments to @code{cl-defmacro} (i.e., a macro name, argument list,
 and macro-expander forms).  The macro is defined accordingly for
-use within the body of the @code{macrolet}.
-
-Because of the nature of macros, @code{macrolet} is lexically
-scoped even in Emacs Lisp:  The @code{macrolet} binding will
+use within the body of the @code{cl-macrolet}.
+
+@c FIXME this should be modified to say ``even when lexical-binding
+@c is code{nil}'', but is that true?  The doc of cl-macrolet just
+@c refers us to cl-flet, which refers to cl-labels, which says that it
+@c behaves differently according to whether l-b is true or not.
+Because of the nature of macros, @code{cl-macrolet} is lexically
+scoped even in Emacs Lisp:  The @code{cl-macrolet} binding will
 affect only calls that appear physically within the body
 @var{forms}, possibly after expansion of other macros in the
 body.
-@end defspec
+@end defmac
 
-@defspec symbol-macrolet (bindings@dots{}) forms@dots{}
+@defmac cl-symbol-macrolet (bindings@dots{}) forms@dots{}
 This form creates @dfn{symbol macros}, which are macros that look
 like variable references rather than function calls.  Each
 @var{binding} is a list @samp{(@var{var} @var{expansion})};
@@ -1753,8 +1377,8 @@ replaced by @var{expansion}.
 
 @example
 (setq bar '(5 . 9))
-(symbol-macrolet ((foo (car bar)))
-  (incf foo))
+(cl-symbol-macrolet ((foo (car bar)))
+  (cl-incf foo))
 bar
      @result{} (6 . 9)
 @end example
@@ -1764,25 +1388,28 @@ I.e., @code{(setq foo 4)} in the above would be equivalent to
 @code{(setf foo 4)}, which in turn expands to @code{(setf (car bar) 4)}.
 
 Likewise, a @code{let} or @code{let*} binding a symbol macro is
-treated like a @code{letf} or @code{letf*}.  This differs from true
+treated like a @code{cl-letf} or @code{cl-letf*}.  This differs from true
+@c FIXME does it work like this in Emacs with lexical-binding = t?
 Common Lisp, where the rules of lexical scoping cause a @code{let}
-binding to shadow a @code{symbol-macrolet} binding.  In this package,
+binding to shadow a @code{cl-symbol-macrolet} binding.  In this package,
+@c FIXME obsolete.
 only @code{lexical-let} and @code{lexical-let*} will shadow a symbol
 macro.
 
 There is no analogue of @code{defmacro} for symbol macros; all symbol
-macros are local.  A typical use of @code{symbol-macrolet} is in the
+macros are local.  A typical use of @code{cl-symbol-macrolet} is in the
 expansion of another macro:
 
 @example
-(defmacro* my-dolist ((x list) &rest body)
+(cl-defmacro my-dolist ((x list) &rest body)
   (let ((var (gensym)))
-    (list 'loop 'for var 'on list 'do
-          (list* 'symbol-macrolet (list (list x (list 'car var)))
-                 body))))
+    (list 'cl-loop 'for var 'on list 'do
+          (cl-list* 'cl-symbol-macrolet
+                    (list (list x (list 'car var)))
+                    body))))
 
 (setq mylist '(1 2 3 4))
-(my-dolist (x mylist) (incf x))
+(my-dolist (x mylist) (cl-incf x))
 mylist
      @result{} (2 3 4 5)
 @end example
@@ -1794,22 +1421,22 @@ reference onto the elements of the list.  The @code{my-dolist} call
 shown here expands to
 
 @example
-(loop for G1234 on mylist do
-      (symbol-macrolet ((x (car G1234)))
-        (incf x)))
+(cl-loop for G1234 on mylist do
+      (cl-symbol-macrolet ((x (car G1234)))
+        (cl-incf x)))
 @end example
 
 @noindent
 which in turn expands to
 
 @example
-(loop for G1234 on mylist do (incf (car G1234)))
+(cl-loop for G1234 on mylist do (cl-incf (car G1234)))
 @end example
 
-@xref{Loop Facility}, for a description of the @code{loop} macro.
+@xref{Loop Facility}, for a description of the @code{cl-loop} macro.
 This package defines a nonstandard @code{in-ref} loop clause that
 works much like @code{my-dolist}.
-@end defspec
+@end defmac
 
 @node Conditionals
 @section Conditionals
@@ -1818,11 +1445,11 @@ works much like @code{my-dolist}.
 These conditional forms augment Emacs Lisp's simple @code{if},
 @code{and}, @code{or}, and @code{cond} forms.
 
-@defspec case keyform clause@dots{}
+@defmac cl-case keyform clause@dots{}
 This macro evaluates @var{keyform}, then compares it with the key
 values listed in the various @var{clause}s.  Whichever clause matches
 the key is executed; comparison is done by @code{eql}.  If no clause
-matches, the @code{case} form returns @code{nil}.  The clauses are
+matches, the @code{cl-case} form returns @code{nil}.  The clauses are
 of the form
 
 @example
@@ -1833,7 +1460,7 @@ of the form
 where @var{keylist} is a list of key values.  If there is exactly
 one value, and it is not a cons cell or the symbol @code{nil} or
 @code{t}, then it can be used by itself as a @var{keylist} without
-being enclosed in a list.  All key values in the @code{case} form
+being enclosed in a list.  All key values in the @code{cl-case} form
 must be distinct.  The final clauses may use @code{t} in place of
 a @var{keylist} to indicate a default clause that should be taken
 if none of the other clauses match.  (The symbol @code{otherwise}
@@ -1846,28 +1473,28 @@ four things depending on whether it is an @samp{a}, a @samp{b},
 a @key{RET} or @kbd{C-j}, or anything else.
 
 @example
-(case (read-char)
+(cl-case (read-char)
   (?a (do-a-thing))
   (?b (do-b-thing))
   ((?\r ?\n) (do-ret-thing))
   (t (do-other-thing)))
 @end example
-@end defspec
+@end defmac
 
-@defspec ecase keyform clause@dots{}
-This macro is just like @code{case}, except that if the key does
+@defmac cl-ecase keyform clause@dots{}
+This macro is just like @code{cl-case}, except that if the key does
 not match any of the clauses, an error is signaled rather than
 simply returning @code{nil}.
-@end defspec
+@end defmac
 
-@defspec typecase keyform clause@dots{}
-This macro is a version of @code{case} that checks for types
+@defmac cl-typecase keyform clause@dots{}
+This macro is a version of @code{cl-case} that checks for types
 rather than values.  Each @var{clause} is of the form
 @samp{(@var{type} @var{body}...)}.  @xref{Type Predicates},
 for a description of type specifiers.  For example,
 
 @example
-(typecase x
+(cl-typecase x
   (integer (munch-integer x))
   (float (munch-float x))
   (string (munch-integer (string-to-int x)))
@@ -1877,13 +1504,13 @@ for a description of type specifiers.  For example,
 The type specifier @code{t} matches any type of object; the word
 @code{otherwise} is also allowed.  To make one clause match any of
 several types, use an @code{(or ...)} type specifier.
-@end defspec
+@end defmac
 
-@defspec etypecase keyform clause@dots{}
-This macro is just like @code{typecase}, except that if the key does
+@defmac cl-etypecase keyform clause@dots{}
+This macro is just like @code{cl-typecase}, except that if the key does
 not match any of the clauses, an error is signaled rather than
 simply returning @code{nil}.
-@end defspec
+@end defmac
 
 @node Blocks and Exits
 @section Blocks and Exits
@@ -1891,26 +1518,26 @@ simply returning @code{nil}.
 @noindent
 Common Lisp @dfn{blocks} provide a non-local exit mechanism very
 similar to @code{catch} and @code{throw}, but lexically rather than
-dynamically scoped.  This package actually implements @code{block}
+dynamically scoped.  This package actually implements @code{cl-block}
 in terms of @code{catch}; however, the lexical scoping allows the
 optimizing byte-compiler to omit the costly @code{catch} step if the
-body of the block does not actually @code{return-from} the block.
+body of the block does not actually @code{cl-return-from} the block.
 
-@defspec block name forms@dots{}
+@defmac cl-block name forms@dots{}
 The @var{forms} are evaluated as if by a @code{progn}.  However,
-if any of the @var{forms} execute @code{(return-from @var{name})},
-they will jump out and return directly from the @code{block} form.
-The @code{block} returns the result of the last @var{form} unless
-a @code{return-from} occurs.
+if any of the @var{forms} execute @code{(cl-return-from @var{name})},
+they will jump out and return directly from the @code{cl-block} form.
+The @code{cl-block} returns the result of the last @var{form} unless
+a @code{cl-return-from} occurs.
 
-The @code{block}/@code{return-from} mechanism is quite similar to
+The @code{cl-block}/@code{cl-return-from} mechanism is quite similar to
 the @code{catch}/@code{throw} mechanism.  The main differences are
 that block @var{name}s are unevaluated symbols, rather than forms
 (such as quoted symbols) which evaluate to a tag at run-time; and
 also that blocks are lexically scoped whereas @code{catch}/@code{throw}
 are dynamically scoped.  This means that functions called from the
 body of a @code{catch} can also @code{throw} to the @code{catch},
-but the @code{return-from} referring to a block name must appear
+but the @code{cl-return-from} referring to a block name must appear
 physically within the @var{forms} that make up the body of the block.
 They may not appear within other called functions, although they may
 appear within macro expansions or @code{lambda}s in the body.  Block
@@ -1919,11 +1546,11 @@ names and @code{catch} names form independent name-spaces.
 In true Common Lisp, @code{defun} and @code{defmacro} surround
 the function or expander bodies with implicit blocks with the
 same name as the function or macro.  This does not occur in Emacs
-Lisp, but this package provides @code{defun*} and @code{defmacro*}
+Lisp, but this package provides @code{cl-defun} and @code{cl-defmacro}
 forms which do create the implicit block.
 
 The Common Lisp looping constructs defined by this package,
-such as @code{loop} and @code{dolist}, also create implicit blocks
+such as @code{cl-loop} and @code{cl-dolist}, also create implicit blocks
 just as in Common Lisp.
 
 Because they are implemented in terms of Emacs Lisp @code{catch}
@@ -1931,24 +1558,24 @@ and @code{throw}, blocks have the same overhead as actual
 @code{catch} constructs (roughly two function calls).  However,
 the optimizing byte compiler will optimize away the @code{catch}
 if the block does
-not in fact contain any @code{return} or @code{return-from} calls
-that jump to it.  This means that @code{do} loops and @code{defun*}
-functions which don't use @code{return} don't pay the overhead to
+not in fact contain any @code{cl-return} or @code{cl-return-from} calls
+that jump to it.  This means that @code{cl-do} loops and @code{cl-defun}
+functions which don't use @code{cl-return} don't pay the overhead to
 support it.
-@end defspec
+@end defmac
 
-@defspec return-from name [result]
+@defmac cl-return-from name [result]
 This macro returns from the block named @var{name}, which must be
 an (unevaluated) symbol.  If a @var{result} form is specified, it
 is evaluated to produce the result returned from the @code{block}.
 Otherwise, @code{nil} is returned.
-@end defspec
+@end defmac
 
-@defspec return [result]
-This macro is exactly like @code{(return-from nil @var{result})}.
-Common Lisp loops like @code{do} and @code{dolist} implicitly enclose
+@defmac cl-return [result]
+This macro is exactly like @code{(cl-return-from nil @var{result})}.
+Common Lisp loops like @code{cl-do} and @code{cl-dolist} implicitly enclose
 themselves in @code{nil} blocks.
-@end defspec
+@end defmac
 
 @node Iteration
 @section Iteration
@@ -1958,27 +1585,27 @@ The macros described here provide more sophisticated, high-level
 looping constructs to complement Emacs Lisp's basic @code{while}
 loop.
 
-@defspec loop forms@dots{}
+@defmac cl-loop forms@dots{}
 The @code{CL} package supports both the simple, old-style meaning of
 @code{loop} and the extremely powerful and flexible feature known as
 the @dfn{Loop Facility} or @dfn{Loop Macro}.  This more advanced
 facility is discussed in the following section; @pxref{Loop Facility}.
 The simple form of @code{loop} is described here.
 
-If @code{loop} is followed by zero or more Lisp expressions,
-then @code{(loop @var{exprs}@dots{})} simply creates an infinite
+If @code{cl-loop} is followed by zero or more Lisp expressions,
+then @code{(cl-loop @var{exprs}@dots{})} simply creates an infinite
 loop executing the expressions over and over.  The loop is
 enclosed in an implicit @code{nil} block.  Thus,
 
 @example
-(loop (foo)  (if (no-more) (return 72))  (bar))
+(cl-loop (foo)  (if (no-more) (return 72))  (bar))
 @end example
 
 @noindent
 is exactly equivalent to
 
 @example
-(block nil (while t (foo)  (if (no-more) (return 72))  (bar)))
+(cl-block nil (while t (foo)  (if (no-more) (return 72))  (bar)))
 @end example
 
 If any of the expressions are plain symbols, the loop is instead
@@ -1986,9 +1613,9 @@ interpreted as a Loop Macro specification as described later.
 (This is not a restriction in practice, since a plain symbol
 in the above notation would simply access and throw away the
 value of a variable.)
-@end defspec
+@end defmac
 
-@defspec do (spec@dots{}) (end-test [result@dots{}]) forms@dots{}
+@defmac cl-do (spec@dots{}) (end-test [result@dots{}]) forms@dots{}
 This macro creates a general iterative loop.  Each @var{spec} is
 of the form
 
@@ -2004,15 +1631,15 @@ evaluated, then each @var{var} is set to the associated @var{step}
 expression (as if by a @code{cl-psetq} form) and the next iteration
 begins.  Once the @var{end-test} becomes true, the @var{result}
 forms are evaluated (with the @var{var}s still bound to their
-values) to produce the result returned by @code{do}.
+values) to produce the result returned by @code{cl-do}.
 
-The entire @code{do} loop is enclosed in an implicit @code{nil}
-block, so that you can use @code{(return)} to break out of the
+The entire @code{cl-do} loop is enclosed in an implicit @code{nil}
+block, so that you can use @code{(cl-return)} to break out of the
 loop at any time.
 
 If there are no @var{result} forms, the loop returns @code{nil}.
 If a given @var{var} has no @var{step} form, it is bound to its
-@var{init} value but not otherwise modified during the @code{do}
+@var{init} value but not otherwise modified during the @code{cl-do}
 loop (unless the code explicitly modifies it); this case is just
 a shorthand for putting a @code{(let ((@var{var} @var{init})) @dots{})}
 around the loop.  If @var{init} is also omitted it defaults to
@@ -2023,21 +1650,21 @@ in place of @samp{(@var{var})}, again following the analogy with
 This example (from Steele) illustrates a loop which applies the
 function @code{f} to successive pairs of values from the lists
 @code{foo} and @code{bar}; it is equivalent to the call
-@code{(mapcar* 'f foo bar)}.  Note that this loop has no body
+@code{(cl-mapcar 'f foo bar)}.  Note that this loop has no body
 @var{forms} at all, performing all its work as side effects of
 the rest of the loop.
 
 @example
-(do ((x foo (cdr x))
-     (y bar (cdr y))
-     (z nil (cons (f (car x) (car y)) z)))
-  ((or (null x) (null y))
-   (nreverse z)))
+(cl-do ((x foo (cdr x))
+        (y bar (cdr y))
+        (z nil (cons (f (car x) (car y)) z)))
+     ((or (null x) (null y))
+      (nreverse z)))
 @end example
-@end defspec
+@end defmac
 
-@defspec do* (spec@dots{}) (end-test [result@dots{}]) forms@dots{}
-This is to @code{do} what @code{let*} is to @code{let}.  In
+@defmac cl-do* (spec@dots{}) (end-test [result@dots{}]) forms@dots{}
+This is to @code{cl-do} what @code{let*} is to @code{let}.  In
 particular, the initial values are bound as if by @code{let*}
 rather than @code{let}, and the steps are assigned as if by
 @code{setq} rather than @code{cl-psetq}.
@@ -2045,18 +1672,18 @@ rather than @code{let}, and the steps are assigned as if by
 Here is another way to write the above loop:
 
 @example
-(do* ((xp foo (cdr xp))
-      (yp bar (cdr yp))
-      (x (car xp) (car xp))
-      (y (car yp) (car yp))
-      z)
+(cl-do* ((xp foo (cdr xp))
+         (yp bar (cdr yp))
+         (x (car xp) (car xp))
+         (y (car yp) (car yp))
+         z)
   ((or (null xp) (null yp))
    (nreverse z))
   (push (f x y) z))
 @end example
-@end defspec
+@end defmac
 
-@defspec dolist (var list [result]) forms@dots{}
+@defmac cl-dolist (var list [result]) forms@dots{}
 This is a more specialized loop which iterates across the elements
 of a list.  @var{list} should evaluate to a list; the body @var{forms}
 are executed with @var{var} bound to each element of the list in
@@ -2064,9 +1691,9 @@ turn.  Finally, the @var{result} form (or @code{nil}) is evaluated
 with @var{var} bound to @code{nil} to produce the result returned by
 the loop.  Unlike with Emacs's built in @code{dolist}, the loop is
 surrounded by an implicit @code{nil} block.
-@end defspec
+@end defmac
 
-@defspec dotimes (var count [result]) forms@dots{}
+@defmac cl-dotimes (var count [result]) forms@dots{}
 This is a more specialized loop which iterates a specified number
 of times.  The body is executed with @var{var} bound to the integers
 from zero (inclusive) to @var{count} (exclusive), in turn.  Then
@@ -2074,9 +1701,9 @@ the @code{result} form is evaluated with @var{var} bound to the total
 number of iterations that were done (i.e., @code{(max 0 @var{count})})
 to get the return value for the loop form.  Unlike with Emacs's built in
 @code{dolist}, the loop is surrounded by an implicit @code{nil} block.
-@end defspec
+@end defmac
 
-@defspec do-symbols (var [obarray [result]]) forms@dots{}
+@defmac cl-do-symbols (var [obarray [result]]) forms@dots{}
 This loop iterates over all interned symbols.  If @var{obarray}
 is specified and is not @code{nil}, it loops over all symbols in
 that obarray.  For each symbol, the body @var{forms} are evaluated
@@ -2084,12 +1711,12 @@ with @var{var} bound to that symbol.  The symbols are visited in
 an unspecified order.  Afterward the @var{result} form, if any,
 is evaluated (with @var{var} bound to @code{nil}) to get the return
 value.  The loop is surrounded by an implicit @code{nil} block.
-@end defspec
+@end defmac
 
-@defspec do-all-symbols (var [result]) forms@dots{}
-This is identical to @code{do-symbols} except that the @var{obarray}
+@defmac cl-do-all-symbols (var [result]) forms@dots{}
+This is identical to @code{cl-do-symbols} except that the @var{obarray}
 argument is omitted; it always iterates over the default obarray.
-@end defspec
+@end defmac
 
 @xref{Mapping over Sequences}, for some more functions for
 iterating over vectors or lists.
@@ -2104,12 +1731,12 @@ that they are either too simple and limited, such as Common Lisp's
 obscure, like Common Lisp's @code{do} loop.
 
 To remedy this, recent versions of Common Lisp have added a new
-construct called the ``Loop Facility'' or ``@code{loop} macro,''
+construct called the ``Loop Facility'' or ``@code{loop} macro'',
 with an easy-to-use but very powerful and expressive syntax.
 
 @menu
-* Loop Basics::           @code{loop} macro, basic clause structure.
-* Loop Examples::         Working examples of @code{loop} macro.
+* Loop Basics::           @code{cl-loop} macro, basic clause structure.
+* Loop Examples::         Working examples of @code{cl-loop} macro.
 * For Clauses::           Clauses introduced by @code{for} or @code{as}.
 * Iteration Clauses::     @code{repeat}, @code{while}, @code{thereis}, etc.
 * Accumulation Clauses::  @code{collect}, @code{sum}, @code{maximize}, etc.
@@ -2120,19 +1747,19 @@ with an easy-to-use but very powerful and expressive syntax.
 @subsection Loop Basics
 
 @noindent
-The @code{loop} macro essentially creates a mini-language within
+The @code{cl-loop} macro essentially creates a mini-language within
 Lisp that is specially tailored for describing loops.  While this
 language is a little strange-looking by the standards of regular Lisp,
 it turns out to be very easy to learn and well-suited to its purpose.
 
-Since @code{loop} is a macro, all parsing of the loop language
-takes place at byte-compile time; compiled @code{loop}s are just
+Since @code{cl-loop} is a macro, all parsing of the loop language
+takes place at byte-compile time; compiled @code{cl-loop}s are just
 as efficient as the equivalent @code{while} loops written longhand.
 
-@defspec loop clauses@dots{}
+@defmac cl-loop clauses@dots{}
 A loop construct consists of a series of @var{clause}s, each
 introduced by a symbol like @code{for} or @code{do}.  Clauses
-are simply strung together in the argument list of @code{loop},
+are simply strung together in the argument list of @code{cl-loop},
 with minimal extra parentheses.  The various types of clauses
 specify initializations, such as the binding of temporary
 variables, actions to be taken in the loop, stepping actions,
@@ -2142,9 +1769,9 @@ Common Lisp specifies a certain general order of clauses in a
 loop:
 
 @example
-(loop @var{name-clause}
-      @var{var-clauses}@dots{}
-      @var{action-clauses}@dots{})
+(cl-loop @var{name-clause}
+         @var{var-clauses}@dots{}
+         @var{action-clauses}@dots{})
 @end example
 
 The @var{name-clause} optionally gives a name to the implicit
@@ -2155,7 +1782,7 @@ be modified or iterated throughout the course of the loop.  The
 @var{action-clauses} are things to be done during the loop, such
 as computing, collecting, and returning values.
 
-The Emacs version of the @code{loop} macro is less restrictive about
+The Emacs version of the @code{cl-loop} macro is less restrictive about
 the order of clauses, but things will behave most predictably if
 you put the variable-binding clauses @code{with}, @code{for}, and
 @code{repeat} before the action clauses.  As in Common Lisp,
@@ -2166,9 +1793,9 @@ them to return a value by using an accumulation clause like
 @code{collect}, an end-test clause like @code{always}, or an
 explicit @code{return} clause to jump out of the implicit block.
 (Because the loop body is enclosed in an implicit block, you can
-also use regular Lisp @code{return} or @code{return-from} to
+also use regular Lisp @code{cl-return} or @code{cl-return-from} to
 break out of the loop.)
-@end defspec
+@end defmac
 
 The following sections give some examples of the Loop Macro in
 action, and describe the particular loop clauses in great detail.
@@ -2180,25 +1807,25 @@ for additional discussion and examples of the @code{loop} macro.
 
 @noindent
 Before listing the full set of clauses that are allowed, let's
-look at a few example loops just to get a feel for the @code{loop}
+look at a few example loops just to get a feel for the @code{cl-loop}
 language.
 
 @example
-(loop for buf in (buffer-list)
-      collect (buffer-file-name buf))
+(cl-loop for buf in (buffer-list)
+         collect (buffer-file-name buf))
 @end example
 
 @noindent
 This loop iterates over all Emacs buffers, using the list
-returned by @code{buffer-list}.  For each buffer @code{buf},
+returned by @code{buffer-list}.  For each buffer @var{buf},
 it calls @code{buffer-file-name} and collects the results into
-a list, which is then returned from the @code{loop} construct.
+a list, which is then returned from the @code{cl-loop} construct.
 The result is a list of the file names of all the buffers in
 Emacs's memory.  The words @code{for}, @code{in}, and @code{collect}
-are reserved words in the @code{loop} language.
+are reserved words in the @code{cl-loop} language.
 
 @example
-(loop repeat 20 do (insert "Yowsa\n"))
+(cl-loop repeat 20 do (insert "Yowsa\n"))
 @end example
 
 @noindent
@@ -2206,7 +1833,7 @@ This loop inserts the phrase ``Yowsa'' twenty times in the
 current buffer.
 
 @example
-(loop until (eobp) do (munch-line) (forward-line 1))
+(cl-loop until (eobp) do (munch-line) (forward-line 1))
 @end example
 
 @noindent
@@ -2215,7 +1842,7 @@ of the buffer.  If point is already at the end of the buffer,
 the loop exits immediately.
 
 @example
-(loop do (munch-line) until (eobp) do (forward-line 1))
+(cl-loop do (munch-line) until (eobp) do (forward-line 1))
 @end example
 
 @noindent
@@ -2223,10 +1850,10 @@ This loop is similar to the above one, except that @code{munch-line}
 is always called at least once.
 
 @example
-(loop for x from 1 to 100
-      for y = (* x x)
-      until (>= y 729)
-      finally return (list x (= y 729)))
+(cl-loop for x from 1 to 100
+         for y = (* x x)
+         until (>= y 729)
+         finally return (list x (= y 729)))
 @end example
 
 @noindent
@@ -2246,7 +1873,7 @@ Note that even though this loop contains three clauses (two
 @code{for}s and an @code{until}) that would have been enough to
 define loops all by themselves, it still creates a single loop
 rather than some sort of triple-nested loop.  You must explicitly
-nest your @code{loop} constructs if you want nested loops.
+nest your @code{cl-loop} constructs if you want nested loops.
 
 @node For Clauses
 @subsection For Clauses
@@ -2272,7 +1899,7 @@ The variable is bound around the loop as if by @code{let}:
 
 @example
 (setq i 'happy)
-(loop for i from 1 to 10 do (do-something-with i))
+(cl-loop for i from 1 to 10 do (do-something-with i))
 i
      @result{} happy
 @end example
@@ -2302,10 +1929,10 @@ which are like @code{upto} and @code{downto} respectively except
 that they are exclusive rather than inclusive limits:
 
 @example
-(loop for x to 10 collect x)
-     @result{} (0 1 2 3 4 5 6 7 8 9 10)
-(loop for x below 10 collect x)
-     @result{} (0 1 2 3 4 5 6 7 8 9)
+(cl-loop for x to 10 collect x)
+        @result{} (0 1 2 3 4 5 6 7 8 9 10)
+(cl-loop for x below 10 collect x)
+        @result{} (0 1 2 3 4 5 6 7 8 9)
 @end example
 
 The @code{by} value is always positive, even for downward-counting
@@ -2320,25 +1947,25 @@ is used to traverse the list instead of @code{cdr}; it must be a
 function taking one argument.  For example:
 
 @example
-(loop for x in '(1 2 3 4 5 6) collect (* x x))
-     @result{} (1 4 9 16 25 36)
-(loop for x in '(1 2 3 4 5 6) by 'cddr collect (* x x))
-     @result{} (1 9 25)
+(cl-loop for x in '(1 2 3 4 5 6) collect (* x x))
+        @result{} (1 4 9 16 25 36)
+(cl-loop for x in '(1 2 3 4 5 6) by 'cddr collect (* x x))
+        @result{} (1 9 25)
 @end example
 
 @item for @var{var} on @var{list} by @var{function}
 This clause iterates @var{var} over all the cons cells of @var{list}.
 
 @example
-(loop for x on '(1 2 3 4) collect x)
-     @result{} ((1 2 3 4) (2 3 4) (3 4) (4))
+(cl-loop for x on '(1 2 3 4) collect x)
+        @result{} ((1 2 3 4) (2 3 4) (3 4) (4))
 @end example
 
 With @code{by}, there is no real reason that the @code{on} expression
 must be a list.  For example:
 
 @example
-(loop for x on first-animal by 'next-animal collect x)
+(cl-loop for x on first-animal by 'next-animal collect x)
 @end example
 
 @noindent
@@ -2352,7 +1979,7 @@ a @code{setf}-able ``reference'' onto the elements of the list
 rather than just a temporary variable.  For example,
 
 @example
-(loop for x in-ref my-list do (incf x))
+(cl-loop for x in-ref my-list do (cl-incf x))
 @end example
 
 @noindent
@@ -2364,8 +1991,8 @@ This clause iterates @var{var} over all the elements of @var{array},
 which may be a vector or a string.
 
 @example
-(loop for x across "aeiou"
-      do (use-vowel (char-to-string x)))
+(cl-loop for x across "aeiou"
+         do (use-vowel (char-to-string x)))
 @end example
 
 @item for @var{var} across-ref @var{array}
@@ -2397,10 +2024,10 @@ an unspecified order.
 As an example,
 
 @example
-(loop for sym being the symbols
-      when (fboundp sym)
-      when (string-match "^map" (symbol-name sym))
-      collect sym)
+(cl-loop for sym being the symbols
+         when (fboundp sym)
+         when (string-match "^map" (symbol-name sym))
+         collect sym)
 @end example
 
 @noindent
@@ -2411,7 +2038,7 @@ are also recognized but are equivalent to @code{symbols} in Emacs Lisp.
 
 Due to a minor implementation restriction, it will not work to have
 more than one @code{for} clause iterating over symbols, hash tables,
-keymaps, overlays, or intervals in a given @code{loop}.  Fortunately,
+keymaps, overlays, or intervals in a given @code{cl-loop}.  Fortunately,
 it would rarely if ever be useful to do so.  It @emph{is} valid to mix
 one of these types of clauses with other clauses like @code{for ... to}
 or @code{while}.
@@ -2423,10 +2050,10 @@ This clause iterates over the entries in @var{hash-table} with
 a second variable to the opposite part.
 
 @example
-(loop for k being the hash-keys of h
-            using (hash-values v)
-      do
-      (message "key %S -> value %S" k v))
+(cl-loop for k being the hash-keys of h
+               using (hash-values v)
+         do
+         (message "key %S -> value %S" k v))
 @end example
 
 @item for @var{var} being the key-codes of @var{keymap}
@@ -2438,10 +2065,10 @@ A @code{using} clause can access both the codes and the bindings
 together.
 
 @example
-(loop for c being the key-codes of (current-local-map)
-            using (key-bindings b)
-      do
-      (message "key %S -> binding %S" c b))
+(cl-loop for c being the key-codes of (current-local-map)
+               using (key-bindings b)
+         do
+         (message "key %S -> binding %S" c b))
 @end example
 
 
@@ -2497,8 +2124,8 @@ and successive iterations it will be set by evaluating @var{expr2}
 these two loops are effectively the same:
 
 @example
-(loop for x on my-list by 'cddr do ...)
-(loop for x = my-list then (cddr x) while x do ...)
+(cl-loop for x on my-list by 'cddr do ...)
+(cl-loop for x = my-list then (cddr x) while x do ...)
 @end example
 
 Note that this type of @code{for} clause does not imply any sort
@@ -2509,7 +2136,7 @@ If you omit the @code{then} term, @var{expr1} is used both for
 the initial setting and for successive settings:
 
 @example
-(loop for x = (random) when (> x 0) return x)
+(cl-loop for x = (random) when (> x 0) return x)
 @end example
 
 @noindent
@@ -2524,10 +2151,10 @@ in which case they are processed in parallel (as if by @code{let}
 and @code{cl-psetq}).
 
 @example
-(loop for x below 5 for y = nil then x collect (list x y))
-     @result{} ((0 nil) (1 1) (2 2) (3 3) (4 4))
-(loop for x below 5 and y = nil then x collect (list x y))
-     @result{} ((0 nil) (1 0) (2 1) (3 2) (4 3))
+(cl-loop for x below 5 for y = nil then x collect (list x y))
+        @result{} ((0 nil) (1 1) (2 2) (3 3) (4 4))
+(cl-loop for x below 5 and y = nil then x collect (list x y))
+        @result{} ((0 nil) (1 0) (2 1) (3 2) (4 3))
 @end example
 
 @noindent
@@ -2537,7 +2164,7 @@ that was just set by the previous clause; in the second loop,
 based on the value of @code{x} left over from the previous time
 through the loop.
 
-Another feature of the @code{loop} macro is @dfn{destructuring},
+Another feature of the @code{cl-loop} macro is @dfn{destructuring},
 similar in concept to the destructuring provided by @code{defmacro}.
 The @var{var} part of any @code{for} clause can be given as a list
 of variables instead of a single variable.  The values produced
@@ -2545,8 +2172,8 @@ during loop execution must be lists; the values in the lists are
 stored in the corresponding variables.
 
 @example
-(loop for (x y) in '((2 3) (4 5) (6 7)) collect (+ x y))
-     @result{} (5 9 13)
+(cl-loop for (x y) in '((2 3) (4 5) (6 7)) collect (+ x y))
+        @result{} (5 9 13)
 @end example
 
 In loop destructuring, if there are more values than variables
@@ -2558,9 +2185,9 @@ lists of variables like @code{(x . y)} are allowed, so for example
 to process an alist
 
 @example
-(loop for (key . value) in '((a . 1) (b . 2))
-      collect value)
-     @result{} (1 2)
+(cl-loop for (key . value) in '((a . 1) (b . 2))
+         collect value)
+        @result{} (1 2)
 @end example
 
 @node Iteration Clauses
@@ -2577,8 +2204,8 @@ This clause simply counts up to the specified number using an
 internal temporary variable.  The loops
 
 @example
-(loop repeat (1+ n) do ...)
-(loop for temp to n do ...)
+(cl-loop repeat (1+ n) do ...)
+(cl-loop for temp to n do ...)
 @end example
 
 @noindent
@@ -2593,7 +2220,7 @@ that surrounds the second one:
 
 @example
 (while @var{cond} @var{forms}@dots{})
-(loop while @var{cond} do @var{forms}@dots{})
+(cl-loop while @var{cond} do @var{forms}@dots{})
 @end example
 
 @item until @var{condition}
@@ -2607,7 +2234,7 @@ the @code{finally} clauses are not executed.  If all the conditions
 were non-@code{nil}, the loop returns @code{t}:
 
 @example
-(if (loop for size in size-list always (> size 10))
+(if (cl-loop for size in size-list always (> size 10))
     (some-big-sizes)
   (no-big-sizes))
 @end example
@@ -2684,11 +2311,11 @@ It is valid for several accumulation clauses of the same type to
 accumulate into the same place.  From Steele:
 
 @example
-(loop for name in '(fred sue alice joe june)
-      for kids in '((bob ken) () () (kris sunshine) ())
-      collect name
-      append kids)
-     @result{} (fred bob ken sue alice joe kris sunshine june)
+(cl-loop for name in '(fred sue alice joe june)
+         for kids in '((bob ken) () () (kris sunshine) ())
+         collect name
+         append kids)
+        @result{} (fred bob ken sue alice joe kris sunshine june)
 @end example
 
 @node Other Clauses
@@ -2704,17 +2331,17 @@ otherwise leaves the variable alone during the loop.  The following
 loops are basically equivalent:
 
 @example
-(loop with x = 17 do ...)
-(let ((x 17)) (loop do ...))
-(loop for x = 17 then x do ...)
+(cl-loop with x = 17 do ...)
+(let ((x 17)) (cl-loop do ...))
+(cl-loop for x = 17 then x do ...)
 @end example
 
 Naturally, the variable @var{var} might be used for some purpose
 in the rest of the loop.  For example:
 
 @example
-(loop for x in my-list  with res = nil  do (push x res)
-      finally return res)
+(cl-loop for x in my-list  with res = nil  do (push x res)
+         finally return res)
 @end example
 
 This loop inserts the elements of @code{my-list} at the front of
@@ -2749,18 +2376,18 @@ by the name @code{it} in the ``then'' part.  For example:
 @example
 (setq funny-numbers '(6 13 -1))
      @result{} (6 13 -1)
-(loop for x below 10
-      if (oddp x)
-        collect x into odds
-        and if (memq x funny-numbers) return (cdr it) end
-      else
-        collect x into evens
-      finally return (vector odds evens))
-     @result{} [(1 3 5 7 9) (0 2 4 6 8)]
+(cl-loop for x below 10
+         if (oddp x)
+           collect x into odds
+           and if (memq x funny-numbers) return (cdr it) end
+         else
+           collect x into evens
+         finally return (vector odds evens))
+        @result{} [(1 3 5 7 9) (0 2 4 6 8)]
 (setq funny-numbers '(6 7 13 -1))
      @result{} (6 7 13 -1)
-(loop <@r{same thing again}>)
-     @result{} (13 -1)
+(cl-loop <@r{same thing again}>)
+        @result{} (13 -1)
 @end example
 
 Note the use of @code{and} to put two clauses into the ``then''
@@ -2823,20 +2450,20 @@ Of course, @code{return} is generally used inside an @code{if} or
 the loop would never get to ``loop'' more than once.
 
 The clause @samp{return @var{form}} is equivalent to
+@c FIXME cl-do, cl-return?
 @samp{do (return @var{form})} (or @code{return-from} if the loop
 was named).  The @code{return} clause is implemented a bit more
 efficiently, though.
 @end table
 
-While there is no high-level way to add user extensions to @code{loop}
-(comparable to @code{defsetf} for @code{setf}, say), this package
-does offer two properties called @code{cl-loop-handler} and
-@code{cl-loop-for-handler} which are functions to be called when
-a given symbol is encountered as a top-level loop clause or
-@code{for} clause, respectively.  Consult the source code in
-file @file{cl-macs.el} for details.
+While there is no high-level way to add user extensions to @code{cl-loop},
+this package does offer two properties called @code{cl-loop-handler}
+and @code{cl-loop-for-handler} which are functions to be called when a
+given symbol is encountered as a top-level loop clause or @code{for}
+clause, respectively.  Consult the source code in file
+@file{cl-macs.el} for details.
 
-This package's @code{loop} macro is compatible with that of Common
+This package's @code{cl-loop} macro is compatible with that of Common
 Lisp, except that a few features are not implemented:  @code{loop-finish}
 and data-type specifiers.  Naturally, the @code{for} clauses which
 iterate over keymaps, overlays, intervals, frames, windows, and
@@ -2851,35 +2478,28 @@ functions, by contrast, always return exactly one result.  This
 package makes no attempt to emulate Common Lisp multiple return
 values; Emacs versions of Common Lisp functions that return more
 than one value either return just the first value (as in
-@code{compiler-macroexpand}) or return a list of values (as in
-@code{get-setf-method}).  This package @emph{does} define placeholders
+@code{cl-compiler-macroexpand}) or return a list of values.
+This package @emph{does} define placeholders
 for the Common Lisp functions that work with multiple values, but
 in Emacs Lisp these functions simply operate on lists instead.
-The @code{values} form, for example, is a synonym for @code{list}
+The @code{cl-values} form, for example, is a synonym for @code{list}
 in Emacs.
 
-@defspec multiple-value-bind (var@dots{}) values-form forms@dots{}
+@defmac cl-multiple-value-bind (var@dots{}) values-form forms@dots{}
 This form evaluates @var{values-form}, which must return a list of
 values.  It then binds the @var{var}s to these respective values,
 as if by @code{let}, and then executes the body @var{forms}.
 If there are more @var{var}s than values, the extra @var{var}s
 are bound to @code{nil}.  If there are fewer @var{var}s than
 values, the excess values are ignored.
-@end defspec
+@end defmac
 
-@defspec multiple-value-setq (var@dots{}) form
+@defmac cl-multiple-value-setq (var@dots{}) form
 This form evaluates @var{form}, which must return a list of values.
 It then sets the @var{var}s to these respective values, as if by
 @code{setq}.  Extra @var{var}s or values are treated the same as
-in @code{multiple-value-bind}.
-@end defspec
-
-The older Quiroz package attempted a more faithful (but still
-imperfect) emulation of Common Lisp multiple values.  The old
-method ``usually'' simulated true multiple values quite well,
-but under certain circumstances would leave spurious return
-values in memory where a later, unrelated @code{multiple-value-bind}
-form would see them.
+in @code{cl-multiple-value-bind}.
+@end defmac
 
 Since a perfect emulation is not feasible in Emacs Lisp, this
 package opts to keep it as simple and predictable as possible.
@@ -2897,7 +2517,7 @@ for @code{defmacro} due to technical difficulties.
 Destructuring is made available to the user by way of the
 following macro:
 
-@defspec destructuring-bind arglist expr forms@dots{}
+@defmac cl-destructuring-bind arglist expr forms@dots{}
 This macro expands to code which executes @var{forms}, with
 the variables in @var{arglist} bound to the list of values
 returned by @var{expr}.  The @var{arglist} can include all
@@ -2906,13 +2526,13 @@ including destructuring.  (The @code{&environment} keyword
 is not allowed.)  The macro expansion will signal an error
 if @var{expr} returns a list of the wrong number of arguments
 or with incorrect keyword arguments.
-@end defspec
+@end defmac
 
-This package also includes the Common Lisp @code{define-compiler-macro}
+This package also includes the Common Lisp @code{cl-define-compiler-macro}
 facility, which allows you to define compile-time expansions and
 optimizations for your functions.
 
-@defspec define-compiler-macro name arglist forms@dots{}
+@defmac cl-define-compiler-macro name arglist forms@dots{}
 This form is similar to @code{defmacro}, except that it only expands
 calls to @var{name} at compile-time; calls processed by the Lisp
 interpreter are not expanded, nor are they expanded by the
@@ -2930,25 +2550,25 @@ For example, here is a simplified version of a definition that
 appears as a standard part of this package:
 
 @example
-(define-compiler-macro member* (&whole form a list &rest keys)
-  (if (and (null keys)
-           (eq (car-safe a) 'quote)
-           (not (floatp-safe (cadr a))))
-      (list 'memq a list)
-    form))
+(cl-define-compiler-macro cl-member (&whole form a list &rest keys)
+     (if (and (null keys)
+              (eq (car-safe a) 'quote)
+              (not (floatp-safe (cadr a))))
+         (list 'memq a list)
+       form))
 @end example
 
 @noindent
-This definition causes @code{(member* @var{a} @var{list})} to change
+This definition causes @code{(cl-member @var{a} @var{list})} to change
 to a call to the faster @code{memq} in the common case where @var{a}
 is a non-floating-point constant; if @var{a} is anything else, or
 if there are any keyword arguments in the call, then the original
-@code{member*} call is left intact.  (The actual compiler macro
-for @code{member*} optimizes a number of other cases, including
+@code{cl-member} call is left intact.  (The actual compiler macro
+for @code{cl-member} optimizes a number of other cases, including
 common @code{:test} predicates.)
-@end defspec
+@end defmac
 
-@defun compiler-macroexpand form
+@defun cl-compiler-macroexpand form
 This function is analogous to @code{macroexpand}, except that it
 expands compiler macros rather than regular macros.  It returns
 @var{form} unchanged if it is not a call to a function for which
@@ -2958,8 +2578,8 @@ decided to punt by returning its @code{&whole} argument.  Like
 for which no further expansion is possible.
 @end defun
 
-@xref{Macro Bindings}, for descriptions of the @code{macrolet}
-and @code{symbol-macrolet} forms for making ``local'' macro
+@xref{Macro Bindings}, for descriptions of the @code{cl-macrolet}
+and @code{cl-symbol-macrolet} forms for making ``local'' macro
 definitions.
 
 @node Declarations
@@ -2971,8 +2591,8 @@ mechanism that allows you to give the compiler special hints
 about the types of data that will be stored in particular variables,
 and about the ways those variables and functions will be used.  This
 package defines versions of all the Common Lisp declaration forms:
-@code{declare}, @code{locally}, @code{proclaim}, @code{declaim},
-and @code{the}.
+@code{cl-declare}, @code{cl-locally}, @code{cl-proclaim}, @code{cl-declaim},
+and @code{cl-the}.
 
 Most of the Common Lisp declarations are not currently useful in
 Emacs Lisp, as the byte-code system provides little opportunity
@@ -2982,53 +2602,53 @@ declarations are meaningful when the optimizing byte
 compiler is being used, however.  Under the earlier non-optimizing
 compiler, these declarations will effectively be ignored.
 
-@defun proclaim decl-spec
+@defun cl-proclaim decl-spec
 This function records a ``global'' declaration specified by
-@var{decl-spec}.  Since @code{proclaim} is a function, @var{decl-spec}
+@var{decl-spec}.  Since @code{cl-proclaim} is a function, @var{decl-spec}
 is evaluated and thus should normally be quoted.
 @end defun
 
-@defspec declaim decl-specs@dots{}
-This macro is like @code{proclaim}, except that it takes any number
+@defmac cl-declaim decl-specs@dots{}
+This macro is like @code{cl-proclaim}, except that it takes any number
 of @var{decl-spec} arguments, and the arguments are unevaluated and
-unquoted.  The @code{declaim} macro also puts an @code{(eval-when
+unquoted.  The @code{cl-declaim} macro also puts an @code{(cl-eval-when
 (compile load eval) ...)} around the declarations so that they will
 be registered at compile-time as well as at run-time.  (This is vital,
 since normally the declarations are meant to influence the way the
-compiler treats the rest of the file that contains the @code{declaim}
+compiler treats the rest of the file that contains the @code{cl-declaim}
 form.)
-@end defspec
+@end defmac
 
-@defspec declare decl-specs@dots{}
+@defmac cl-declare decl-specs@dots{}
 This macro is used to make declarations within functions and other
 code.  Common Lisp allows declarations in various locations, generally
 at the beginning of any of the many ``implicit @code{progn}s''
 throughout Lisp syntax, such as function bodies, @code{let} bodies,
-etc.  Currently the only declaration understood by @code{declare}
+etc.  Currently the only declaration understood by @code{cl-declare}
 is @code{special}.
-@end defspec
+@end defmac
 
-@defspec locally declarations@dots{} forms@dots{}
-In this package, @code{locally} is no different from @code{progn}.
-@end defspec
+@defmac cl-locally declarations@dots{} forms@dots{}
+In this package, @code{cl-locally} is no different from @code{progn}.
+@end defmac
 
-@defspec the type form
-Type information provided by @code{the} is ignored in this package;
-in other words, @code{(the @var{type} @var{form})} is equivalent
+@defmac cl-the type form
+Type information provided by @code{cl-the} is ignored in this package;
+in other words, @code{(cl-the @var{type} @var{form})} is equivalent
 to @var{form}.  Future versions of the optimizing byte-compiler may
 make use of this information.
 
 For example, @code{mapcar} can map over both lists and arrays.  It is
 hard for the compiler to expand @code{mapcar} into an in-line loop
 unless it knows whether the sequence will be a list or an array ahead
-of time.  With @code{(mapcar 'car (the vector foo))}, a future
+of time.  With @code{(mapcar 'car (cl-the vector foo))}, a future
 compiler would have enough information to expand the loop in-line.
 For now, Emacs Lisp will treat the above code as exactly equivalent
 to @code{(mapcar 'car foo)}.
-@end defspec
+@end defmac
 
-Each @var{decl-spec} in a @code{proclaim}, @code{declaim}, or
-@code{declare} should be a list beginning with a symbol that says
+Each @var{decl-spec} in a @code{cl-proclaim}, @code{cl-declaim}, or
+@code{cl-declare} should be a list beginning with a symbol that says
 what kind of declaration it is.  This package currently understands
 @code{special}, @code{inline}, @code{notinline}, @code{optimize},
 and @code{warn} declarations.  (The @code{warn} declaration is an
@@ -3045,16 +2665,16 @@ bound in the body of the function.  The compiler normally emits
 warnings for such references, since they could be typographical
 errors for references to local variables.
 
-The declaration @code{(declare (special @var{var1} @var{var2}))} is
+The declaration @code{(cl-declare (special @var{var1} @var{var2}))} is
 equivalent to @code{(defvar @var{var1}) (defvar @var{var2})} in the
 optimizing compiler, or to nothing at all in older compilers (which
 do not warn for non-local references).
 
 In top-level contexts, it is generally better to write
-@code{(defvar @var{var})} than @code{(declaim (special @var{var}))},
+@code{(defvar @var{var})} than @code{(cl-declaim (special @var{var}))},
 since @code{defvar} makes your intentions clearer.  But the older
 byte compilers can not handle @code{defvar}s appearing inside of
-functions, while @code{(declare (special @var{var}))} takes care
+functions, while @code{(cl-declare (special @var{var}))} takes care
 to work correctly with all compilers.
 
 @item inline
@@ -3072,8 +2692,9 @@ The following declarations are all equivalent.  Note that the
 and declare it inline all at once.
 
 @example
-(declaim (inline foo bar))
-(eval-when (compile load eval) (proclaim '(inline foo bar)))
+(cl-declaim (inline foo bar))
+(cl-eval-when (compile load eval)
+  (cl-proclaim '(inline foo bar)))
 (defsubst foo (...) ...)       ; instead of defun
 @end example
 
@@ -3083,10 +2704,10 @@ request that a function you have defined should be inlined,
 but it is impolite to use it to request inlining of an external
 function.
 
-In Common Lisp, it is possible to use @code{(declare (inline @dots{}))}
+In Common Lisp, it is possible to use @code{(cl-declare (inline @dots{}))}
 before a particular call to a function to cause just that call to
 be inlined; the current byte compilers provide no way to implement
-this, so @code{(declare (inline @dots{}))} is currently ignored by
+this, so @code{(cl-declare (inline @dots{}))} is currently ignored by
 this package.
 
 @item notinline
@@ -3103,15 +2724,15 @@ The word @code{optimize} is followed by any number of lists like
 @code{(speed 3)} or @code{(safety 2)}.  Common Lisp defines several
 optimization ``qualities''; this package ignores all but @code{speed}
 and @code{safety}.  The value of a quality should be an integer from
-0 to 3, with 0 meaning ``unimportant'' and 3 meaning ``very important.''
+0 to 3, with 0 meaning ``unimportant'' and 3 meaning ``very important''.
 The default level for both qualities is 1.
 
 In this package, with the optimizing compiler, the
-@code{speed} quality is tied to the @code{byte-compile-optimize}
+@code{speed} quality is tied to the @code{byte-optimize}
 flag, which is set to @code{nil} for @code{(speed 0)} and to
 @code{t} for higher settings; and the @code{safety} quality is
 tied to the @code{byte-compile-delete-errors} flag, which is
-set to @code{t} for @code{(safety 3)} and to @code{nil} for all
+set to @code{nil} for @code{(safety 3)} and to @code{t} for all
 lower settings.  (The latter flag controls whether the compiler
 is allowed to optimize out code whose only side-effect could
 be to signal an error, e.g., rewriting @code{(progn foo bar)} to
@@ -3125,10 +2746,10 @@ Emacs itself, Emacs will not crash with a segmentation fault
 just because of an error in a fully-optimized Lisp program.
 
 The @code{optimize} declaration is normally used in a top-level
-@code{proclaim} or @code{declaim} in a file; Common Lisp allows
-it to be used with @code{declare} to set the level of optimization
+@code{cl-proclaim} or @code{cl-declaim} in a file; Common Lisp allows
+it to be used with @code{cl-declare} to set the level of optimization
 locally for a given form, but this will not work correctly with the
-current version of the optimizing compiler.  (The @code{declare}
+current version of the optimizing compiler.  (The @code{cl-declare}
 will set the new optimization level, but that level will not
 automatically be unset after the enclosing form is done.)
 
@@ -3136,7 +2757,7 @@ automatically be unset after the enclosing form is done.)
 This declaration controls what sorts of warnings are generated
 by the byte compiler.  Again, only the optimizing compiler
 generates warnings.  The word @code{warn} is followed by any
-number of ``warning qualities,'' similar in form to optimization
+number of ``warning qualities'', similar in form to optimization
 qualities.  The currently supported warning types are
 @code{redefine}, @code{callargs}, @code{unresolved}, and
 @code{free-vars}; in the current system, a value of 0 will
@@ -3152,8 +2773,8 @@ This package defines several symbol-related features that were
 missing from Emacs Lisp.
 
 @menu
-* Property Lists::       @code{get*}, @code{remprop}, @code{getf}, @code{remf}.
-* Creating Symbols::     @code{gensym}, @code{gentemp}.
+* Property Lists::       @code{cl-get}, @code{cl-remprop}, @code{cl-getf}, @code{cl-remf}.
+* Creating Symbols::     @code{cl-gensym}, @code{cl-gentemp}.
 @end menu
 
 @node Property Lists
@@ -3165,18 +2786,18 @@ and @code{put} for operating on properties attached to symbols.
 There are also functions for working with property lists as
 first-class data structures not attached to particular symbols.
 
-@defun get* symbol property &optional default
+@defun cl-get symbol property &optional default
 This function is like @code{get}, except that if the property is
 not found, the @var{default} argument provides the return value.
 (The Emacs Lisp @code{get} function always uses @code{nil} as
-the default; this package's @code{get*} is equivalent to Common
+the default; this package's @code{cl-get} is equivalent to Common
 Lisp's @code{get}.)
 
-The @code{get*} function is @code{setf}-able; when used in this
+The @code{cl-get} function is @code{setf}-able; when used in this
 fashion, the @var{default} argument is allowed but ignored.
 @end defun
 
-@defun remprop symbol property
+@defun cl-remprop symbol property
 This function removes the entry for @var{property} from the property
 list of @var{symbol}.  It returns a true value if the property was
 indeed found and removed, or @code{nil} if there was no such property.
@@ -3184,10 +2805,10 @@ indeed found and removed, or @code{nil} if there was no such property.
 since @code{get} did not allow a @var{default}, it was very difficult
 to distinguish between a missing property and a property whose value
 was @code{nil}; thus, setting a property to @code{nil} was close
-enough to @code{remprop} for most purposes.)
+enough to @code{cl-remprop} for most purposes.)
 @end defun
 
-@defun getf place property &optional default
+@defun cl-getf place property &optional default
 This function scans the list @var{place} as if it were a property
 list, i.e., a list of alternating property names and values.  If
 an even-numbered element of @var{place} is found which is @code{eq}
@@ -3198,10 +2819,10 @@ is given).
 In particular,
 
 @example
-(get sym prop)  @equiv{}  (getf (symbol-plist sym) prop)
+(get sym prop)  @equiv{}  (cl-getf (symbol-plist sym) prop)
 @end example
 
-It is valid to use @code{getf} as a @code{setf} place, in which case
+It is valid to use @code{cl-getf} as a @code{setf} place, in which case
 its @var{place} argument must itself be a valid @code{setf} place.
 The @var{default} argument, if any, is ignored in this context.
 The effect is to change (via @code{setcar}) the value cell in the
@@ -3209,25 +2830,25 @@ list that corresponds to @var{property}, or to cons a new property-value
 pair onto the list if the property is not yet present.
 
 @example
-(put sym prop val)  @equiv{}  (setf (getf (symbol-plist sym) prop) val)
+(put sym prop val)  @equiv{}  (setf (cl-getf (symbol-plist sym) prop) val)
 @end example
 
-The @code{get} and @code{get*} functions are also @code{setf}-able.
+The @code{get} and @code{cl-get} functions are also @code{setf}-able.
 The fact that @code{default} is ignored can sometimes be useful:
 
 @example
-(incf (get* 'foo 'usage-count 0))
+(cl-incf (cl-get 'foo 'usage-count 0))
 @end example
 
 Here, symbol @code{foo}'s @code{usage-count} property is incremented
 if it exists, or set to 1 (an incremented 0) otherwise.
 
-When not used as a @code{setf} form, @code{getf} is just a regular
+When not used as a @code{setf} form, @code{cl-getf} is just a regular
 function and its @var{place} argument can actually be any Lisp
 expression.
 @end defun
 
-@defspec remf place property
+@defmac cl-remf place property
 This macro removes the property-value pair for @var{property} from
 the property list stored at @var{place}, which is any @code{setf}-able
 place expression.  It returns true if the property was found.  Note
@@ -3235,11 +2856,7 @@ that if @var{property} happens to be first on the list, this will
 effectively do a @code{(setf @var{place} (cddr @var{place}))},
 whereas if it occurs later, this simply uses @code{setcdr} to splice
 out the property and value cells.
-@end defspec
-
-@iftex
-@secno=2
-@end iftex
+@end defmac
 
 @node Creating Symbols
 @section Creating Symbols
@@ -3248,7 +2865,7 @@ out the property and value cells.
 These functions create unique symbols, typically for use as
 temporary variables.
 
-@defun gensym &optional x
+@defun cl-gensym &optional x
 This function creates a new, uninterned symbol (using @code{make-symbol})
 with a unique name.  (The name of an uninterned symbol is relevant
 only if the symbol is printed.)  By default, the name is generated
@@ -3260,31 +2877,30 @@ their names will not conflict with ``real'' variables in the user's
 code.
 @end defun
 
-@defvar *gensym-counter*
-This variable holds the counter used to generate @code{gensym} names.
-It is incremented after each use by @code{gensym}.  In Common Lisp
+@defvar cl--gensym-counter
+This variable holds the counter used to generate @code{cl-gensym} names.
+It is incremented after each use by @code{cl-gensym}.  In Common Lisp
 this is initialized with 0, but this package initializes it with a
 random (time-dependent) value to avoid trouble when two files that
-each used @code{gensym} in their compilation are loaded together.
+each used @code{cl-gensym} in their compilation are loaded together.
 (Uninterned symbols become interned when the compiler writes them
 out to a file and the Emacs loader loads them, so their names have to
 be treated a bit more carefully than in Common Lisp where uninterned
 symbols remain uninterned after loading.)
 @end defvar
 
-@defun gentemp &optional x
-This function is like @code{gensym}, except that it produces a new
+@defun cl-gentemp &optional x
+This function is like @code{cl-gensym}, except that it produces a new
 @emph{interned} symbol.  If the symbol that is generated already
 exists, the function keeps incrementing the counter and trying
 again until a new symbol is generated.
 @end defun
 
-The Quiroz @file{cl.el} package also defined a @code{defkeyword}
-form for creating self-quoting keyword symbols.  This package
-automatically creates all keywords that are called for by
-@code{&key} argument specifiers, and discourages the use of
-keywords as data unrelated to keyword arguments, so the
-@code{defkeyword} form has been discontinued.
+This package automatically creates all keywords that are called for by
+@code{&key} argument specifiers, and discourages the use of keywords
+as data unrelated to keyword arguments, so the related function
+@code{defkeyword} (to create self-quoting keyword symbols) is not
+provided.
 
 @node Numbers
 @chapter Numbers
@@ -3294,16 +2910,12 @@ This section defines a few simple Common Lisp operations on numbers
 which were left out of Emacs Lisp.
 
 @menu
-* Predicates on Numbers::       @code{plusp}, @code{oddp}, @code{floatp-safe}, etc.
-* Numerical Functions::         @code{abs}, @code{floor*}, etc.
-* Random Numbers::              @code{random*}, @code{make-random-state}.
-* Implementation Parameters::   @code{most-positive-float}.
+* Predicates on Numbers::       @code{cl-plusp}, @code{cl-oddp}, @code{cl-floatp-safe}, etc.
+* Numerical Functions::         @code{abs}, @code{cl-floor}, etc.
+* Random Numbers::              @code{cl-random}, @code{cl-make-random-state}.
+* Implementation Parameters::   @code{cl-most-positive-float}.
 @end menu
 
-@iftex
-@secno=1
-@end iftex
-
 @node Predicates on Numbers
 @section Predicates on Numbers
 
@@ -3311,66 +2923,58 @@ which were left out of Emacs Lisp.
 These functions return @code{t} if the specified condition is
 true of the numerical argument, or @code{nil} otherwise.
 
-@defun plusp number
+@defun cl-plusp number
 This predicate tests whether @var{number} is positive.  It is an
 error if the argument is not a number.
 @end defun
 
-@defun minusp number
+@defun cl-minusp number
 This predicate tests whether @var{number} is negative.  It is an
 error if the argument is not a number.
 @end defun
 
-@defun oddp integer
+@defun cl-oddp integer
 This predicate tests whether @var{integer} is odd.  It is an
 error if the argument is not an integer.
 @end defun
 
-@defun evenp integer
+@defun cl-evenp integer
 This predicate tests whether @var{integer} is even.  It is an
 error if the argument is not an integer.
 @end defun
 
-@defun floatp-safe object
+@defun cl-floatp-safe object
 This predicate tests whether @var{object} is a floating-point
 number.  On systems that support floating-point, this is equivalent
 to @code{floatp}.  On other systems, this always returns @code{nil}.
 @end defun
 
-@iftex
-@secno=3
-@end iftex
-
 @node Numerical Functions
 @section Numerical Functions
 
 @noindent
 These functions perform various arithmetic operations on numbers.
 
-@defun gcd &rest integers
+@defun cl-gcd &rest integers
 This function returns the Greatest Common Divisor of the arguments.
 For one argument, it returns the absolute value of that argument.
 For zero arguments, it returns zero.
 @end defun
 
-@defun lcm &rest integers
+@defun cl-lcm &rest integers
 This function returns the Least Common Multiple of the arguments.
 For one argument, it returns the absolute value of that argument.
 For zero arguments, it returns one.
 @end defun
 
-@defun isqrt integer
+@defun cl-isqrt integer
 This function computes the ``integer square root'' of its integer
 argument, i.e., the greatest integer less than or equal to the true
 square root of the argument.
 @end defun
 
-@defun floor* number &optional divisor
-This function implements the Common Lisp @code{floor} function.
-It is called @code{floor*} to avoid name conflicts with the
-simpler @code{floor} function built-in to Emacs.
-
-With one argument, @code{floor*} returns a list of two numbers:
+@defun cl-floor number &optional divisor
+With one argument, @code{cl-floor} returns a list of two numbers:
 The argument rounded down (toward minus infinity) to an integer,
 and the ``remainder'' which would have to be added back to the
 first return value to yield the argument again.  If the argument
@@ -3379,37 +2983,37 @@ If the argument is a floating-point number, the first
 result is a Lisp integer and the second is a Lisp float between
 0 (inclusive) and 1 (exclusive).
 
-With two arguments, @code{floor*} divides @var{number} by
+With two arguments, @code{cl-floor} divides @var{number} by
 @var{divisor}, and returns the floor of the quotient and the
 corresponding remainder as a list of two numbers.  If
-@code{(floor* @var{x} @var{y})} returns @code{(@var{q} @var{r})},
+@code{(cl-floor @var{x} @var{y})} returns @code{(@var{q} @var{r})},
 then @code{@var{q}*@var{y} + @var{r} = @var{x}}, with @var{r}
 between 0 (inclusive) and @var{r} (exclusive).  Also, note
-that @code{(floor* @var{x})} is exactly equivalent to
-@code{(floor* @var{x} 1)}.
+that @code{(cl-floor @var{x})} is exactly equivalent to
+@code{(cl-floor @var{x} 1)}.
 
 This function is entirely compatible with Common Lisp's @code{floor}
 function, except that it returns the two results in a list since
 Emacs Lisp does not support multiple-valued functions.
 @end defun
 
-@defun ceiling* number &optional divisor
+@defun cl-ceiling number &optional divisor
 This function implements the Common Lisp @code{ceiling} function,
 which is analogous to @code{floor} except that it rounds the
 argument or quotient of the arguments up toward plus infinity.
 The remainder will be between 0 and minus @var{r}.
 @end defun
 
-@defun truncate* number &optional divisor
+@defun cl-truncate number &optional divisor
 This function implements the Common Lisp @code{truncate} function,
 which is analogous to @code{floor} except that it rounds the
 argument or quotient of the arguments toward zero.  Thus it is
-equivalent to @code{floor*} if the argument or quotient is
-positive, or to @code{ceiling*} otherwise.  The remainder has
+equivalent to @code{cl-floor} if the argument or quotient is
+positive, or to @code{cl-ceiling} otherwise.  The remainder has
 the same sign as @var{number}.
 @end defun
 
-@defun round* number &optional divisor
+@defun cl-round number &optional divisor
 This function implements the Common Lisp @code{round} function,
 which is analogous to @code{floor} except that it rounds the
 argument or quotient of the arguments to the nearest integer.
@@ -3417,26 +3021,16 @@ In the case of a tie (the argument or quotient is exactly
 halfway between two integers), it rounds to the even integer.
 @end defun
 
-@defun mod* number divisor
+@defun cl-mod number divisor
 This function returns the same value as the second return value
-of @code{floor}.
+of @code{cl-floor}.
 @end defun
 
-@defun rem* number divisor
+@defun cl-rem number divisor
 This function returns the same value as the second return value
-of @code{truncate}.
+of @code{cl-truncate}.
 @end defun
 
-These definitions are compatible with those in the Quiroz
-@file{cl.el} package, except that this package appends @samp{*}
-to certain function names to avoid conflicts with existing
-Emacs functions, and that the mechanism for returning
-multiple values is different.
-
-@iftex
-@secno=8
-@end iftex
-
 @node Random Numbers
 @section Random Numbers
 
@@ -3447,32 +3041,32 @@ algorithm, which is much more likely to give statistically clean
 random numbers than the simple generators supplied by many
 operating systems.
 
-@defun random* number &optional state
+@defun cl-random number &optional state
 This function returns a random nonnegative number less than
 @var{number}, and of the same type (either integer or floating-point).
 The @var{state} argument should be a @code{random-state} object
 which holds the state of the random number generator.  The
 function modifies this state object as a side effect.  If
 @var{state} is omitted, it defaults to the variable
-@code{*random-state*}, which contains a pre-initialized
+@code{cl--random-state}, which contains a pre-initialized
 @code{random-state} object.
 @end defun
 
-@defvar *random-state*
+@defvar cl--random-state
 This variable contains the system ``default'' @code{random-state}
-object, used for calls to @code{random*} that do not specify an
+object, used for calls to @code{cl-random} that do not specify an
 alternative state object.  Since any number of programs in the
-Emacs process may be accessing @code{*random-state*} in interleaved
+Emacs process may be accessing @code{cl--random-state} in interleaved
 fashion, the sequence generated from this variable will be
 irreproducible for all intents and purposes.
 @end defvar
 
-@defun make-random-state &optional state
+@defun cl-make-random-state &optional state
 This function creates or copies a @code{random-state} object.
 If @var{state} is omitted or @code{nil}, it returns a new copy of
-@code{*random-state*}.  This is a copy in the sense that future
-sequences of calls to @code{(random* @var{n})} and
-@code{(random* @var{n} @var{s})} (where @var{s} is the new
+@code{cl--random-state}.  This is a copy in the sense that future
+sequences of calls to @code{(cl-random @var{n})} and
+@code{(cl-random @var{n} @var{s})} (where @var{s} is the new
 random-state object) will return identical sequences of random
 numbers.
 
@@ -3487,13 +3081,13 @@ different sequence of random numbers.
 It is valid to print a @code{random-state} object to a buffer or
 file and later read it back with @code{read}.  If a program wishes
 to use a sequence of pseudo-random numbers which can be reproduced
-later for debugging, it can call @code{(make-random-state t)} to
+later for debugging, it can call @code{(cl-make-random-state t)} to
 get a new sequence, then print this sequence to a file.  When the
 program is later rerun, it can read the original run's random-state
 from the file.
 @end defun
 
-@defun random-state-p object
+@defun cl-random-state-p object
 This predicate returns @code{t} if @var{object} is a
 @code{random-state} object, or @code{nil} otherwise.
 @end defun
@@ -3512,7 +3106,7 @@ function that must be called before the parameters can be used.
 
 @defun cl-float-limits
 This function makes sure that the Common Lisp floating-point parameters
-like @code{most-positive-float} have been initialized.  Until it is
+like @code{cl-most-positive-float} have been initialized.  Until it is
 called, these parameters will be @code{nil}.  If this version of Emacs
 does not support floats, the parameters will remain @code{nil}.  If the
 parameters have already been initialized, the function returns
@@ -3530,50 +3124,50 @@ precisions, it has families of constants like
 floating-point precision, so this package omits the precision word
 from the constants' names.
 
-@defvar most-positive-float
+@defvar cl-most-positive-float
 This constant equals the largest value a Lisp float can hold.
 For those systems whose arithmetic supports infinities, this is
 the largest @emph{finite} value.  For IEEE machines, the value
 is approximately @code{1.79e+308}.
 @end defvar
 
-@defvar most-negative-float
+@defvar cl-most-negative-float
 This constant equals the most-negative value a Lisp float can hold.
-(It is assumed to be equal to @code{(- most-positive-float)}.)
+(It is assumed to be equal to @code{(- cl-most-positive-float)}.)
 @end defvar
 
-@defvar least-positive-float
+@defvar cl-least-positive-float
 This constant equals the smallest Lisp float value greater than zero.
 For IEEE machines, it is about @code{4.94e-324} if denormals are
 supported or @code{2.22e-308} if not.
 @end defvar
 
-@defvar least-positive-normalized-float
+@defvar cl-least-positive-normalized-float
 This constant equals the smallest @emph{normalized} Lisp float greater
 than zero, i.e., the smallest value for which IEEE denormalization
 will not result in a loss of precision.  For IEEE machines, this
 value is about @code{2.22e-308}.  For machines that do not support
 the concept of denormalization and gradual underflow, this constant
-will always equal @code{least-positive-float}.
+will always equal @code{cl-least-positive-float}.
 @end defvar
 
-@defvar least-negative-float
-This constant is the negative counterpart of @code{least-positive-float}.
+@defvar cl-least-negative-float
+This constant is the negative counterpart of @code{cl-least-positive-float}.
 @end defvar
 
-@defvar least-negative-normalized-float
+@defvar cl-least-negative-normalized-float
 This constant is the negative counterpart of
-@code{least-positive-normalized-float}.
+@code{cl-least-positive-normalized-float}.
 @end defvar
 
-@defvar float-epsilon
+@defvar cl-float-epsilon
 This constant is the smallest positive Lisp float that can be added
 to 1.0 to produce a distinct value.  Adding a smaller number to 1.0
 will yield 1.0 again due to roundoff.  For IEEE machines, epsilon
 is about @code{2.22e-16}.
 @end defvar
 
-@defvar float-negative-epsilon
+@defvar cl-float-negative-epsilon
 This is the smallest positive value that can be subtracted from
 1.0 to produce a distinct value.  For IEEE machines, it is about
 @code{1.11e-16}.
@@ -3590,10 +3184,10 @@ Emacs Lisp includes a few of these, notably @code{elt} and
 
 @menu
 * Sequence Basics::          Arguments shared by all sequence functions.
-* Mapping over Sequences::   @code{mapcar*}, @code{mapcan}, @code{map}, @code{every}, etc.
-* Sequence Functions::       @code{subseq}, @code{remove*}, @code{substitute}, etc.
-* Searching Sequences::      @code{find}, @code{position}, @code{count}, @code{search}, etc.
-* Sorting Sequences::        @code{sort*}, @code{stable-sort}, @code{merge}.
+* Mapping over Sequences::   @code{cl-mapcar}, @code{cl-mapcan}, @code{cl-map}, @code{cl-every}, etc.
+* Sequence Functions::       @code{cl-subseq}, @code{cl-remove}, @code{cl-substitute}, etc.
+* Searching Sequences::      @code{cl-find}, @code{cl-position}, @code{cl-count}, @code{cl-search}, etc.
+* Sorting Sequences::        @code{cl-sort}, @code{cl-stable-sort}, @code{cl-merge}.
 @end menu
 
 @node Sequence Basics
@@ -3607,7 +3201,7 @@ may appear in any order.
 The @code{:key} argument should be passed either @code{nil}, or a
 function of one argument.  This key function is used as a filter
 through which the elements of the sequence are seen; for example,
-@code{(find x y :key 'car)} is similar to @code{(assoc* x y)}:
+@code{(cl-find x y :key 'car)} is similar to @code{(cl-assoc x y)}:
 It searches for an element of the list whose @code{car} equals
 @code{x}, rather than for an element which equals @code{x} itself.
 If @code{:key} is omitted or @code{nil}, the filter is effectively
@@ -3632,7 +3226,7 @@ and sequence elements match if the predicate returns true on them
 (or false in the case of @code{-if-not}).  For example:
 
 @example
-(remove* 0 seq :test '=)  @equiv{}  (remove-if 'zerop seq)
+(cl-remove 0 seq :test '=)  @equiv{}  (cl-remove-if 'zerop seq)
 @end example
 
 @noindent
@@ -3662,14 +3256,14 @@ are called on various elements.  Therefore, it is a bad idea to depend
 on side effects of these functions.  For example, @code{:from-end}
 may cause the sequence to be scanned actually in reverse, or it may
 be scanned forwards but computing a result ``as if'' it were scanned
-backwards.  (Some functions, like @code{mapcar*} and @code{every},
+backwards.  (Some functions, like @code{cl-mapcar} and @code{cl-every},
 @emph{do} specify exactly the order in which the function is called
 so side effects are perfectly acceptable in those cases.)
 
 Strings may contain ``text properties'' as well
 as character data.  Except as noted, it is undefined whether or
 not text properties are preserved by sequence functions.  For
-example, @code{(remove* ?A @var{str})} may or may not preserve
+example, @code{(cl-remove ?A @var{str})} may or may not preserve
 the properties of the characters copied from @var{str} into the
 result.
 
@@ -3681,7 +3275,7 @@ These functions ``map'' the function you specify over the elements
 of lists or arrays.  They are all variations on the theme of the
 built-in function @code{mapcar}.
 
-@defun mapcar* function seq &rest more-seqs
+@defun cl-mapcar function seq &rest more-seqs
 This function calls @var{function} on successive parallel sets of
 elements from its argument sequences.  Given a single @var{seq}
 argument it is equivalent to @code{mapcar}; given @var{n} sequences,
@@ -3694,86 +3288,89 @@ is always a list.
 
 Common Lisp's @code{mapcar} accepts multiple arguments but works
 only on lists; Emacs Lisp's @code{mapcar} accepts a single sequence
-argument.  This package's @code{mapcar*} works as a compatible
+argument.  This package's @code{cl-mapcar} works as a compatible
 superset of both.
 @end defun
 
-@defun map result-type function seq &rest more-seqs
+@defun cl-map result-type function seq &rest more-seqs
 This function maps @var{function} over the argument sequences,
-just like @code{mapcar*}, but it returns a sequence of type
+just like @code{cl-mapcar}, but it returns a sequence of type
 @var{result-type} rather than a list.  @var{result-type} must
 be one of the following symbols: @code{vector}, @code{string},
 @code{list} (in which case the effect is the same as for
-@code{mapcar*}), or @code{nil} (in which case the results are
-thrown away and @code{map} returns @code{nil}).
+@code{cl-mapcar}), or @code{nil} (in which case the results are
+thrown away and @code{cl-map} returns @code{nil}).
 @end defun
 
-@defun maplist function list &rest more-lists
+@defun cl-maplist function list &rest more-lists
 This function calls @var{function} on each of its argument lists,
 then on the @code{cdr}s of those lists, and so on, until the
 shortest list runs out.  The results are returned in the form
-of a list.  Thus, @code{maplist} is like @code{mapcar*} except
+of a list.  Thus, @code{cl-maplist} is like @code{cl-mapcar} except
 that it passes in the list pointers themselves rather than the
 @code{car}s of the advancing pointers.
 @end defun
 
 @defun cl-mapc function seq &rest more-seqs
-This function is like @code{mapcar*}, except that the values returned
+This function is like @code{cl-mapcar}, except that the values returned
 by @var{function} are ignored and thrown away rather than being
 collected into a list.  The return value of @code{cl-mapc} is @var{seq},
 the first sequence.  This function is more general than the Emacs
-primitive @code{mapc}.
+primitive @code{mapc}.  (Note that this function is called
+@code{cl-mapc} even in @file{cl.el}, rather than @code{map*} as you
+might expect.)
+@c http://debbugs.gnu.org/6575
 @end defun
 
-@defun mapl function list &rest more-lists
-This function is like @code{maplist}, except that it throws away
+@defun cl-mapl function list &rest more-lists
+This function is like @code{cl-maplist}, except that it throws away
 the values returned by @var{function}.
 @end defun
 
-@defun mapcan function seq &rest more-seqs
-This function is like @code{mapcar*}, except that it concatenates
+@defun cl-mapcan function seq &rest more-seqs
+This function is like @code{cl-mapcar}, except that it concatenates
 the return values (which must be lists) using @code{nconc},
 rather than simply collecting them into a list.
 @end defun
 
-@defun mapcon function list &rest more-lists
-This function is like @code{maplist}, except that it concatenates
+@defun cl-mapcon function list &rest more-lists
+This function is like @code{cl-maplist}, except that it concatenates
 the return values using @code{nconc}.
 @end defun
 
-@defun some predicate seq &rest more-seqs
+@defun cl-some predicate seq &rest more-seqs
 This function calls @var{predicate} on each element of @var{seq}
 in turn; if @var{predicate} returns a non-@code{nil} value,
 @code{some} returns that value, otherwise it returns @code{nil}.
 Given several sequence arguments, it steps through the sequences
 in parallel until the shortest one runs out, just as in
-@code{mapcar*}.  You can rely on the left-to-right order in which
+@code{cl-mapcar}.  You can rely on the left-to-right order in which
 the elements are visited, and on the fact that mapping stops
 immediately as soon as @var{predicate} returns non-@code{nil}.
 @end defun
 
-@defun every predicate seq &rest more-seqs
+@defun cl-every predicate seq &rest more-seqs
 This function calls @var{predicate} on each element of the sequence(s)
 in turn; it returns @code{nil} as soon as @var{predicate} returns
 @code{nil} for any element, or @code{t} if the predicate was true
 for all elements.
 @end defun
 
-@defun notany predicate seq &rest more-seqs
+@defun cl-notany predicate seq &rest more-seqs
 This function calls @var{predicate} on each element of the sequence(s)
 in turn; it returns @code{nil} as soon as @var{predicate} returns
 a non-@code{nil} value for any element, or @code{t} if the predicate
 was @code{nil} for all elements.
 @end defun
 
-@defun notevery predicate seq &rest more-seqs
+@defun cl-notevery predicate seq &rest more-seqs
 This function calls @var{predicate} on each element of the sequence(s)
 in turn; it returns a non-@code{nil} value as soon as @var{predicate}
 returns @code{nil} for any element, or @code{t} if the predicate was
 true for all elements.
 @end defun
 
-@defun reduce function seq @t{&key :from-end :start :end :initial-value :key}
+@defun cl-reduce function seq @t{&key :from-end :start :end :initial-value :key}
 This function combines the elements of @var{seq} using an associative
 binary operation.  Suppose @var{function} is @code{*} and @var{seq} is
 the list @code{(2 3 4 5)}.  The first two elements of the list are
@@ -3781,16 +3378,16 @@ combined with @code{(* 2 3) = 6}; this is combined with the next
 element, @code{(* 6 4) = 24}, and that is combined with the final
 element: @code{(* 24 5) = 120}.  Note that the @code{*} function happens
 to be self-reducing, so that @code{(* 2 3 4 5)} has the same effect as
-an explicit call to @code{reduce}.
+an explicit call to @code{cl-reduce}.
 
 If @code{:from-end} is true, the reduction is right-associative instead
 of left-associative:
 
 @example
-(reduce '- '(1 2 3 4))
-     @equiv{} (- (- (- 1 2) 3) 4) @result{} -8
-(reduce '- '(1 2 3 4) :from-end t)
-     @equiv{} (- 1 (- 2 (- 3 4))) @result{} -2
+(cl-reduce '- '(1 2 3 4))
+        @equiv{} (- (- (- 1 2) 3) 4) @result{} -8
+(cl-reduce '- '(1 2 3 4) :from-end t)
+        @equiv{} (- 1 (- 2 (- 3 4))) @result{} -2
 @end example
 
 If @code{:key} is specified, it is a function of one argument which
@@ -3807,7 +3404,7 @@ If the sequence is empty (and there is no initial value), then
 @end defun
 
 All of these mapping operations can be expressed conveniently in
-terms of the @code{loop} macro.  In compiled code, @code{loop} will
+terms of the @code{cl-loop} macro.  In compiled code, @code{cl-loop} will
 be faster since it generates the loop as in-line code with no
 function calls.
 
@@ -3818,7 +3415,7 @@ function calls.
 This section describes a number of Common Lisp functions for
 operating on sequences.
 
-@defun subseq sequence start &optional end
+@defun cl-subseq sequence start &optional end
 This function returns a given subsequence of the argument
 @var{sequence}, which may be a list, string, or vector.
 The indices @var{start} and @var{end} must be in range, and
@@ -3830,30 +3427,30 @@ with @var{sequence}.
 As an extension to Common Lisp, @var{start} and/or @var{end}
 may be negative, in which case they represent a distance back
 from the end of the sequence.  This is for compatibility with
-Emacs's @code{substring} function.  Note that @code{subseq} is
+Emacs's @code{substring} function.  Note that @code{cl-subseq} is
 the @emph{only} sequence function that allows negative
 @var{start} and @var{end}.
 
-You can use @code{setf} on a @code{subseq} form to replace a
+You can use @code{setf} on a @code{cl-subseq} form to replace a
 specified range of elements with elements from another sequence.
-The replacement is done as if by @code{replace}, described below.
+The replacement is done as if by @code{cl-replace}, described below.
 @end defun
 
-@defun concatenate result-type &rest seqs
+@defun cl-concatenate result-type &rest seqs
 This function concatenates the argument sequences together to
 form a result sequence of type @var{result-type}, one of the
 symbols @code{vector}, @code{string}, or @code{list}.  The
 arguments are always copied, even in cases such as
-@code{(concatenate 'list '(1 2 3))} where the result is
+@code{(cl-concatenate 'list '(1 2 3))} where the result is
 identical to an argument.
 @end defun
 
-@defun fill seq item @t{&key :start :end}
+@defun cl-fill seq item @t{&key :start :end}
 This function fills the elements of the sequence (or the specified
 part of the sequence) with the value @var{item}.
 @end defun
 
-@defun replace seq1 seq2 @t{&key :start1 :end1 :start2 :end2}
+@defun cl-replace seq1 seq2 @t{&key :start1 :end1 :start2 :end2}
 This function copies part of @var{seq2} into part of @var{seq1}.
 The sequence @var{seq1} is not stretched or resized; the amount
 of data copied is simply the shorter of the source and destination
@@ -3867,7 +3464,7 @@ start and end arguments specify overlapping regions, the effect
 is undefined.
 @end defun
 
-@defun remove* item seq @t{&key :test :test-not :key :count :start :end :from-end}
+@defun cl-remove item seq @t{&key :test :test-not :key :count :start :end :from-end}
 This returns a copy of @var{seq} with all elements matching
 @var{item} removed.  The result may share storage with or be
 @code{eq} to @var{seq} in some circumstances, but the original
@@ -3884,25 +3481,25 @@ end of the sequence rather than the beginning (this matters only
 if @var{count} was also specified).
 @end defun
 
-@defun delete* item seq @t{&key :test :test-not :key :count :start :end :from-end}
+@defun cl-delete item seq @t{&key :test :test-not :key :count :start :end :from-end}
 This deletes all elements of @var{seq} which match @var{item}.
 It is a destructive operation.  Since Emacs Lisp does not support
-stretchable strings or vectors, this is the same as @code{remove*}
-for those sequence types.  On lists, @code{remove*} will copy the
+stretchable strings or vectors, this is the same as @code{cl-remove}
+for those sequence types.  On lists, @code{cl-remove} will copy the
 list if necessary to preserve the original list, whereas
-@code{delete*} will splice out parts of the argument list.
+@code{cl-delete} will splice out parts of the argument list.
 Compare @code{append} and @code{nconc}, which are analogous
 non-destructive and destructive list operations in Emacs Lisp.
 @end defun
 
-@findex remove-if
-@findex remove-if-not
-@findex delete-if
-@findex delete-if-not
-The predicate-oriented functions @code{remove-if}, @code{remove-if-not},
-@code{delete-if}, and @code{delete-if-not} are defined similarly.
+@findex cl-remove-if
+@findex cl-remove-if-not
+@findex cl-delete-if
+@findex cl-delete-if-not
+The predicate-oriented functions @code{cl-remove-if}, @code{cl-remove-if-not},
+@code{cl-delete-if}, and @code{cl-delete-if-not} are defined similarly.
 
-@defun remove-duplicates seq @t{&key :test :test-not :key :start :end :from-end}
+@defun cl-remove-duplicates seq @t{&key :test :test-not :key :start :end :from-end}
 This function returns a copy of @var{seq} with duplicate elements
 removed.  Specifically, if two elements from the sequence match
 according to the @code{:test}, @code{:test-not}, and @code{:key}
@@ -3912,40 +3509,41 @@ is true, the leftmost one is retained instead.  If @code{:start} or
 examined or removed.
 @end defun
 
-@defun delete-duplicates seq @t{&key :test :test-not :key :start :end :from-end}
+@defun cl-delete-duplicates seq @t{&key :test :test-not :key :start :end :from-end}
 This function deletes duplicate elements from @var{seq}.  It is
-a destructive version of @code{remove-duplicates}.
+a destructive version of @code{cl-remove-duplicates}.
 @end defun
 
-@defun substitute new old seq @t{&key :test :test-not :key :count :start :end :from-end}
+@defun cl-substitute new old seq @t{&key :test :test-not :key :count :start :end :from-end}
 This function returns a copy of @var{seq}, with all elements
 matching @var{old} replaced with @var{new}.  The @code{:count},
 @code{:start}, @code{:end}, and @code{:from-end} arguments may be
 used to limit the number of substitutions made.
 @end defun
 
-@defun nsubstitute new old seq @t{&key :test :test-not :key :count :start :end :from-end}
-This is a destructive version of @code{substitute}; it performs
+@defun cl-nsubstitute new old seq @t{&key :test :test-not :key :count :start :end :from-end}
+This is a destructive version of @code{cl-substitute}; it performs
 the substitution using @code{setcar} or @code{aset} rather than
 by returning a changed copy of the sequence.
 @end defun
 
-@findex substitute-if
-@findex substitute-if-not
-@findex nsubstitute-if
-@findex nsubstitute-if-not
-The @code{substitute-if}, @code{substitute-if-not}, @code{nsubstitute-if},
-and @code{nsubstitute-if-not} functions are defined similarly.  For
-these, a @var{predicate} is given in place of the @var{old} argument.
+@findex cl-substitute-if
+@findex cl-substitute-if-not
+@findex cl-nsubstitute-if
+@findex cl-nsubstitute-if-not
+The functions @code{cl-substitute-if}, @code{cl-substitute-if-not},
+@code{cl-nsubstitute-if}, and @code{cl-nsubstitute-if-not} are defined
+similarly.  For these, a @var{predicate} is given in place of the
+@var{old} argument.
 
 @node Searching Sequences
 @section Searching Sequences
 
 @noindent
 These functions search for elements or subsequences in a sequence.
-(See also @code{member*} and @code{assoc*}; @pxref{Lists}.)
+(See also @code{cl-member} and @code{cl-assoc}; @pxref{Lists}.)
 
-@defun find item seq @t{&key :test :test-not :key :start :end :from-end}
+@defun cl-find item seq @t{&key :test :test-not :key :start :end :from-end}
 This function searches @var{seq} for an element matching @var{item}.
 If it finds a match, it returns the matching element.  Otherwise,
 it returns @code{nil}.  It returns the leftmost match, unless
@@ -3954,30 +3552,30 @@ match.  The @code{:start} and @code{:end} arguments may be used to
 limit the range of elements that are searched.
 @end defun
 
-@defun position item seq @t{&key :test :test-not :key :start :end :from-end}
-This function is like @code{find}, except that it returns the
+@defun cl-position item seq @t{&key :test :test-not :key :start :end :from-end}
+This function is like @code{cl-find}, except that it returns the
 integer position in the sequence of the matching item rather than
 the item itself.  The position is relative to the start of the
 sequence as a whole, even if @code{:start} is non-zero.  The function
 returns @code{nil} if no matching element was found.
 @end defun
 
-@defun count item seq @t{&key :test :test-not :key :start :end}
+@defun cl-count item seq @t{&key :test :test-not :key :start :end}
 This function returns the number of elements of @var{seq} which
 match @var{item}.  The result is always a nonnegative integer.
 @end defun
 
-@findex find-if
-@findex find-if-not
-@findex position-if
-@findex position-if-not
-@findex count-if
-@findex count-if-not
-The @code{find-if}, @code{find-if-not}, @code{position-if},
-@code{position-if-not}, @code{count-if}, and @code{count-if-not}
+@findex cl-find-if
+@findex cl-find-if-not
+@findex cl-position-if
+@findex cl-position-if-not
+@findex cl-count-if
+@findex cl-count-if-not
+The @code{cl-find-if}, @code{cl-find-if-not}, @code{cl-position-if},
+@code{cl-position-if-not}, @code{cl-count-if}, and @code{cl-count-if-not}
 functions are defined similarly.
 
-@defun mismatch seq1 seq2 @t{&key :test :test-not :key :start1 :end1 :start2 :end2 :from-end}
+@defun cl-mismatch seq1 seq2 @t{&key :test :test-not :key :start1 :end1 :start2 :end2 :from-end}
 This function compares the specified parts of @var{seq1} and
 @var{seq2}.  If they are the same length and the corresponding
 elements match (according to @code{:test}, @code{:test-not},
@@ -3992,11 +3590,11 @@ to left starting at @code{(1- @var{end1})} and @code{(1- @var{end2})}.
 If the sequences differ, then one plus the index of the rightmost
 difference (relative to @var{seq1}) is returned.
 
-An interesting example is @code{(mismatch str1 str2 :key 'upcase)},
+An interesting example is @code{(cl-mismatch str1 str2 :key 'upcase)},
 which compares two strings case-insensitively.
 @end defun
 
-@defun search seq1 seq2 @t{&key :test :test-not :key :from-end :start1 :end1 :start2 :end2}
+@defun cl-search seq1 seq2 @t{&key :test :test-not :key :from-end :start1 :end1 :start2 :end2}
 This function searches @var{seq2} for a subsequence that matches
 @var{seq1} (or part of it specified by @code{:start1} and
 @code{:end1}.)  Only matches which fall entirely within the region
@@ -4010,7 +3608,7 @@ function finds the @emph{rightmost} matching subsequence.
 @node Sorting Sequences
 @section Sorting Sequences
 
-@defun sort* seq predicate @t{&key :key}
+@defun clsort seq predicate @t{&key :key}
 This function sorts @var{seq} into increasing order as determined
 by using @var{predicate} to compare pairs of elements.  @var{predicate}
 should return true (non-@code{nil}) if and only if its first argument
@@ -4025,7 +3623,7 @@ accepts a @code{:key} argument which is used to preprocess data
 fed to the @var{predicate} function.  For example,
 
 @example
-(setq data (sort* data 'string-lessp :key 'downcase))
+(setq data (cl-sort data 'string-lessp :key 'downcase))
 @end example
 
 @noindent
@@ -4035,25 +3633,25 @@ would be useful for sorting association lists.  It should only be a
 simple accessor though, it's used heavily in the current
 implementation.
 
-The @code{sort*} function is destructive; it sorts lists by actually
+The @code{cl-sort} function is destructive; it sorts lists by actually
 rearranging the @code{cdr} pointers in suitable fashion.
 @end defun
 
-@defun stable-sort seq predicate @t{&key :key}
+@defun cl-stable-sort seq predicate @t{&key :key}
 This function sorts @var{seq} @dfn{stably}, meaning two elements
 which are equal in terms of @var{predicate} are guaranteed not to
 be rearranged out of their original order by the sort.
 
-In practice, @code{sort*} and @code{stable-sort} are equivalent
+In practice, @code{cl-sort} and @code{cl-stable-sort} are equivalent
 in Emacs Lisp because the underlying @code{sort} function is
 stable by default.  However, this package reserves the right to
-use non-stable methods for @code{sort*} in the future.
+use non-stable methods for @code{cl-sort} in the future.
 @end defun
 
-@defun merge type seq1 seq2 predicate @t{&key :key}
+@defun cl-merge type seq1 seq2 predicate @t{&key :key}
 This function merges two sequences @var{seq1} and @var{seq2} by
 interleaving their elements.  The result sequence, of type @var{type}
-(in the sense of @code{concatenate}), has length equal to the sum
+(in the sense of @code{cl-concatenate}), has length equal to the sum
 of the lengths of the two input sequences.  The sequences may be
 modified destructively.  Order of elements within @var{seq1} and
 @var{seq2} is preserved in the interleaving; elements of the two
@@ -4073,10 +3671,10 @@ a merged sequence which is (stably) sorted according to
 The functions described here operate on lists.
 
 @menu
-* List Functions::                @code{caddr}, @code{first}, @code{list*}, etc.
-* Substitution of Expressions::   @code{subst}, @code{sublis}, etc.
-* Lists as Sets::                 @code{member*}, @code{adjoin}, @code{union}, etc.
-* Association Lists::             @code{assoc*}, @code{rassoc*}, @code{acons}, @code{pairlis}.
+* List Functions::                @code{cl-caddr}, @code{cl-first}, @code{cl-list*}, etc.
+* Substitution of Expressions::   @code{cl-subst}, @code{cl-sublis}, etc.
+* Lists as Sets::                 @code{cl-member}, @code{cl-adjoin}, @code{cl-union}, etc.
+* Association Lists::             @code{cl-assoc}, @code{cl-rassoc}, @code{cl-acons}, @code{cl-pairlis}.
 @end menu
 
 @node List Functions
@@ -4086,7 +3684,7 @@ The functions described here operate on lists.
 This section describes a number of simple operations on lists,
 i.e., chains of cons cells.
 
-@defun caddr x
+@defun cl-caddr x
 This function is equivalent to @code{(car (cdr (cdr @var{x})))}.
 Likewise, this package defines all 28 @code{c@var{xxx}r} functions
 where @var{xxx} is up to four @samp{a}s and/or @samp{d}s.
@@ -4094,24 +3692,24 @@ All of these functions are @code{setf}-able, and calls to them
 are expanded inline by the byte-compiler for maximum efficiency.
 @end defun
 
-@defun first x
+@defun cl-first x
 This function is a synonym for @code{(car @var{x})}.  Likewise,
-the functions @code{second}, @code{third}, @dots{}, through
-@code{tenth} return the given element of the list @var{x}.
+the functions @code{cl-second}, @code{cl-third}, @dots{}, through
+@code{cl-tenth} return the given element of the list @var{x}.
 @end defun
 
-@defun rest x
+@defun cl-rest x
 This function is a synonym for @code{(cdr @var{x})}.
 @end defun
 
-@defun endp x
+@defun cl-endp x
 Common Lisp defines this function to act like @code{null}, but
 signaling an error if @code{x} is neither a @code{nil} nor a
-cons cell.  This package simply defines @code{endp} as a synonym
+cons cell.  This package simply defines @code{cl-endp} as a synonym
 for @code{null}.
 @end defun
 
-@defun list-length x
+@defun cl-list-length x
 This function returns the length of list @var{x}, exactly like
 @code{(length @var{x})}, except that if @var{x} is a circular
 list (where the cdr-chain forms a loop rather than terminating
@@ -4119,38 +3717,35 @@ with @code{nil}), this function returns @code{nil}.  (The regular
 @code{length} function would get stuck if given a circular list.)
 @end defun
 
-@defun list* arg &rest others
+@defun cl-list* arg &rest others
 This function constructs a list of its arguments.  The final
 argument becomes the @code{cdr} of the last cell constructed.
-Thus, @code{(list* @var{a} @var{b} @var{c})} is equivalent to
+Thus, @code{(cl-list* @var{a} @var{b} @var{c})} is equivalent to
 @code{(cons @var{a} (cons @var{b} @var{c}))}, and
-@code{(list* @var{a} @var{b} nil)} is equivalent to
+@code{(cl-list* @var{a} @var{b} nil)} is equivalent to
 @code{(list @var{a} @var{b})}.
-
-(Note that this function really is called @code{list*} in Common
-Lisp; it is not a name invented for this package like @code{member*}
-or @code{defun*}.)
 @end defun
 
-@defun ldiff list sublist
+@defun cl-ldiff list sublist
 If @var{sublist} is a sublist of @var{list}, i.e., is @code{eq} to
 one of the cons cells of @var{list}, then this function returns
 a copy of the part of @var{list} up to but not including
-@var{sublist}.  For example, @code{(ldiff x (cddr x))} returns
+@var{sublist}.  For example, @code{(cl-ldiff x (cddr x))} returns
 the first two elements of the list @code{x}.  The result is a
 copy; the original @var{list} is not modified.  If @var{sublist}
 is not a sublist of @var{list}, a copy of the entire @var{list}
 is returned.
 @end defun
 
-@defun copy-list list
+@defun cl-copy-list list
 This function returns a copy of the list @var{list}.  It copies
 dotted lists like @code{(1 2 . 3)} correctly.
 @end defun
 
 @defun copy-tree x &optional vecp
 This function returns a copy of the tree of cons cells @var{x}.
-Unlike @code{copy-sequence} (and its alias @code{copy-list}),
+@c FIXME? cl-copy-list is not an alias of copy-sequence.
+Unlike @code{copy-sequence} (and its alias @code{cl-copy-list}),
 which copies only along the @code{cdr} direction, this function
 copies (recursively) along both the @code{car} and the @code{cdr}
 directions.  If @var{x} is not a cons cell, the function simply
@@ -4159,7 +3754,7 @@ is true, this function copies vectors (recursively) as well as
 cons cells.
 @end defun
 
-@defun tree-equal x y @t{&key :test :test-not :key}
+@defun cl-tree-equal x y @t{&key :test :test-not :key}
 This function compares two trees of cons cells.  If @var{x} and
 @var{y} are both cons cells, their @code{car}s and @code{cdr}s are
 compared recursively.  If neither @var{x} nor @var{y} is a cons
@@ -4168,19 +3763,15 @@ specified test.  The @code{:key} function, if specified, is
 applied to the elements of both trees.  @xref{Sequences}.
 @end defun
 
-@iftex
-@secno=3
-@end iftex
-
 @node Substitution of Expressions
 @section Substitution of Expressions
 
 @noindent
 These functions substitute elements throughout a tree of cons
-cells.  (@xref{Sequence Functions}, for the @code{substitute}
+cells.  (@xref{Sequence Functions}, for the @code{cl-substitute}
 function, which works on just the top-level elements of a list.)
 
-@defun subst new old tree @t{&key :test :test-not :key}
+@defun cl-subst new old tree @t{&key :test :test-not :key}
 This function substitutes occurrences of @var{old} with @var{new}
 in @var{tree}, a tree of cons cells.  It returns a substituted
 tree, which will be a copy except that it may share storage with
@@ -4195,21 +3786,21 @@ The @code{:key} function is applied to the elements of the tree
 but not to @var{old}.
 @end defun
 
-@defun nsubst new old tree @t{&key :test :test-not :key}
-This function is like @code{subst}, except that it works by
+@defun cl-nsubst new old tree @t{&key :test :test-not :key}
+This function is like @code{cl-subst}, except that it works by
 destructive modification (by @code{setcar} or @code{setcdr})
 rather than copying.
 @end defun
 
-@findex subst-if
-@findex subst-if-not
-@findex nsubst-if
-@findex nsubst-if-not
-The @code{subst-if}, @code{subst-if-not}, @code{nsubst-if}, and
-@code{nsubst-if-not} functions are defined similarly.
+@findex cl-subst-if
+@findex cl-subst-if-not
+@findex cl-nsubst-if
+@findex cl-nsubst-if-not
+The @code{cl-subst-if}, @code{cl-subst-if-not}, @code{cl-nsubst-if}, and
+@code{cl-nsubst-if-not} functions are defined similarly.
 
-@defun sublis alist tree @t{&key :test :test-not :key}
-This function is like @code{subst}, except that it takes an
+@defun cl-sublis alist tree @t{&key :test :test-not :key}
+This function is like @code{cl-subst}, except that it takes an
 association list @var{alist} of @var{old}-@var{new} pairs.
 Each element of the tree (after applying the @code{:key}
 function, if any), is compared with the @code{car}s of
@@ -4217,8 +3808,8 @@ function, if any), is compared with the @code{car}s of
 @code{cdr}.
 @end defun
 
-@defun nsublis alist tree @t{&key :test :test-not :key}
-This is a destructive version of @code{sublis}.
+@defun cl-nsublis alist tree @t{&key :test :test-not :key}
+This is a destructive version of @code{cl-sublis}.
 @end defun
 
 @node Lists as Sets
@@ -4228,7 +3819,7 @@ This is a destructive version of @code{sublis}.
 These functions perform operations on lists which represent sets
 of elements.
 
-@defun member* item list @t{&key :test :test-not :key}
+@defun cl-member item list @t{&key :test :test-not :key}
 This function searches @var{list} for an element matching @var{item}.
 If a match is found, it returns the cons cell whose @code{car} was
 the matching element.  Otherwise, it returns @code{nil}.  Elements
@@ -4236,34 +3827,33 @@ are compared by @code{eql} by default; you can use the @code{:test},
 @code{:test-not}, and @code{:key} arguments to modify this behavior.
 @xref{Sequences}.
 
-Note that this function's name is suffixed by @samp{*} to avoid
-the incompatible @code{member} function defined in Emacs.
-(That function uses @code{equal} for comparisons; it is equivalent
-to @code{(member* @var{item} @var{list} :test 'equal)}.)
+The standard Emacs lisp function @code{member} uses @code{equal} for
+comparisons; it is equivalent to @code{(cl-member @var{item} @var{list}
+:test 'equal)}.
 @end defun
 
-@findex member-if
-@findex member-if-not
-The @code{member-if} and @code{member-if-not} functions
+@findex cl-member-if
+@findex cl-member-if-not
+The @code{cl-member-if} and @code{cl-member-if-not} functions
 analogously search for elements which satisfy a given predicate.
 
-@defun tailp sublist list
+@defun cl-tailp sublist list
 This function returns @code{t} if @var{sublist} is a sublist of
 @var{list}, i.e., if @var{sublist} is @code{eql} to @var{list} or to
 any of its @code{cdr}s.
 @end defun
 
-@defun adjoin item list @t{&key :test :test-not :key}
+@defun cl-adjoin item list @t{&key :test :test-not :key}
 This function conses @var{item} onto the front of @var{list},
 like @code{(cons @var{item} @var{list})}, but only if @var{item}
-is not already present on the list (as determined by @code{member*}).
+is not already present on the list (as determined by @code{cl-member}).
 If a @code{:key} argument is specified, it is applied to
 @var{item} as well as to the elements of @var{list} during
 the search, on the reasoning that @var{item} is ``about'' to
 become part of the list.
 @end defun
 
-@defun union list1 list2 @t{&key :test :test-not :key}
+@defun cl-union list1 list2 @t{&key :test :test-not :key}
 This function combines two lists which represent sets of items,
 returning a list that represents the union of those two sets.
 The result list will contain all items which appear in @var{list1}
@@ -4275,46 +3865,46 @@ result list.  The order of elements in the result list is also
 undefined.
 @end defun
 
-@defun nunion list1 list2 @t{&key :test :test-not :key}
-This is a destructive version of @code{union}; rather than copying,
+@defun cl-nunion list1 list2 @t{&key :test :test-not :key}
+This is a destructive version of @code{cl-union}; rather than copying,
 it tries to reuse the storage of the argument lists if possible.
 @end defun
 
-@defun intersection list1 list2 @t{&key :test :test-not :key}
+@defun cl-intersection list1 list2 @t{&key :test :test-not :key}
 This function computes the intersection of the sets represented
 by @var{list1} and @var{list2}.  It returns the list of items
 which appear in both @var{list1} and @var{list2}.
 @end defun
 
-@defun nintersection list1 list2 @t{&key :test :test-not :key}
-This is a destructive version of @code{intersection}.  It
+@defun cl-nintersection list1 list2 @t{&key :test :test-not :key}
+This is a destructive version of @code{cl-intersection}.  It
 tries to reuse storage of @var{list1} rather than copying.
 It does @emph{not} reuse the storage of @var{list2}.
 @end defun
 
-@defun set-difference list1 list2 @t{&key :test :test-not :key}
+@defun cl-set-difference list1 list2 @t{&key :test :test-not :key}
 This function computes the ``set difference'' of @var{list1}
 and @var{list2}, i.e., the set of elements that appear in
 @var{list1} but @emph{not} in @var{list2}.
 @end defun
 
-@defun nset-difference list1 list2 @t{&key :test :test-not :key}
-This is a destructive @code{set-difference}, which will try
+@defun cl-nset-difference list1 list2 @t{&key :test :test-not :key}
+This is a destructive @code{cl-set-difference}, which will try
 to reuse @var{list1} if possible.
 @end defun
 
-@defun set-exclusive-or list1 list2 @t{&key :test :test-not :key}
+@defun cl-set-exclusive-or list1 list2 @t{&key :test :test-not :key}
 This function computes the ``set exclusive or'' of @var{list1}
 and @var{list2}, i.e., the set of elements that appear in
 exactly one of @var{list1} and @var{list2}.
 @end defun
 
-@defun nset-exclusive-or list1 list2 @t{&key :test :test-not :key}
-This is a destructive @code{set-exclusive-or}, which will try
+@defun cl-nset-exclusive-or list1 list2 @t{&key :test :test-not :key}
+This is a destructive @code{cl-set-exclusive-or}, which will try
 to reuse @var{list1} and @var{list2} if possible.
 @end defun
 
-@defun subsetp list1 list2 @t{&key :test :test-not :key}
+@defun cl-subsetp list1 list2 @t{&key :test :test-not :key}
 This function checks whether @var{list1} represents a subset
 of @var{list2}, i.e., whether every element of @var{list1}
 also appears in @var{list2}.
@@ -4328,7 +3918,7 @@ An @dfn{association list} is a list representing a mapping from
 one set of values to another; any list whose elements are cons
 cells is an association list.
 
-@defun assoc* item a-list @t{&key :test :test-not :key}
+@defun cl-assoc item a-list @t{&key :test :test-not :key}
 This function searches the association list @var{a-list} for an
 element whose @code{car} matches (in the sense of @code{:test},
 @code{:test-not}, and @code{:key}, or by comparison with @code{eql})
@@ -4340,27 +3930,27 @@ are not cons cells.  (This corresponds to the behavior of
 elements of @var{a-list} to be an error.)
 @end defun
 
-@defun rassoc* item a-list @t{&key :test :test-not :key}
+@defun cl-rassoc item a-list @t{&key :test :test-not :key}
 This function searches for an element whose @code{cdr} matches
 @var{item}.  If @var{a-list} represents a mapping, this applies
 the inverse of the mapping to @var{item}.
 @end defun
 
-@findex assoc-if
-@findex assoc-if-not
-@findex rassoc-if
-@findex rassoc-if-not
-The @code{assoc-if}, @code{assoc-if-not}, @code{rassoc-if},
-and @code{rassoc-if-not} functions are defined similarly.
+@findex cl-assoc-if
+@findex cl-assoc-if-not
+@findex cl-rassoc-if
+@findex cl-rassoc-if-not
+The @code{cl-assoc-if}, @code{cl-assoc-if-not}, @code{cl-rassoc-if},
+and @code{cl-rassoc-if-not} functions are defined similarly.
 
 Two simple functions for constructing association lists are:
 
-@defun acons key value alist
+@defun cl-acons key value alist
 This is equivalent to @code{(cons (cons @var{key} @var{value}) @var{alist})}.
 @end defun
 
-@defun pairlis keys values &optional alist
-This is equivalent to @code{(nconc (mapcar* 'cons @var{keys} @var{values})
+@defun cl-pairlis keys values &optional alist
+This is equivalent to @code{(nconc (cl-mapcar 'cons @var{keys} @var{values})
 @var{alist})}.
 @end defun
 
@@ -4382,15 +3972,15 @@ system provides no way to create new distinct types, this package
 implements structures as vectors (or lists upon request) with a
 special ``tag'' symbol to identify them.
 
-@defspec defstruct name slots@dots{}
-The @code{defstruct} form defines a new structure type called
+@defmac cl-defstruct name slots@dots{}
+The @code{cl-defstruct} form defines a new structure type called
 @var{name}, with the specified @var{slots}.  (The @var{slots}
 may begin with a string which documents the structure type.)
 In the simplest case, @var{name} and each of the @var{slots}
 are symbols.  For example,
 
 @example
-(defstruct person name age sex)
+(cl-defstruct person name age sex)
 @end example
 
 @noindent
@@ -4401,14 +3991,14 @@ and @code{(person-sex @var{p})}.  You can also change these slots by
 using @code{setf} on any of these place forms:
 
 @example
-(incf (person-age birthday-boy))
+(cl-incf (person-age birthday-boy))
 @end example
 
 You can create a new @code{person} by calling @code{make-person},
 which takes keyword arguments @code{:name}, @code{:age}, and
 @code{:sex} to specify the initial values of these slots in the
 new object.  (Omitting any of these arguments leaves the corresponding
-slot ``undefined,'' according to the Common Lisp standard; in Emacs
+slot ``undefined'', according to the Common Lisp standard; in Emacs
 Lisp, such uninitialized slots are filled with @code{nil}.)
 
 Given a @code{person}, @code{(copy-person @var{p})} makes a new
@@ -4465,10 +4055,10 @@ the slot's value is determined when the object is created and does
 not change afterward.
 
 @example
-(defstruct person
-  (name nil :read-only t)
-  age
-  (sex 'unknown))
+(cl-defstruct person
+     (name nil :read-only t)
+     age
+     (sex 'unknown))
 @end example
 
 Any slot options other than @code{:read-only} are ignored.
@@ -4480,19 +4070,15 @@ by arguments.  (By contrast, slot options are key-value pairs not
 enclosed in lists.)
 
 @example
-(defstruct (person (:constructor create-person)
-                   (:type list)
-                   :named)
-  name age sex)
+(cl-defstruct (person (:constructor create-person)
+                      (:type list)
+                      :named)
+     name age sex)
 @end example
 
 The following structure options are recognized.
 
 @table @code
-@iftex
-@itemmax=0 in
-@advance@leftskip-.5@tableindent
-@end iftex
 @item :conc-name
 The argument is a symbol whose print name is used as the prefix for
 the names of slot accessor functions.  The default is the name of
@@ -4529,21 +4115,22 @@ as well unless you disable it with a simple-format @code{:constructor}
 option.
 
 @example
-(defstruct
- (person
-  (:constructor nil)   ; no default constructor
-  (:constructor new-person (name sex &optional (age 0)))
-  (:constructor new-hound (&key (name "Rover")
-                                (dog-years 0)
-                           &aux (age (* 7 dog-years))
-                                (sex 'canine))))
- name age sex)
+(cl-defstruct
+    (person
+     (:constructor nil)   ; no default constructor
+     (:constructor new-person
+                   (name sex &optional (age 0)))
+     (:constructor new-hound (&key (name "Rover")
+                                   (dog-years 0)
+                              &aux (age (* 7 dog-years))
+                                   (sex 'canine))))
+    name age sex)
 @end example
 
 The first constructor here takes its arguments positionally rather
 than by keyword.  (In official Common Lisp terminology, constructors
 that work By Order of Arguments instead of by keyword are called
-``BOA constructors.''  No, I'm not making this up.)  For example,
+``BOA constructors''.  No, I'm not making this up.)  For example,
 @code{(new-person "Jane" 'female)} generates a person whose slots
 are @code{"Jane"}, 0, and @code{female}, respectively.
 
@@ -4569,14 +4156,14 @@ ever generated.)
 
 In true Common Lisp, @code{typep} is always able to recognize a
 structure object even if @code{:predicate} was used.  In this
-package, @code{typep} simply looks for a function called
+package, @code{cl-typep} simply looks for a function called
 @code{@var{typename}-p}, so it will work for structure types
 only if they used the default predicate name.
 
 @item :include
 This option implements a very limited form of C++-style inheritance.
 The argument is the name of another structure type previously
-created with @code{defstruct}.  The effect is to cause the new
+created with @code{cl-defstruct}.  The effect is to cause the new
 structure type to inherit all of the included structure's slots
 (plus, of course, any new slots described by this struct's slot
 descriptors).  The new structure is considered a ``specialization''
@@ -4589,12 +4176,12 @@ slot descriptors for slots in the included structure, possibly with
 modified default values.  Borrowing an example from Steele:
 
 @example
-(defstruct person name (age 0) sex)
-     @result{} person
-(defstruct (astronaut (:include person (age 45)))
-  helmet-size
-  (favorite-beverage 'tang))
-     @result{} astronaut
+(cl-defstruct person name (age 0) sex)
+        @result{} person
+(cl-defstruct (astronaut (:include person (age 45)))
+     helmet-size
+     (favorite-beverage 'tang))
+        @result{} astronaut
 
 (setq joe (make-person :name "Joe"))
      @result{} [cl-struct-person "Joe" 0 nil]
@@ -4650,9 +4237,9 @@ use named vectors.  Therefore, @code{:named} is only useful in
 conjunction with @code{:type}.
 
 @example
-(defstruct (person1) name age sex)
-(defstruct (person2 (:type list) :named) name age sex)
-(defstruct (person3 (:type list)) name age sex)
+(cl-defstruct (person1) name age sex)
+(cl-defstruct (person2 (:type list) :named) name age sex)
+(cl-defstruct (person3 (:type list)) name age sex)
 
 (setq p1 (make-person1))
      @result{} [cl-struct-person1 nil nil nil]
@@ -4669,7 +4256,7 @@ conjunction with @code{:type}.
      @result{} error: function person3-p undefined
 @end example
 
-Since unnamed structures don't have tags, @code{defstruct} is not
+Since unnamed structures don't have tags, @code{cl-defstruct} is not
 able to make a useful predicate for recognizing them.  Also,
 accessors like @code{person3-name} will be generated but they
 will not be able to do any type checking.  The @code{person3-name}
@@ -4689,9 +4276,9 @@ the type @code{:include}s another type, then @code{:initial-offset}
 specifies a number of slots to be skipped between the last slot
 of the included type and the first new slot.
 @end table
-@end defspec
+@end defmac
 
-Except as noted, the @code{defstruct} facility of this package is
+Except as noted, the @code{cl-defstruct} facility of this package is
 entirely compatible with that of Common Lisp.
 
 @node Assertions
@@ -4708,10 +4295,10 @@ If the optimization property @code{speed} has been set to 3, and
 away the following assertions.  Because assertions might be optimized
 away, it is a bad idea for them to include side-effects.
 
-@defspec assert test-form [show-args string args@dots{}]
+@defmac cl-assert test-form [show-args string args@dots{}]
 This form verifies that @var{test-form} is true (i.e., evaluates to
 a non-@code{nil} value).  If so, it returns @code{nil}.  If the test
-is not satisfied, @code{assert} signals an error.
+is not satisfied, @code{cl-assert} signals an error.
 
 A default error message will be supplied which includes @var{test-form}.
 You can specify a different error message by including a @var{string}
@@ -4724,7 +4311,7 @@ will also include all non-constant arguments of the top-level
 @var{form}.  For example:
 
 @example
-(assert (> x 10) t "x is too small: %d")
+(cl-assert (> x 10) t "x is too small: %d")
 @end example
 
 This usage of @var{show-args} is an extension to Common Lisp.  In
@@ -4732,18 +4319,18 @@ true Common Lisp, the second argument gives a list of @var{places}
 which can be @code{setf}'d by the user before continuing from the
 error.  Since Emacs Lisp does not support continuable errors, it
 makes no sense to specify @var{places}.
-@end defspec
+@end defmac
 
-@defspec check-type form type [string]
+@defmac cl-check-type form type [string]
 This form verifies that @var{form} evaluates to a value of type
-@var{type}.  If so, it returns @code{nil}.  If not, @code{check-type}
+@var{type}.  If so, it returns @code{nil}.  If not, @code{cl-check-type}
 signals a @code{wrong-type-argument} error.  The default error message
 lists the erroneous value along with @var{type} and @var{form}
 themselves.  If @var{string} is specified, it is included in the
 error message in place of @var{type}.  For example:
 
 @example
-(check-type x (integer 1 *) "a positive integer")
+(cl-check-type x (integer 1 *) "a positive integer")
 @end example
 
 @xref{Type Predicates}, for a description of the type specifiers
@@ -4753,18 +4340,7 @@ Note that in Common Lisp, the first argument to @code{check-type}
 must be a @var{place} suitable for use by @code{setf}, because
 @code{check-type} signals a continuable error that allows the
 user to modify @var{place}.
-@end defspec
-
-The following error-related macro is also defined:
-
-@defspec ignore-errors forms@dots{}
-This executes @var{forms} exactly like a @code{progn}, except that
-errors are ignored during the @var{forms}.  More precisely, if
-an error is signaled then @code{ignore-errors} immediately
-aborts execution of the @var{forms} and returns @code{nil}.
-If the @var{forms} complete successfully, @code{ignore-errors}
-returns the result of the last @var{form}.
-@end defspec
+@end defmac
 
 @node Efficiency Concerns
 @appendix Efficiency Concerns
@@ -4772,38 +4348,35 @@ returns the result of the last @var{form}.
 @appendixsec Macros
 
 @noindent
-Many of the advanced features of this package, such as @code{defun*},
-@code{loop}, and @code{setf}, are implemented as Lisp macros.  In
+Many of the advanced features of this package, such as @code{cl-defun},
+@code{cl-loop}, etc., are implemented as Lisp macros.  In
 byte-compiled code, these complex notations will be expanded into
 equivalent Lisp code which is simple and efficient.  For example,
-the forms
+the form
 
 @example
-(incf i n)
-(push x (car p))
+(cl-incf i n)
 @end example
 
 @noindent
-are expanded at compile-time to the Lisp forms
+is expanded at compile-time to the Lisp form
 
 @example
 (setq i (+ i n))
-(setcar p (cons x (car p)))
 @end example
 
 @noindent
-which are the most efficient ways of doing these respective operations
+which is the most efficient ways of doing this operation
 in Lisp.  Thus, there is no performance penalty for using the more
-readable @code{incf} and @code{push} forms in your compiled code.
+readable @code{cl-incf} form in your compiled code.
 
 @emph{Interpreted} code, on the other hand, must expand these macros
 every time they are executed.  For this reason it is strongly
 recommended that code making heavy use of macros be compiled.
-(The features labeled ``Special Form'' instead of ``Function'' in
-this manual are macros.)  A loop using @code{incf} a hundred times
-will execute considerably faster if compiled, and will also
-garbage-collect less because the macro expansion will not have
-to be generated, used, and thrown away a hundred times.
+A loop using @code{cl-incf} a hundred times will execute considerably
+faster if compiled, and will also garbage-collect less because the
+macro expansion will not have to be generated, used, and thrown away a
+hundred times.
 
 You can find out how a macro expands by using the
 @code{cl-prettyexpand} function.
@@ -4813,10 +4386,10 @@ This function takes a single Lisp form as an argument and inserts
 a nicely formatted copy of it in the current buffer (which must be
 in Lisp mode so that indentation works properly).  It also expands
 all Lisp macros which appear in the form.  The easiest way to use
-this function is to go to the @code{*scratch*} buffer and type, say,
+this function is to go to the @file{*scratch*} buffer and type, say,
 
 @example
-(cl-prettyexpand '(loop for x below 10 collect x))
+(cl-prettyexpand '(cl-loop for x below 10 collect x))
 @end example
 
 @noindent
@@ -4824,36 +4397,36 @@ and type @kbd{C-x C-e} immediately after the closing parenthesis;
 the expansion
 
 @example
-(block nil
-  (let* ((x 0)
-         (G1004 nil))
-    (while (< x 10)
-      (setq G1004 (cons x G1004))
-      (setq x (+ x 1)))
-    (nreverse G1004)))
+(cl-block nil
+     (let* ((x 0)
+            (G1004 nil))
+       (while (< x 10)
+         (setq G1004 (cons x G1004))
+         (setq x (+ x 1)))
+       (nreverse G1004)))
 @end example
 
 @noindent
-will be inserted into the buffer.  (The @code{block} macro is
+will be inserted into the buffer.  (The @code{cl-block} macro is
 expanded differently in the interpreter and compiler, so
 @code{cl-prettyexpand} just leaves it alone.  The temporary
-variable @code{G1004} was created by @code{gensym}.)
+variable @code{G1004} was created by @code{cl-gensym}.)
 
 If the optional argument @var{full} is true, then @emph{all}
-macros are expanded, including @code{block}, @code{eval-when},
+macros are expanded, including @code{cl-block}, @code{cl-eval-when},
 and compiler macros.  Expansion is done as if @var{form} were
 a top-level form in a file being compiled.  For example,
 
 @example
-(cl-prettyexpand '(pushnew 'x list))
-     @print{} (setq list (adjoin 'x list))
-(cl-prettyexpand '(pushnew 'x list) t)
+(cl-prettyexpand '(cl-pushnew 'x list))
+     @print{} (setq list (cl-adjoin 'x list))
+(cl-prettyexpand '(cl-pushnew 'x list) t)
      @print{} (setq list (if (memq 'x list) list (cons 'x list)))
-(cl-prettyexpand '(caddr (member* 'a list)) t)
+(cl-prettyexpand '(caddr (cl-member 'a list)) t)
      @print{} (car (cdr (cdr (memq 'a list))))
 @end example
 
-Note that @code{adjoin}, @code{caddr}, and @code{member*} all
+Note that @code{cl-adjoin}, @code{cl-caddr}, and @code{cl-member} all
 have built-in compiler macros to optimize them in common cases.
 @end defun
 
@@ -4875,22 +4448,22 @@ phrase ``it is an error if'' to indicate a situation which is not
 supposed to arise in complying programs; implementations are strongly
 encouraged but not required to signal an error in these situations.
 This package sometimes omits such error checking in the interest of
-compactness and efficiency.  For example, @code{do} variable
+compactness and efficiency.  For example, @code{cl-do} variable
 specifiers are supposed to be lists of one, two, or three forms;
 extra forms are ignored by this package rather than signaling a
-syntax error.  The @code{endp} function is simply a synonym for
+syntax error.  The @code{cl-endp} function is simply a synonym for
 @code{null} in this package.  Functions taking keyword arguments
 will accept an odd number of arguments, treating the trailing
 keyword as if it were followed by the value @code{nil}.
 
-Argument lists (as processed by @code{defun*} and friends)
+Argument lists (as processed by @code{cl-defun} and friends)
 @emph{are} checked rigorously except for the minor point just
 mentioned; in particular, keyword arguments are checked for
 validity, and @code{&allow-other-keys} and @code{:allow-other-keys}
 are fully implemented.  Keyword validity checking is slightly
 time consuming (though not too bad in byte-compiled code);
 you can use @code{&allow-other-keys} to omit this check.  Functions
-defined in this package such as @code{find} and @code{member*}
+defined in this package such as @code{cl-find} and @code{cl-member}
 do check their keyword arguments for validity.
 
 @ifinfo
@@ -4904,10 +4477,10 @@ do check their keyword arguments for validity.
 Use of the optimizing Emacs compiler is highly recommended; many of the Common
 Lisp macros emit
 code which can be improved by optimization.  In particular,
-@code{block}s (whether explicit or implicit in constructs like
-@code{defun*} and @code{loop}) carry a fair run-time penalty; the
-optimizing compiler removes @code{block}s which are not actually
-referenced by @code{return} or @code{return-from} inside the block.
+@code{cl-block}s (whether explicit or implicit in constructs like
+@code{cl-defun} and @code{cl-loop}) carry a fair run-time penalty; the
+optimizing compiler removes @code{cl-block}s which are not actually
+referenced by @code{cl-return} or @code{cl-return-from} inside the block.
 
 @node Common Lisp Compatibility
 @appendix Common Lisp Compatibility
@@ -4916,42 +4489,38 @@ referenced by @code{return} or @code{return-from} inside the block.
 Following is a list of all known incompatibilities between this
 package and Common Lisp as documented in Steele (2nd edition).
 
-Certain function names, such as @code{member}, @code{assoc}, and
-@code{floor}, were already taken by (incompatible) Emacs Lisp
-functions; this package appends @samp{*} to the names of its
-Common Lisp versions of these functions.
-
-The word @code{defun*} is required instead of @code{defun} in order
+The word @code{cl-defun} is required instead of @code{defun} in order
 to use extended Common Lisp argument lists in a function.  Likewise,
-@code{defmacro*} and @code{function*} are versions of those forms
+@code{cl-defmacro} and @code{cl-function} are versions of those forms
 which understand full-featured argument lists.  The @code{&whole}
 keyword does not work in @code{defmacro} argument lists (except
 inside recursive argument lists).
 
 The @code{equal} predicate does not distinguish
-between IEEE floating-point plus and minus zero.  The @code{equalp}
+between IEEE floating-point plus and minus zero.  The @code{cl-equalp}
 predicate has several differences with Common Lisp; @pxref{Predicates}.
 
+@c FIXME no longer provided by cl.
 The @code{setf} mechanism is entirely compatible, except that
 setf-methods return a list of five values rather than five
 values directly.  Also, the new ``@code{setf} function'' concept
 (typified by @code{(defun (setf foo) @dots{})}) is not implemented.
 
-The @code{do-all-symbols} form is the same as @code{do-symbols}
+The @code{cl-do-all-symbols} form is the same as @code{cl-do-symbols}
 with no @var{obarray} argument.  In Common Lisp, this form would
 iterate over all symbols in all packages.  Since Emacs obarrays
 are not a first-class package mechanism, there is no way for
-@code{do-all-symbols} to locate any but the default obarray.
+@code{cl-do-all-symbols} to locate any but the default obarray.
 
-The @code{loop} macro is complete except that @code{loop-finish}
+The @code{cl-loop} macro is complete except that @code{loop-finish}
 and type specifiers are unimplemented.
 
 The multiple-value return facility treats lists as multiple
 values, since Emacs Lisp cannot support multiple return values
 directly.  The macros will be compatible with Common Lisp if
-@code{values} or @code{values-list} is always used to return to
-a @code{multiple-value-bind} or other multiple-value receiver;
-if @code{values} is used without @code{multiple-value-@dots{}}
+@code{cl-values} or @code{cl-values-list} is always used to return to
+a @code{cl-multiple-value-bind} or other multiple-value receiver;
+if @code{cl-values} is used without @code{cl-multiple-value-@dots{}}
 or vice-versa the effect will be different from Common Lisp.
 
 Many Common Lisp declarations are ignored, and others match
@@ -4960,117 +4529,16 @@ example, local @code{special} declarations, which are purely
 advisory in Emacs Lisp, do not rigorously obey the scoping rules
 set down in Steele's book.
 
-The variable @code{*gensym-counter*} starts out with a pseudo-random
+The variable @code{cl--gensym-counter} starts out with a pseudo-random
 value rather than with zero.  This is to cope with the fact that
 generated symbols become interned when they are written to and
 loaded back from a file.
 
-The @code{defstruct} facility is compatible, except that structures
+The @code{cl-defstruct} facility is compatible, except that structures
 are of type @code{:type vector :named} by default rather than some
 special, distinct type.  Also, the @code{:type} slot option is ignored.
 
-The second argument of @code{check-type} is treated differently.
-
-@node Old CL Compatibility
-@appendix Old CL Compatibility
-
-@noindent
-Following is a list of all known incompatibilities between this package
-and the older Quiroz @file{cl.el} package.
-
-This package's emulation of multiple return values in functions is
-incompatible with that of the older package.  That package attempted
-to come as close as possible to true Common Lisp multiple return
-values; unfortunately, it could not be 100% reliable and so was prone
-to occasional surprises if used freely.  This package uses a simpler
-method, namely replacing multiple values with lists of values, which
-is more predictable though more noticeably different from Common Lisp.
-
-The @code{defkeyword} form and @code{keywordp} function are not
-implemented in this package.
-
-The @code{member}, @code{floor}, @code{ceiling}, @code{truncate},
-@code{round}, @code{mod}, and @code{rem} functions are suffixed
-by @samp{*} in this package to avoid collision with existing
-functions in Emacs.  The older package simply
-redefined these functions, overwriting the built-in meanings and
-causing serious portability problems.  (Some more
-recent versions of the Quiroz package changed the names to
-@code{cl-member}, etc.; this package defines the latter names as
-aliases for @code{member*}, etc.)
-
-Certain functions in the old package which were buggy or inconsistent
-with the Common Lisp standard are incompatible with the conforming
-versions in this package.  For example, @code{eql} and @code{member}
-were synonyms for @code{eq} and @code{memq} in that package, @code{setf}
-failed to preserve correct order of evaluation of its arguments, etc.
-
-Finally, unlike the older package, this package is careful to
-prefix all of its internal names with @code{cl-}.  Except for a
-few functions which are explicitly defined as additional features
-(such as @code{floatp-safe} and @code{letf}), this package does not
-export any non-@samp{cl-} symbols which are not also part of Common
-Lisp.
-
-@ifinfo
-@example
-
-@end example
-@end ifinfo
-@appendixsec The @code{cl-compat} package
-
-@noindent
-The @code{CL} package includes emulations of some features of the
-old @file{cl.el}, in the form of a compatibility package
-@code{cl-compat}.  This file is obsolete and may be removed in future,
-so it should not be used in new code.
-
-The old package defined a number of internal routines without
-@code{cl-} prefixes or other annotations.  Call to these routines
-may have crept into existing Lisp code.  @code{cl-compat}
-provides emulations of the following internal routines:
-@code{pair-with-newsyms}, @code{zip-lists}, @code{unzip-lists},
-@code{reassemble-arglists}, @code{duplicate-symbols-p},
-@code{safe-idiv}.
-
-Some @code{setf} forms translated into calls to internal
-functions that user code might call directly.  The functions
-@code{setnth}, @code{setnthcdr}, and @code{setelt} fall in
-this category; they are defined by @code{cl-compat}, but the
-best fix is to change to use @code{setf} properly.
-
-The @code{cl-compat} file defines the keyword functions
-@code{keywordp}, @code{keyword-of}, and @code{defkeyword},
-which are not defined by the new @code{CL} package because the
-use of keywords as data is discouraged.
-
-The @code{build-klist} mechanism for parsing keyword arguments
-is emulated by @code{cl-compat}; the @code{with-keyword-args}
-macro is not, however, and in any case it's best to change to
-use the more natural keyword argument processing offered by
-@code{defun*}.
-
-Multiple return values are treated differently by the two
-Common Lisp packages.  The old package's method was more
-compatible with true Common Lisp, though it used heuristics
-that caused it to report spurious multiple return values in
-certain cases.  The @code{cl-compat} package defines a set
-of multiple-value macros that are compatible with the old
-CL package; again, they are heuristic in nature, but they
-are guaranteed to work in any case where the old package's
-macros worked.  To avoid name collision with the ``official''
-multiple-value facilities, the ones in @code{cl-compat} have
-capitalized names:  @code{Values}, @code{Values-list},
-@code{Multiple-value-bind}, etc.
-
-The functions @code{cl-floor}, @code{cl-ceiling}, @code{cl-truncate},
-and @code{cl-round} are defined by @code{cl-compat} to use the
-old-style multiple-value mechanism, just as they did in the old
-package.  The newer @code{floor*} and friends return their two
-results in a list rather than as multiple values.  Note that
-older versions of the old package used the unadorned names
-@code{floor}, @code{ceiling}, etc.; @code{cl-compat} cannot use
-these names because they conflict with Emacs built-ins.
+The second argument of @code{cl-check-type} is treated differently.
 
 @node Porting Common Lisp
 @appendix Porting Common Lisp
@@ -5100,19 +4568,17 @@ this convention, calls to Lisp builtins like @code{if} and
 
 @item
 Lexical scoping.  In Common Lisp, function arguments and @code{let}
-bindings apply only to references physically within their bodies
-(or within macro expansions in their bodies).  Emacs Lisp, by
-contrast, uses @dfn{dynamic scoping} wherein a binding to a
-variable is visible even inside functions called from the body.
-
-Variables in Common Lisp can be made dynamically scoped by
-declaring them @code{special} or using @code{defvar}.  In Emacs
-Lisp it is as if all variables were declared @code{special}.
-
-Often you can use code that was written for lexical scoping
-even in a dynamically scoped Lisp, but not always.  Here is
-an example of a Common Lisp code fragment that would fail in
-Emacs Lisp:
+bindings apply only to references physically within their bodies (or
+within macro expansions in their bodies).  Traditionally, Emacs Lisp
+uses @dfn{dynamic scoping} wherein a binding to a variable is visible
+even inside functions called from the body.
+@xref{Dynamic Binding,,,elisp,GNU Emacs Lisp Reference Manual}.
+Lexical binding is available since Emacs 24.1, so be sure to set
+@code{lexical-binding} to @code{t} if you need to emulate this aspect
+of Common Lisp.  @xref{Lexical Binding,,,elisp,GNU Emacs Lisp Reference Manual}.
+
+Here is an example of a Common Lisp code fragment that would fail in
+Emacs Lisp if @code{lexical-binding} were set to @code{nil}:
 
 @example
 (defun map-odd-elements (func list)
@@ -5125,20 +4591,16 @@ Emacs Lisp:
 @end example
 
 @noindent
-In Common Lisp, the two functions' usages of @code{x} are completely
-independent.  In Emacs Lisp, the binding to @code{x} made by
-@code{add-odd-elements} will have been hidden by the binding
-in @code{map-odd-elements} by the time the @code{(+ a x)} function
-is called.
-
-(This package avoids such problems in its own mapping functions
-by using names like @code{cl-x} instead of @code{x} internally;
-as long as you don't use the @code{cl-} prefix for your own
-variables no collision can occur.)
+With lexical binding, the two functions' usages of @code{x} are
+completely independent.  With dynamic binding, the binding to @code{x}
+made by @code{add-odd-elements} will have been hidden by the binding
+in @code{map-odd-elements} by the time the @code{(+ a x)} function is
+called.
 
-@xref{Lexical Bindings}, for a description of the @code{lexical-let}
-form which establishes a Common Lisp-style lexical binding, and some
-examples of how it differs from Emacs's regular @code{let}.
+Internally, this package uses lexical binding so that such problems do
+not occur.  @xref{Lexical Bindings}, for a description of the obsolete
+@code{lexical-let} form that emulates a Common Lisp-style lexical
+binding when dynamic binding is in use.
 
 @item
 Reader macros.  Common Lisp includes a second type of macro that
@@ -5178,7 +4640,7 @@ Lisp, they are totally distinct in Emacs Lisp.  Common Lisp
 programs which refer to a symbol by the full name sometimes
 and the short name other times will not port cleanly to Emacs.
 
-Emacs Lisp does have a concept of ``obarrays,'' which are
+Emacs Lisp does have a concept of ``obarrays'', which are
 package-like collections of symbols, but this feature is not
 strong enough to be used as a true package mechanism.
 
@@ -5198,10 +4660,10 @@ codes provide such features as paragraph filling, case
 conversion, and even loops and conditionals.
 
 While it would have been possible to implement most of Common
-Lisp @code{format} in this package (under the name @code{format*},
+Lisp @code{format} in this package (under the name @code{cl-format},
 of course), it was not deemed worthwhile.  It would have required
 a huge amount of code to implement even a decent subset of
-@code{format*}, yet the functionality it would provide over
+@code{cl-format}, yet the functionality it would provide over
 Emacs Lisp's @code{format} would rarely be useful.
 
 @item
@@ -5267,8 +4729,8 @@ where a more iteratively-minded programmer might write one of
 these forms:
 
 @example
-(let ((total 0)) (dolist (x my-list) (incf total x)) total)
-(loop for x in my-list sum x)
+(let ((total 0)) (dolist (x my-list) (cl-incf total x)) total)
+(cl-loop for x in my-list sum x)
 @end example
 
 While this would be mainly a stylistic choice in most Common Lisps,
@@ -5278,6 +4740,373 @@ note that the current Emacs Lisp compiler does not optimize tail
 recursion.
 @end itemize
 
+@node Obsolete Features
+@appendix Obsolete Features
+
+This section describes some features of the package that are obsolete
+and should not be used in new code.  They are either only provided by
+the old @file{cl.el} entry point, not by the newer @file{cl-lib.el};
+or where versions with a @samp{cl-} prefix do exist they do not behave
+in exactly the same way.
+
+@menu
+* Lexical Bindings::            An approximation of lexical binding.
+* Obsolete Lexical Macros::     Obsolete macros using lexical-let.
+* Obsolete Setf Customization:: Obsolete ways to customize setf.
+@end menu
+
+@node Lexical Bindings
+@appendixsec Lexical Bindings
+
+The following macros are extensions to Common Lisp, where all bindings
+are lexical unless declared otherwise.  These features are likewise
+obsolete since the introduction of true lexical binding in Emacs 24.1.
+
+@defmac lexical-let (bindings@dots{}) forms@dots{}
+This form is exactly like @code{let} except that the bindings it
+establishes are purely lexical.
+@end defmac
+
+@c FIXME remove this and refer to elisp manual.
+@c Maybe merge some stuff from here to there?
+@noindent
+Lexical bindings are similar to local variables in a language like C:
+Only the code physically within the body of the @code{lexical-let}
+(after macro expansion) may refer to the bound variables.
+
+@example
+(setq a 5)
+(defun foo (b) (+ a b))
+(let ((a 2)) (foo a))
+     @result{} 4
+(lexical-let ((a 2)) (foo a))
+     @result{} 7
+@end example
+
+@noindent
+In this example, a regular @code{let} binding of @code{a} actually
+makes a temporary change to the global variable @code{a}, so @code{foo}
+is able to see the binding of @code{a} to 2.  But @code{lexical-let}
+actually creates a distinct local variable @code{a} for use within its
+body, without any effect on the global variable of the same name.
+
+The most important use of lexical bindings is to create @dfn{closures}.
+A closure is a function object that refers to an outside lexical
+variable (@pxref{Closures,,,elisp,GNU Emacs Lisp Reference Manual}).
+For example:
+
+@example
+(defun make-adder (n)
+  (lexical-let ((n n))
+    (function (lambda (m) (+ n m)))))
+(setq add17 (make-adder 17))
+(funcall add17 4)
+     @result{} 21
+@end example
+
+@noindent
+The call @code{(make-adder 17)} returns a function object which adds
+17 to its argument.  If @code{let} had been used instead of
+@code{lexical-let}, the function object would have referred to the
+global @code{n}, which would have been bound to 17 only during the
+call to @code{make-adder} itself.
+
+@example
+(defun make-counter ()
+  (lexical-let ((n 0))
+    (cl-function (lambda (&optional (m 1)) (cl-incf n m)))))
+(setq count-1 (make-counter))
+(funcall count-1 3)
+     @result{} 3
+(funcall count-1 14)
+     @result{} 17
+(setq count-2 (make-counter))
+(funcall count-2 5)
+     @result{} 5
+(funcall count-1 2)
+     @result{} 19
+(funcall count-2)
+     @result{} 6
+@end example
+
+@noindent
+Here we see that each call to @code{make-counter} creates a distinct
+local variable @code{n}, which serves as a private counter for the
+function object that is returned.
+
+Closed-over lexical variables persist until the last reference to
+them goes away, just like all other Lisp objects.  For example,
+@code{count-2} refers to a function object which refers to an
+instance of the variable @code{n}; this is the only reference
+to that variable, so after @code{(setq count-2 nil)} the garbage
+collector would be able to delete this instance of @code{n}.
+Of course, if a @code{lexical-let} does not actually create any
+closures, then the lexical variables are free as soon as the
+@code{lexical-let} returns.
+
+Many closures are used only during the extent of the bindings they
+refer to; these are known as ``downward funargs'' in Lisp parlance.
+When a closure is used in this way, regular Emacs Lisp dynamic
+bindings suffice and will be more efficient than @code{lexical-let}
+closures:
+
+@example
+(defun add-to-list (x list)
+  (mapcar (lambda (y) (+ x y))) list)
+(add-to-list 7 '(1 2 5))
+     @result{} (8 9 12)
+@end example
+
+@noindent
+Since this lambda is only used while @code{x} is still bound,
+it is not necessary to make a true closure out of it.
+
+You can use @code{defun} or @code{flet} inside a @code{lexical-let}
+to create a named closure.  If several closures are created in the
+body of a single @code{lexical-let}, they all close over the same
+instance of the lexical variable.
+
+@defmac lexical-let* (bindings@dots{}) forms@dots{}
+This form is just like @code{lexical-let}, except that the bindings
+are made sequentially in the manner of @code{let*}.
+@end defmac
+
+@node Obsolete Lexical Macros
+@appendixsec Macros Defined Using Lexical-Let
+
+The following macros are defined using @code{lexical-let}.
+They are replaced by versions with a @samp{cl-} prefix that use true
+lexical binding (and hence rely on @code{lexical-binding} being set to
+@code{t} in code using them).
+
+@defmac flet (bindings@dots{}) forms@dots{}
+Replaced by @code{cl-flet} (@pxref{Function Bindings})
+or @code{cl-letf} (@pxref{Modify Macros}).
+@end defmac
+
+@defmac labels (bindings@dots{}) forms@dots{}
+Replaced by @code{cl-labels} (@pxref{Function Bindings}).
+@end defmac
+
+@defmac letf (bindings@dots{}) forms@dots{}
+This macro is almost exactly the same as @code{cl-letf}, which
+replaces it (@pxref{Modify Macros}).  The only difference is in
+details that relate to some deprecated usage of @code{symbol-function}
+in place forms.
+@end defmac
+
+@node Obsolete Setf Customization
+@appendixsec Obsolete Ways to Customize Setf
+
+Common Lisp defines three macros, @code{define-modify-macro},
+@code{defsetf}, and @code{define-setf-method}, that allow the
+user to extend generalized variables in various ways.
+In Emacs, these are obsolete, replaced by various features of
+@file{gv.el} in Emacs 24.3.
+@c FIXME details.
+
+@defmac define-modify-macro name arglist function [doc-string]
+This macro defines a ``read-modify-write'' macro similar to
+@code{cl-incf} and @code{cl-decf}.  The macro @var{name} is defined
+to take a @var{place} argument followed by additional arguments
+described by @var{arglist}.  The call
+
+@example
+(@var{name} @var{place} @var{args}...)
+@end example
+
+@noindent
+will be expanded to
+
+@example
+(cl-callf @var{func} @var{place} @var{args}...)
+@end example
+
+@noindent
+which in turn is roughly equivalent to
+
+@example
+(setf @var{place} (@var{func} @var{place} @var{args}...))
+@end example
+
+For example:
+
+@example
+(define-modify-macro cl-incf (&optional (n 1)) +)
+(define-modify-macro cl-concatf (&rest args) concat)
+@end example
+
+Note that @code{&key} is not allowed in @var{arglist}, but
+@code{&rest} is sufficient to pass keywords on to the function.
+
+Most of the modify macros defined by Common Lisp do not exactly
+follow the pattern of @code{define-modify-macro}.  For example,
+@code{push} takes its arguments in the wrong order, and @code{pop}
+is completely irregular.  You can define these macros ``by hand''
+using @code{get-setf-method}, or consult the source
+to see how to use the internal @code{setf} building blocks.
+@end defmac
+
+@defmac defsetf access-fn update-fn
+This is the simpler of two @code{defsetf} forms.  Where
+@var{access-fn} is the name of a function which accesses a place,
+this declares @var{update-fn} to be the corresponding store
+function.  From now on,
+
+@example
+(setf (@var{access-fn} @var{arg1} @var{arg2} @var{arg3}) @var{value})
+@end example
+
+@noindent
+will be expanded to
+
+@example
+(@var{update-fn} @var{arg1} @var{arg2} @var{arg3} @var{value})
+@end example
+
+@noindent
+The @var{update-fn} is required to be either a true function, or
+a macro which evaluates its arguments in a function-like way.  Also,
+the @var{update-fn} is expected to return @var{value} as its result.
+Otherwise, the above expansion would not obey the rules for the way
+@code{setf} is supposed to behave.
+
+As a special (non-Common-Lisp) extension, a third argument of @code{t}
+to @code{defsetf} says that the @code{update-fn}'s return value is
+not suitable, so that the above @code{setf} should be expanded to
+something more like
+
+@example
+(let ((temp @var{value}))
+  (@var{update-fn} @var{arg1} @var{arg2} @var{arg3} temp)
+  temp)
+@end example
+
+Some examples of the use of @code{defsetf}, drawn from the standard
+suite of setf methods, are:
+
+@example
+(defsetf car setcar)
+(defsetf symbol-value set)
+(defsetf buffer-name rename-buffer t)
+@end example
+@end defmac
+
+@defmac defsetf access-fn arglist (store-var) forms@dots{}
+This is the second, more complex, form of @code{defsetf}.  It is
+rather like @code{defmacro} except for the additional @var{store-var}
+argument.  The @var{forms} should return a Lisp form which stores
+the value of @var{store-var} into the generalized variable formed
+by a call to @var{access-fn} with arguments described by @var{arglist}.
+The @var{forms} may begin with a string which documents the @code{setf}
+method (analogous to the doc string that appears at the front of a
+function).
+
+For example, the simple form of @code{defsetf} is shorthand for
+
+@example
+(defsetf @var{access-fn} (&rest args) (store)
+  (append '(@var{update-fn}) args (list store)))
+@end example
+
+The Lisp form that is returned can access the arguments from
+@var{arglist} and @var{store-var} in an unrestricted fashion;
+macros like @code{setf} and @code{cl-incf} which invoke this
+setf-method will insert temporary variables as needed to make
+sure the apparent order of evaluation is preserved.
+
+Another example drawn from the standard package:
+
+@example
+(defsetf nth (n x) (store)
+  (list 'setcar (list 'nthcdr n x) store))
+@end example
+@end defmac
+
+@defmac define-setf-method access-fn arglist forms@dots{}
+This is the most general way to create new place forms.  When
+a @code{setf} to @var{access-fn} with arguments described by
+@var{arglist} is expanded, the @var{forms} are evaluated and
+must return a list of five items:
+
+@enumerate
+@item
+A list of @dfn{temporary variables}.
+
+@item
+A list of @dfn{value forms} corresponding to the temporary variables
+above.  The temporary variables will be bound to these value forms
+as the first step of any operation on the generalized variable.
+
+@item
+A list of exactly one @dfn{store variable} (generally obtained
+from a call to @code{gensym}).
+
+@item
+A Lisp form which stores the contents of the store variable into
+the generalized variable, assuming the temporaries have been
+bound as described above.
+
+@item
+A Lisp form which accesses the contents of the generalized variable,
+assuming the temporaries have been bound.
+@end enumerate
+
+This is exactly like the Common Lisp macro of the same name,
+except that the method returns a list of five values rather
+than the five values themselves, since Emacs Lisp does not
+support Common Lisp's notion of multiple return values.
+
+Once again, the @var{forms} may begin with a documentation string.
+
+A setf-method should be maximally conservative with regard to
+temporary variables.  In the setf-methods generated by
+@code{defsetf}, the second return value is simply the list of
+arguments in the place form, and the first return value is a
+list of a corresponding number of temporary variables generated
+by @code{cl-gensym}.  Macros like @code{setf} and @code{cl-incf} which
+use this setf-method will optimize away most temporaries that
+turn out to be unnecessary, so there is little reason for the
+setf-method itself to optimize.
+@end defmac
+
+@defun get-setf-method place &optional env
+This function returns the setf-method for @var{place}, by
+invoking the definition previously recorded by @code{defsetf}
+or @code{define-setf-method}.  The result is a list of five
+values as described above.  You can use this function to build
+your own @code{cl-incf}-like modify macros.  (Actually, it is
+@c FIXME?
+better to use the internal functions @code{cl-setf-do-modify}
+and @code{cl-setf-do-store}, which are a bit easier to use and
+which also do a number of optimizations; consult the source
+code for the @code{cl-incf} function for a simple example.)
+
+The argument @var{env} specifies the ``environment'' to be
+passed on to @code{macroexpand} if @code{get-setf-method} should
+need to expand a macro in @var{place}.  It should come from
+an @code{&environment} argument to the macro or setf-method
+that called @code{get-setf-method}.
+
+See also the source code for the setf-method for
+@c Also @code{apply}, but that is commented out.
+@code{substring}, which works by calling @code{get-setf-method} on a
+simpler case, then massaging the result.
+@end defun
+
+Modern Common Lisp defines a second, independent way to specify
+the @code{setf} behavior of a function, namely ``@code{setf}
+functions'' whose names are lists @code{(setf @var{name})}
+rather than symbols.  For example, @code{(defun (setf foo) @dots{})}
+defines the function that is used when @code{setf} is applied to
+@code{foo}.  This package does not currently support @code{setf}
+functions.  In particular, it is a compile-time error to use
+@code{setf} on a form which has not already been @code{defsetf}'d
+or otherwise declared; in newer Common Lisps, this would not be
+an error since the function @code{(setf @var{func})} might be
+defined later.
+
+
 @node GNU Free Documentation License
 @appendix GNU Free Documentation License
 @include doclicense.texi
diff --git a/doc/misc/emacs-mime.texi b/doc/misc/emacs-mime.texi
index 896eba2f1bb..e57fcc8adf1 100644
--- a/doc/misc/emacs-mime.texi
+++ b/doc/misc/emacs-mime.texi
@@ -1516,16 +1516,16 @@ Here's a bunch of time/date/second/day examples:
 @result{} 905595714.0
 
 (seconds-to-time 905595714.0)
-@result{} (13818 19266 0)
+@result{} (13818 19266 0 0)
 
 (time-to-days '(13818 19266))
 @result{} 729644
 
 (days-to-time 729644)
-@result{} (961933 65536)
+@result{} (961933 512)
 
 (time-since '(13818 19266))
-@result{} (0 430)
+@result{} (6797 9607 984839 247000)
 
 (time-less-p '(13818 19266) '(13818 19145))
 @result{} nil
@@ -1546,7 +1546,7 @@ Here's a bunch of time/date/second/day examples:
 (time-to-number-of-days
  (time-since
   (date-to-time "Mon, 01 Jan 2001 02:22:26 GMT")))
-@result{} 4.146122685185185
+@result{} 4314.095589286675
 @end example
 
 And finally, we have @code{safe-date-to-time}, which does the same as
@@ -1561,7 +1561,7 @@ An RFC822 (or similar) date string.  For instance: @code{"Sat Sep 12
 12:21:54 1998 +0200"}.
 
 @item time
-An internal Emacs time.  For instance: @code{(13818 26466)}.
+An internal Emacs time.  For instance: @code{(13818 26466 0 0)}.
 
 @item seconds
 A floating point representation of the internal Emacs time.  For
diff --git a/doc/misc/org.texi b/doc/misc/org.texi
index 89c99018460..a69dc0fd81f 100644
--- a/doc/misc/org.texi
+++ b/doc/misc/org.texi
@@ -857,7 +857,7 @@ Theory Ltd.}
 @b{Important:} @i{If you the version of Org that comes with Emacs or as a
 XEmacs package, please skip this section and go directly to @ref{Activation}.
 If you downloaded Org as an ELPA package, please read the instructions on the
-@uref{http://orgmode.org/elpa/, Org ELPA page}.  To see what version of Org
+@uref{http://orgmode.org/elpa.html, Org ELPA page}.  To see what version of Org
 (if any) is part of your Emacs distribution, type @kbd{M-x org-version} (if
 your Emacs distribution does not come with Org, this function will not be
 defined).}
@@ -964,13 +964,6 @@ on your system).
 make install-info
 @end example
 
-Then add the following line to @file{.emacs}.  It is needed so that
-Emacs can autoload functions that are located in files not immediately loaded
-when Org mode starts.
-@lisp
-(require 'org-install)
-@end lisp
-
 Do not forget to activate Org as described in the following section.
 @page
 
@@ -1092,9 +1085,6 @@ shown below.
 ;; add latest org-mode to load path
 (add-to-list 'load-path (expand-file-name "/path/to/org-mode/lisp"))
 (add-to-list 'load-path (expand-file-name "/path/to/org-mode/contrib/lisp" t))
-
-;; activate org
-(require 'org-install)
 @end example
 
 If an error occurs, a backtrace can be very useful (see below on how to
@@ -3785,7 +3775,7 @@ mostly if more than two TODO states are possible (@pxref{TODO
 extensions}).  See also @ref{Conflicts}, for a discussion of the interaction
 with @code{shift-selection-mode}.  See also the variable
 @code{org-treat-S-cursor-todo-selection-as-state-change}.
-@orgcmd{C-c / t,org-show-todo-key}
+@orgcmd{C-c / t,org-show-todo-tree}
 @cindex sparse tree, for TODO
 @vindex org-todo-keywords
 View TODO items in a @emph{sparse tree} (@pxref{Sparse trees}).  Folds the
@@ -9386,16 +9376,16 @@ so often, shortcuts are provided using the Easy Templates facility
 @item C-c '
 Edit the source code example at point in its native mode.  This works by
 switching to a temporary buffer with the source code.  You need to exit by
-pressing @kbd{C-c '} again@footnote{Upon exit, lines starting with @samp{*}
-or @samp{#} will get a comma prepended, to keep them from being interpreted
-by Org as outline nodes or special comments.  These commas will be stripped
-for editing with @kbd{C-c '}, and also for export.}.  The edited version will
-then replace the old version in the Org buffer.  Fixed-width regions
-(where each line starts with a colon followed by a space) will be edited
-using @code{artist-mode}@footnote{You may select a different-mode with the
-variable @code{org-edit-fixed-width-region-mode}.} to allow creating ASCII
-drawings easily.  Using this command in an empty line will create a new
-fixed-width region.
+pressing @kbd{C-c '} again@footnote{Upon exit, lines starting with @samp{*},
+@samp{,*}, @samp{#+} and @samp{,#+} will get a comma prepended, to keep them
+from being interpreted by Org as outline nodes or special syntax.  These
+commas will be stripped for editing with @kbd{C-c '}, and also for export.}.
+The edited version will then replace the old version in the Org buffer.
+Fixed-width regions (where each line starts with a colon followed by a space)
+will be edited using @code{artist-mode}@footnote{You may select
+a different-mode with the variable @code{org-edit-fixed-width-region-mode}.}
+to allow creating ASCII drawings easily.  Using this command in an empty line
+will create a new fixed-width region.
 @kindex C-c l
 @item C-c l
 Calling @code{org-store-link} while editing a source code example in a
@@ -14523,14 +14513,13 @@ Be sure to adjust the paths to fit your system.
 #
 DIR=`pwd`
 FILES=""
-ORGINSTALL="~/src/org/lisp/org-install.el"
 
 # wrap each argument in the code required to call tangle on it
 for i in $@@; do
     FILES="$FILES \"$i\""
 done
 
-emacs -Q --batch -l $ORGINSTALL \
+emacs -Q --batch \
 --eval "(progn
 (add-to-list 'load-path (expand-file-name \"~/src/org/lisp/\"))
 (add-to-list 'load-path (expand-file-name \"~/src/org/contrib/lisp/\" t))
diff --git a/doc/misc/tramp.texi b/doc/misc/tramp.texi
index 46f99acbb87..a983f76ffd3 100644
--- a/doc/misc/tramp.texi
+++ b/doc/misc/tramp.texi
@@ -2918,7 +2918,8 @@ information about remote hosts is kept in the file specified in
 @code{tramp-persistency-file-name}.  Keep this file.  If you are
 confident that files on remote hosts are not changed out of
 @value{emacsname}' control, set @code{remote-file-name-inhibit-cache}
-to @code{nil}.
+to @code{nil}.  Set also @code{tramp-completion-reread-directory-timeout}
+to @code{nil}, @ref{Filename completion}.
 
 Disable version control.  If you access remote files which are not
 under version control, a lot of check operations can be avoided by