auto upstream

34 files changed, 672 insertions, 301 deletions

diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 111a1594512..7c444a038af 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1,3 +1,8 @@
+2013-02-08  Glenn Morris  <rgm@gnu.org>
+
+        * keymaps.texi (Active Keymaps, Searching Keymaps):
+        Remove confusing mention of "symbolic prefix".  (Bug#13643)
+
 2013-01-19  Glenn Morris  <rgm@gnu.org>
 
         * macros.texi (Indenting Macros): Fix order of an indent
diff --git a/doc/lispref/keymaps.texi b/doc/lispref/keymaps.texi
index cb6c785905c..7c66bbec801 100644
--- a/doc/lispref/keymaps.texi
+++ b/doc/lispref/keymaps.texi
@@ -634,8 +634,8 @@ keymap, and the global keymap, in that order.  Emacs searches for each
 input key sequence in all these keymaps.  @xref{Searching Keymaps},
 for more details of this procedure.
 
-  When the key sequence starts with a mouse event (optionally preceded
-by a symbolic prefix), the active keymaps are determined based on the
+  When the key sequence starts with a mouse event,
+the active keymaps are determined based on the
 position in that event.  If the event happened on a string embedded
 with a @code{display}, @code{before-string}, or @code{after-string}
 property (@pxref{Special Properties}), the non-@code{nil} map
@@ -766,8 +766,7 @@ them:
 @var{find-in} and @var{find-in-any} are pseudo functions that search
 in one keymap and in an alist of keymaps, respectively.  (Searching a
 single keymap for a binding is called @dfn{key lookup}; see @ref{Key
-Lookup}.)  If the key sequence starts with a mouse event, or a
-symbolic prefix event followed by a mouse event, that event's position
+Lookup}.)  If the key sequence starts with a mouse event, that event's position
 is used instead of point and the current buffer.  Mouse events on an
 embedded string use non-@code{nil} text properties from that string
 instead of the buffer.  @var{temp-map} is a pseudo variable that
diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog
index 7ebaa5534d1..c0a454d31b5 100644
--- a/doc/misc/ChangeLog
+++ b/doc/misc/ChangeLog
@@ -1,3 +1,7 @@
+2013-02-08  Aidan Gauland  <aidalgol@no8wireless.co.nz>
+
+        * eshell.texi: Fill most of the missing sections.
+
 2013-02-07  Bastien Guerry  <bzg@gnu.org>
 
         * org.texi (References): Clarify an example.
diff --git a/doc/misc/eshell.texi b/doc/misc/eshell.texi
index 504940c5c6b..9825c90dd81 100644
--- a/doc/misc/eshell.texi
+++ b/doc/misc/eshell.texi
@@ -2,6 +2,7 @@
 @c %**start of header
 @setfilename ../../info/eshell
 @settitle Eshell: The Emacs Shell
+@defindex cm
 @synindex vr fn
 @c %**end of header
 
@@ -42,7 +43,7 @@ modify this GNU manual.''
 @c -release-
 @end ignore
 @sp 3
-@center John Wiegley
+@center John Wiegley & Aidan Gauland
 @c -date-
 
 @page
@@ -75,16 +76,15 @@ handling the sort of tasks accomplished by those tools.
 * What is Eshell?::             A brief introduction to the Emacs Shell.
 * Command basics::              The basics of command usage.
 * Commands::
-* Arguments::
+* Expansion::
 * Input/Output::
-* Process control::
 * Extension modules::
-* Extras and Goodies::
 * Bugs and ideas::              Known problems, and future ideas.
 * GNU Free Documentation License:: The license for this documentation.
 * Concept Index::
 * Function and Variable Index::
 * Key Index::
+* Command Index::
 @end menu
 
 @node What is Eshell?
@@ -278,83 +278,56 @@ on your mind.  Have fun!
 @node Commands
 @chapter Commands
 
+In a command shell, everything is done by invoking commands.  This
+chapter covers command invocations in Eshell, including the command
+history and invoking commands in a script file.
+
 @menu
 * Invocation::
-* Completion::
+* Arguments::
+* Variables::
+* Built-ins::
 * Aliases::
 * History::
+* Completion::
+* for loop::
 * Scripts::
-* Built-ins::
 @end menu
 
-Essentially, a command shell is all about invoking commands---and
-everything that entails.  So understanding how Eshell invokes commands
-is the key to comprehending how it all works.
-
 @node Invocation
 @section Invocation
-
 Unlike regular system shells, Eshell never invokes kernel functions
 directly, such as @code{exec(3)}.  Instead, it uses the Lisp functions
 available in the Emacs Lisp library.  It does this by transforming the
-command you specify into a callable Lisp form.@footnote{To see the Lisp
-form that will be invoked, type: @samp{eshell-parse-command "echo
-hello"}}
-
-This transformation, from the string of text typed at the command
-prompt, to the ultimate invocation of either a Lisp function or external
-command, follows these steps:
-
-@enumerate
-@item Parse the command string into separate arguments.
-@item
-@end enumerate
-
-@node Completion
-@section Completion
-
-@node Aliases
-@section Aliases
-
-@node History
-@section History
-
-Eshell knows a few built-in variables:
-
-@table @code
-
-@item $+
-@vindex $+
-This variable always contains the current working directory.
-
-@item $-
-@vindex $-
-This variable always contains the previous working directory (the
-current working directory from before the last @code{cd} command).
-
-@item $_
-@vindex $_
-It refers to the last argument of the last command.
-
-@item $$
-@vindex $$
-This is the result of the last command.  In case of an external
-command, it is @code{t} or @code{nil}.
-
-@item $?
-@vindex $?
-This variable contains the exit code of the last command (0 or 1 for
-Lisp functions, based on successful completion).
-
-@end table
-
-@node Scripts
-@section Scripts
+input line into a callable Lisp form.@footnote{To see the Lisp form that will be invoked, type: @samp{eshell-parse-command "echo hello"}}
+
+The command can be either an Elisp function or an external command.
+Eshell looks first for an @ref{Aliases, alias} with the same name as the
+command, then a @ref{Built-ins, built-in command} or a function with the
+same name; if there is no match, it then tries to execute it as an
+external command.
+
+The semicolon (@code{;}) can be used to separate multiple command
+invocations on a single line.  A command invocation followed by an
+ampersand (@code{&}) will be run in the background.  Eshell has no job
+control, so you can not suspend or background the current process, or
+bring a background process into the foreground.  That said, background
+processes invoked from Eshell can be controlled the same way as any
+other background process in Emacs.
 
+@node Arguments
+@section Arguments
+Command arguments are passed to the functions as either strings or
+numbers, depending on what the parser thinks they look like.  If you
+need to use a function that takes some other data type, you will need to
+call it in an Elisp expression (which can also be used with
+@ref{Expansion, expansions}).  As with other shells, you can
+escape special characters and spaces with the backslash (@code{\}) and
+the single (@code{''}) and double (@code{""}) quotes.
 
 @node Built-ins
-@section Built-in commands
 
+@section Built-in commands
 Several commands are built-in in Eshell.  In order to call the
 external variant of a built-in command @code{foo}, you could call
 @code{*foo}.  Usually, this should not be necessary.  You can check
@@ -368,7 +341,7 @@ eshell/ls is a compiled Lisp function in `em-ls.el'
 @end example
 
 If you want to discard a given built-in command, you could declare an
-alias, @ref{Aliases}.  Eample:
+alias, @ref{Aliases}.  Example:
 
 @example
 ~ $ which sudo
@@ -378,15 +351,96 @@ eshell/sudo is a compiled Lisp function in `em-unix.el'
 sudo is an alias, defined as "*sudo $*"
 @end example
 
-Some of the built-in commands have a special behavior in Eshell:
+@vindex eshell-prefer-lisp-functions
+If you would prefer to use the built-in commands instead of the external
+commands, set @var{eshell-prefer-lisp-functions} to @code{t}.
+
+Some of the built-in commands have different behaviour from their
+external counterparts, and some have no external counterpart.  Most of
+these will print a usage message when given the @code{--help} option.
 
 @table @code
 
+@item addpath
+@cmindex addpath
+Adds a given path or set of paths to the PATH environment variable, or,
+with no arguments, prints the current paths in this variable.
+
+@item alias
+@cmindex alias
+Define an alias (@pxref{Aliases}).  This does not add it to the aliases
+file.
+
+@item date
+@cmindex date
+Similar to, but slightly different from, the GNU Coreutils
+@command{date} command.
+
+@item define
+@cmindex define
+Define a varalias.  @xref{Variable Aliases, , , elisp}.
+
+@item diff
+@cmindex diff
+Use Emacs's internal @code{diff} (not to be confused with
+@code{ediff}).  @xref{Comparing Files, , , elisp}.
+
+@item grep
+@cmindex grep
+@itemx agrep
+@cmindex agrep
+@itemx egrep
+@cmindex egrep
+@itemx fgrep
+@cmindex fgrep
+@itemx glimpse
+@cmindex glimpse
+The @command{grep} commands are compatible with GNU @command{grep}, but
+use Emacs's internal @code{grep} instead.
+
+@item info
+@cmindex info
+Same as the external @command{info} command, but uses Emacs's internal
+Info reader.
+
+@item jobs
+@cmindex jobs
+List subprocesses of the Emacs process, if any, using the function
+@code{list-processes}.
+
+@item kill
+@cmindex kill
+Kill processes.  Takes a PID or a process object and an optional
+signal specifier.
+
+@item listify
+@cmindex listify
+Eshell version of @code{list}.  Allows you to create a list using Eshell
+syntax, rather than Elisp syntax.  For example, @samp{listify foo bar}
+and @code{("foo" "bar")} both evaluate to @code{("foo" "bar")}.
+
+@item locate
+@cmindex locate
+Alias to Emacs's @code{locate} function, which simply runs the external
+@command{locate} command and parses the results.  @xref{Dired and `find', , , elisp}.
+
+@item make
+@cmindex make
+Run @command{make} through @code{compile}.  @xref{Running Compilations under Emacs, , , elisp}.
+
+@item occur
+@cmindex occur
+Alias to Emacs's @code{occur}.  @xref{Other Search-and-Loop Commands, , , elisp}.
+
+@item printnl
+@cmindex printnl
+Print the arguments separated by newlines.
+
 @item cd
-@findex cd
+@cmindex cd
 This command changes the current working directory.  Usually, it is
-invoked as @samp{cd foo} where @file{foo} is the new working
-directory.  But @code{cd} knows about a few special arguments:
+invoked as @samp{cd foo} where @file{foo} is the new working directory.
+But @command{cd} knows about a few special arguments:
 
 When it receives no argument at all, it changes to the home directory.
 
@@ -396,14 +450,73 @@ directory (this is the same as @samp{cd $-}).
 The command @samp{cd =} shows the directory stack.  Each line is
 numbered.
 
-With @samp{cd =foo}, Eshell searches the directory stack for a
-directory matching the regular expression @samp{foo} and changes to
-that directory.
+With @samp{cd =foo}, Eshell searches the directory stack for a directory
+matching the regular expression @samp{foo} and changes to that
+directory.
 
 With @samp{cd -42}, you can access the directory stack by number.
 
-@item history
-@findex history
+@item su
+@cmindex su
+@itemx sudo
+@cmindex sudo
+Uses TRAMP's @command{su} or @command{sudo} method to run a command via
+@command{su} or @command{sudo}.
+
+@end table
+
+@section Built-in variables
+Eshell knows a few built-in variables:
+
+@table @code
+
+@item $+
+@vindex $+
+This variable always contains the current working directory.
+
+@item $-
+@vindex $-
+This variable always contains the previous working directory (the
+current working directory from before the last @code{cd} command).
+
+@item $_
+@vindex $_
+It refers to the last argument of the last command.
+
+@item $$
+@vindex $$
+This is the result of the last command.  In case of an external
+command, it is @code{t} or @code{nil}.
+
+@item $?
+@vindex $?
+This variable contains the exit code of the last command (0 or 1 for
+Lisp functions, based on successful completion).
+
+@end table
+
+@node Variables
+@section Variables
+Since Eshell is just an Emacs REPL@footnote{Read-Eval-Print Loop}, it
+does not have its own scope, and simply stores variables the same you
+would in an Elisp program.  Eshell provides a command version of
+@code{setq} for convenience.
+
+@node Aliases
+@section Aliases
+
+Aliases are commands that expand to a longer input line.  For example,
+@command{ll} is a common alias for @code{ls -l}, and would be defined
+with the command invocation @samp{alias ll ls -l}; with this defined,
+running @samp{ll foo} in Eshell will actually run @samp{ls -l foo}.
+Aliases defined (or deleted) by the @command{alias} command are
+automatically written to the file named by @var{eshell-aliases-file},
+which you can also edit directly (although you will have to manually
+reload it).
+
+@node History
+@section History
+@cmindex history
 The @samp{history} command shows all commands kept in the history ring
 as numbered list.  If the history ring contains
 @code{eshell-history-size} commands, those numbers change after every
@@ -419,70 +532,226 @@ of the history ring.
 argument of the last command beginning with @code{foo} is accessible
 by @code{!foo:n}.
 
-@item su
-@findex su
-@itemx sudo
-@findex sudo
-@code{su} and @code{sudo} work as expected: they apply the following
-commands (@code{su}), or the command being an argument (@code{sudo})
-under the permissions of somebody else.
-
-This does not work only on
-the local host, but even on a remote one, when
-@code{default-directory} is a remote file name.  The necessary
-proxy configuration of Tramp is performed
-@ifinfo
-automatically, @ref{Multi-hops, , , tramp}.
-@end ifinfo
-@ifnotinfo
-automatically.
-@end ifnotinfo
-Example:
+The history ring is loaded from a file at the start of every session,
+and written back to the file at the end of every session.  The file path
+is specified in @var{eshell-history-file-name}.  Unlike other shells,
+such as Bash, Eshell can not be configured to keep a history ring of a
+different size than that of the history file.
+
+Since the default buffer navigation and searching key-bindings are
+still present in the Eshell buffer, the commands for history
+navigation and searching are bound to different keys:
+
+@table @kbd
+@item M-r
+@itemx M-s
+History I-search.
+
+@item M-p
+@itemx M-n
+Previous and next history line.  If there is anything on the input
+line when you run these commands, they will instead jump to the
+precious or next line that begins with that string.
+@end table
+
+@node Completion
+@section Completion
+Eshell uses the pcomplete package for programmable completion, similar
+to that of other command shells.  Argument completion differs depending
+on the preceding command: for example, possible completions for
+@command{rmdir} are only directories, while @command{rm} completions can
+be directories @emph{and} files.  Eshell provides predefined completions
+for the built-in functions and some common external commands, and you
+can define your own for any command.
+
+Eshell completion also works for lisp forms and glob patterns. If the
+point is on a lisp form, then @key{TAB} will behave similarly to completion
+in @code{elisp-mode} and @code{lisp-interaction-mode}.  For glob
+patterns, If there are few enough possible completions of the patterns,
+they will be cycled when @key{TAB} is pressed, otherwise it will be removed
+from the input line and the possible completions will be listed.
+
+If you want to see the entire list of possible completions when it's
+below the cycling threshold, press @kbd{M-?}.
+
+@subsection pcomplete
+Pcomplete, short for programmable completion, is the completion
+library originally written for Eshell, but usable for command
+completion@footnote{Command completion as opposed to code completion,
+which is a beyond the scope of pcomplete.}  in other modes.
+
+Completions are defined as functions (with @code{defun}) named
+@code{pcomplete/COMMAND}, where @code{COMMAND} is the name of the
+command for which this function provides completions; you can also name
+the function @code{pcomplete/MAJOR-MODE/COMMAND} to define completions
+for a specific major mode.
+
+@node for loop
+@section @code{for} loop
+Because Eshell commands can not (easily) be combined with lisp forms,
+Eshell provides a command-oriented @command{for}-loop for convenience.
+The syntax is as follows:
 
 @example
-~ $ cd /ssh:otherhost:/etc
-/ssh:user@@otherhost:/etc $ sudo find-file shadow
+@code{for VAR in TOKENS @{ command invocation(s) @}}
 @end example
 
-@end table
-
+where @samp{TOKENS} is a space-separated sequence of values of
+@var{VAR} for each iteration.  This can even be the output of a
+command if @samp{TOKENS} is replaced with @samp{@{ command invocation @}}.
 
-@node Arguments
-@chapter Arguments
+@node Scripts
+@section Scripts
+@cmindex source
+@fnindex eshell-source-file
+You can run Eshell scripts much like scripts for other shells; the main
+difference is that since Eshell is not a system command, you have to run
+it from within Emacs.  An Eshell script is simply a file containing a
+sequence of commands, as with almost any other shell script.  Scripts
+are invoked from Eshell with @command{source}, or from anywhere in Emacs
+with @code{eshell-source-file}.
+
+@cmindex .
+If you wish to load a script into your @emph{current} environment,
+rather than in a subshell, use the @code{.} command.
+
+@node Expansion
+@chapter Expansion
+Expansion in a command shell is somewhat like macro expansion in macro
+parsers (such as @command{cpp} and @command{m4}), but in a command
+shell, they are less often used for constants, and usually for using
+variables and string manipulation.@footnote{Eshell has no
+string-manipulation expansions because the Elisp library already
+provides many functions for this.}  For example, @code{$var} on a line
+expands to the value of the variable @code{var} when the line is
+executed.  Expansions are usually passed as arguments, but may also be
+used as commands.@footnote{e.g. Entering just @samp{$var} at the prompt
+is equivalent to entering the value of @code{var} at the prompt.}
 
 @menu
-* The Parser::
-* Variables::
-* Substitution::
+* Dollars Expansion::
 * Globbing::
-* Predicates::
 @end menu
 
-@node The Parser
-@section The Parser
+@node Dollars Expansion
+@section Dollars Expansion
+Eshell has different @code{$} expansion syntax from other shells.  There
+are some similarities, but don't let these lull you into a false sense
+of familiarity.
 
-@node Variables
-@section Variables
+@table @code
 
-@node Substitution
-@section Substitution
+@item $var
+Expands to the value bound to @code{var}.  This is the main way to use
+variables in command invocations.
 
-@node Globbing
-@section Globbing
+@item $#var
+Expands to the length of the value bound to @code{var}.  Raises an error
+if the value is not a sequence (@pxref{Sequences Arrays and Vectors, Sequences, , elisp}).
 
-@node Predicates
-@section Predicates
+@item $(lisp)
+Expands to the result of evaluating the S-expression @code{(lisp)}.  On
+its own, this is identical to just @code{(lisp)}, but with the @code{$},
+it can be used in a string, such as @samp{/some/path/$(lisp).txt}.
 
+@item $@{command@}
+Returns the output of @command{command}, which can be any valid Eshell
+command invocation, and may even contain expansions.
 
-@node Input/Output
-@chapter Input/Output
+@item $var[i]
+Expands to the @code{i}th element of the value bound to @code{var}.  If
+the value is a string, it will be split at whitespace to make it a list.
+Again, raises an error if the value is not a sequence.
+
+@item $var[: i]
+As above, but now splitting occurs at the colon character.
 
-@node Process control
-@chapter Process control
+@item $var[: i j]
+As above, but instead of returning just a string, it now returns a list
+of two strings.  If the result is being interpolated into a larger
+string, this list will be flattened into one big string, with each
+element separated by a space.
 
+@item $var["\\\\" i]
+Separate on backslash characters.  Actually, the first argument -- if it
+doesn't have the form of a number, or a plain variable name -- can be
+any regular expression.  So to split on numbers, use @samp{$var["[0-9]+" 10 20]}.
+
+@item $var[hello]
+Calls @code{assoc} on @code{var} with @code{"hello"}, expecting it to be
+an alist (@pxref{Association List Type, Association Lists, , elisp}).
+
+@item $#var[hello]
+Returns the length of the cdr of the element of @code{var} who car is equal
+to @code{"hello"}.
+
+@end table
+
+@node Globbing
+@section Globbing
+Eshell's globbing syntax is very similar to that of Zsh.  Users coming
+from Bash can still use Bash-style globbing, as there are no
+incompatibilities.  Most globbing is pattern-based expansion, but there
+is also predicate-based expansion.  See @ref{Filename Generation, , , zsh}
+for full syntax.  To customize the syntax and behaviour of globbing in
+Eshell see the Customize@footnote{@xref{Customization Settings, Customize, , elisp}.}
+groups ``eshell-glob'' and ``eshell-pred''.
+
+@node Input/Output
+@chapter Input/Output
+Since Eshell does not communicate with a terminal like most command
+shells, IO is a little different.  If you try to run programs from
+within Eshell that are not line-oriented, such as programs that use
+ncurses, you will just get garbage output, since the Eshell buffer is
+not a terminal emulator.  Eshell solves this problem by running
+specified commands in Emacs's terminal emulator; to let Eshell know
+which commands need to be run in a terminal, add them to the list
+@var{eshell-visual-commands}.
+
+Redirection is mostly the same in Eshell as it is in other command
+shells.  The output redirection operators @code{>} and @code{>>} as well
+as pipes are supported, but there is not yet any support for input
+redirection.  Output can also be redirected to Elisp functions, using
+virtual devices.
+
+@var{eshell-virtual-targets} is a list of mappings of virtual device
+names to functions.  Eshell comes with two virtual devices:
+@file{/dev/kill}, which sends the text to the kill ring, and
+@file{/dev/clip}, which sends text to the clipboard.
+
+You can, of course, define your own virtual targets.  They are defined
+by adding a list of the form @code{("/dev/name" function mode)} to
+@var{eshell-virtual-targets}.  The first element is the device name;
+@code{function} may be either a lambda or a function name.  If
+@code{mode} is nil, then the function is the output function; if it is
+non-nil, then the function is passed the redirection mode as a
+symbol--@code{overwrite}, @code{append}, or @code{insert}--and the
+function is expected to return the output function.
+
+The output function is called once on each line of output until
+@code{nil} is passed, indicating end of output.
 
 @node Extension modules
 @chapter Extension modules
+Eshell provides a facility for defining extension modules so that they
+can be disabled and enabled without having to unload and reload them,
+and to provide a common parent Customize group for the
+modules.@footnote{ERC provides a similar module facility.}  An Eshell
+module is defined the same as any other library but one requirement: the
+module must define a Customize@footnote{@xref{Customization Settings, Customize, , elisp}.}
+group using @code{eshell-defgroup} (in place of @code{defgroup}) with
+@code{eshell-module} as the parent group.@footnote{If the module has
+no user-customizable options, then there is no need to define it as an
+Eshell module.}  You also need to load the following as shown:
+
+@example
+(eval-when-compile
+  (require 'cl)
+  (require 'esh-mode)
+  (require 'eshell))
+
+(require 'esh-util)
+@end example
 
 @menu
 * Writing a module::
@@ -491,7 +760,6 @@ Example:
 * Key rebinding::
 * Smart scrolling::
 * Terminal emulation::
-* Built-in UNIX commands::
 @end menu
 
 @node Writing a module
@@ -512,13 +780,6 @@ Example:
 @node Terminal emulation
 @section Terminal emulation
 
-@node Built-in UNIX commands
-@section Built-in UNIX commands
-
-
-@node Extras and Goodies
-@chapter Extras and Goodies
-
 @node Bugs and ideas
 @chapter Bugs and ideas
 @cindex reporting bugs and ideas
@@ -527,6 +788,8 @@ Example:
 @cindex email to the author
 @cindex FAQ
 @cindex problems, list of common
+@cindex known bugs
+@cindex bugs, known
 
 If you find a bug or misfeature, don't hesitate to let me know!  Send
 email to @email{johnw@@gnu.org}.  Feature requests should also be sent
@@ -537,16 +800,7 @@ If you have ideas for improvements, or if you have written some
 extensions to this package, I would like to hear from you.  I hope you
 find this package useful!
 
-@menu
-* Known problems::
-@end menu
-
-@node Known problems
-@section Known problems
-@cindex known bugs
-@cindex bugs, known
-
-Below is complete list of known problems with Eshell version 2.4.2,
+Below is a complete list of known problems with Eshell version 2.4.2,
 which is the version included with Emacs 22.
 
 @table @asis
@@ -554,7 +808,7 @@ which is the version included with Emacs 22.
 
 @item Differentiate between aliases and functions
 
-Allow for a bash-compatible syntax, such as:
+Allow for a Bash-compatible syntax, such as:
 
 @example
 alias arg=blah
@@ -838,7 +1092,7 @@ them; @code{min} would display the smallest figure, etc.
 It would provide syntax, abbrev, highlighting and indenting support like
 @code{emacs-lisp-mode} and @code{shell-mode}.
 
-@item In the history mechanism, finish the @command{bash}-style support
+@item In the history mechanism, finish the Bash-style support
 
 This means @samp{!n}, @samp{!#}, @samp{!:%}, and @samp{!:1-} as separate
 from @samp{!:1*}.
@@ -1008,6 +1262,11 @@ Since it keeps the cursor up where the command was invoked.
 
 @printindex fn
 
+@node Command Index
+@unnumbered Command Index
+
+@printindex cm
+
 @node Key Index
 @unnumbered Key Index
 
diff --git a/etc/TODO b/etc/TODO
index cf67140a10c..4f7b8dc5f0c 100644
--- a/etc/TODO
+++ b/etc/TODO
@@ -269,18 +269,11 @@ specified filters, specified timers, and specified hooks.
 
 * Other features we would like:
 
-** Make longlines-mode wrap lines based on screen position instead
-   of character position, so that variable-width fonts can be handled
-   properly.
-
 ** Allow frames(terminals) created by emacsclient to inherit their environment
 from the emacsclient process.
 ** Remove the default toggling behavior of minor modes when called from elisp
 rather than interactively.  This a trivial one-liner in easy-mode.el.
 
-** Create a category of errors called `user-error' for errors which are
-typically due to pilot errors and should thus be in debug-ignored-errors.
-
 ** Give Tar mode all the features of Archive mode.
 
 ** Create a category of errors called `process-error'
diff --git a/leim/ChangeLog b/leim/ChangeLog
index b07102d44ba..b6591afb75f 100644
--- a/leim/ChangeLog
+++ b/leim/ChangeLog
@@ -1,3 +1,7 @@
+2013-02-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * quail/latin-ltx.el: Add greek superscripts.
+
 2012-12-04  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * quail/latin-ltx.el: Avoid deprecated chars for \langle and \rangle.
diff --git a/leim/quail/latin-ltx.el b/leim/quail/latin-ltx.el
index e686d7bc04b..2179e6264a2 100644
--- a/leim/quail/latin-ltx.el
+++ b/leim/quail/latin-ltx.el
@@ -248,14 +248,18 @@ system, including many technical ones.  Examples:
         (string (if (match-end 2) ?^ ?_) basechar))))
   "\\(.*\\)SU\\(?:B\\|\\(PER\\)\\)SCRIPT \\(.*\\)")
 
- ("^\\gamma" ?ˠ)
-
  ((lambda (name char)
-    (let* ((base (format "LATIN %s LETTER %s"
-                         (match-string 1 name) (match-string 2 name)))
-           (basechar (cdr (assoc base (ucs-names)))))
-      (when (latin-ltx--ascii-p basechar)
-        (string ?^ basechar))))
+    (let* ((basename (match-string 2 name))
+           (lbase (format "LATIN %s LETTER %s"
+                          (match-string 1 name) basename))
+           (gbase (format "GREEK %s LETTER %s"
+                          (match-string 1 name) basename))
+           tmp)
+      (cond
+       ((assoc gbase (ucs-names)) (concat "^\\" (downcase basename)))
+       ((latin-ltx--ascii-p (setq tmp (cdr (assoc lbase (ucs-names)))))
+        (string ?^ tmp))
+       (t (message "Unknown modifier letter %s" basename)))))
   "MODIFIER LETTER \\(SMALL\\|CAPITAL\\) \\(.*\\)")
  
  ;; ((lambda (name char) (format "^%s" (downcase (match-string 1 name))))
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 4211901d64f..3dea3ed0380 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,26 @@
+2013-02-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/byte-run.el (eval-when-compile, eval-and-compile):
+        Eval body right away, now that we do eager macroexpansion (bug#13605).
+
+        * simple.el (end-of-buffer): Don't touch unrelated windows (bug#13466).
+        (fundamental-mode): Use run-mode-hooks.
+
+        * eshell/esh-proc.el (eshell/kill): Fix last change.
+        * eshell/em-ls.el (eshell-ls-dir): Fix use of CL in last change.
+
+2013-02-08  Aidan Gauland  <aidalgol@no8wireless.co.nz>
+
+        * eshell/esh-proc.el (eshell/kill): Rewrite.
+
+        * eshell/em-ls.el (show-almost-all): Declare.
+        (eshell-do-ls): Add support for -A argument.
+
+2013-02-08  Jambunathan K  <kjambunathan@gmail.com>
+
+        * icomplete.el (icomplete-forward-completions)
+        (icomplete-backward-completions): Handle corner case (bug#13602).
+
 2013-02-07  Michael Albinus  <michael.albinus@gmx.de>
 
         * vc/vc-hooks.el (vc-find-file-hook): `buffer-file-truename' can
diff --git a/lisp/emacs-lisp/byte-run.el b/lisp/emacs-lisp/byte-run.el
index b44ec68e2bf..48bcefaee1a 100644
--- a/lisp/emacs-lisp/byte-run.el
+++ b/lisp/emacs-lisp/byte-run.el
@@ -392,15 +392,15 @@ If you think you need this, you're probably making a mistake somewhere."
 Thus, the result of the body appears to the compiler as a quoted constant.
 In interpreted code, this is entirely equivalent to `progn'."
   (declare (debug t) (indent 0))
-  ;; Not necessary because we have it in b-c-initial-macro-environment
-  ;; (list 'quote (eval (cons 'progn body)))
-  (cons 'progn body))
+  (list 'quote (eval (cons 'progn body) lexical-binding)))
 
 (defmacro eval-and-compile (&rest body)
   "Like `progn', but evaluates the body at compile time and at load time."
   (declare (debug t) (indent 0))
-  ;; Remember, it's magic.
-  (cons 'progn body))
+  ;; When the byte-compiler expands code, this macro is not used, so we're
+  ;; either about to run `body' (plain interpretation) or we're doing eager
+  ;; macroexpansion.
+  (list 'quote (eval (cons 'progn body) lexical-binding)))
 
 (put 'with-no-warnings 'lisp-indent-function 0)
 (defun with-no-warnings (&rest body)
diff --git a/lisp/eshell/em-ls.el b/lisp/eshell/em-ls.el
index eec932103ee..73ed617b871 100644
--- a/lisp/eshell/em-ls.el
+++ b/lisp/eshell/em-ls.el
@@ -26,9 +26,8 @@
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'cl-lib)
-  (require 'eshell))
+(eval-when-compile (require 'eshell))
+(require 'cl-lib)
 (require 'esh-util)
 (require 'esh-opt)
 
@@ -328,6 +327,7 @@ instead."
 (defvar numeric-uid-gid)
 (defvar reverse-list)
 (defvar show-all)
+(defvar show-almost-all)
 (defvar show-recursive)
 (defvar show-size)
 (defvar sort-method)
@@ -337,13 +337,15 @@ instead."
 (defun eshell-do-ls (&rest args)
   "Implementation of \"ls\" in Lisp, passing ARGS."
   (funcall flush-func -1)
-  ;; process the command arguments, and begin listing files
+  ;; Process the command arguments, and begin listing files.
   (eshell-eval-using-options
    "ls" (if eshell-ls-initial-args
             (list eshell-ls-initial-args args)
           args)
    `((?a "all" nil show-all
-         "show all files in directory")
+         "do not ignore entries starting with .")
+     (?A "almost-all" nil show-almost-all
+         "do not list implied . and ..")
      (?c nil by-ctime sort-method
          "sort by last status change time")
      (?d "directory" nil dir-literal
@@ -558,7 +560,15 @@ relative to that directory."
                                      ;; later when we are going to
                                      ;; display user and group names.
                                      (if numeric-uid-gid 'integer 'string))))
-          (when (and (not show-all) eshell-ls-exclude-regexp)
+          (when (and show-almost-all
+                     (not show-all))
+            (setq entries
+                  (cl-remove-if
+                   (lambda (entry)
+                     (member (caar entry) '("." "..")))
+                   entries)))
+          (when (and (not show-all)
+                     eshell-ls-exclude-regexp)
             (while (and entries (string-match eshell-ls-exclude-regexp
                                               (caar entries)))
               (setq entries (cdr entries)))
diff --git a/lisp/eshell/esh-proc.el b/lisp/eshell/esh-proc.el
index 406822367d1..aa630dc87aa 100644
--- a/lisp/eshell/esh-proc.el
+++ b/lisp/eshell/esh-proc.el
@@ -165,43 +165,38 @@ The signals which will cause this to happen are matched by
        (list-processes)))
 
 (defun eshell/kill (&rest args)
-  "Kill processes, buffers, symbol or files."
-  (let ((ptr args)
-        (signum 'SIGINT))
-    (while ptr
-      (if (or (eshell-processp (car ptr))
-              (and (stringp (car ptr))
-                   (string-match "^[A-Za-z/][A-Za-z0-9<>/]+$"
-                                 (car ptr))))
-          ;; What about when $lisp-variable is possible here?
-          ;; It could very well name a process.
-          (setcar ptr (get-process (car ptr))))
-      (setq ptr (cdr ptr)))
+  "Kill processes.
+Usage: kill [-<signal>] <pid>|<process> ...
+Accepts PIDs and process objects."
+  ;; If the first argument starts with a dash, treat it as the signal
+  ;; specifier.
+  (let ((signum 'SIGINT))
+    (let ((arg (car args))
+          (case-fold-search nil))
+      (when (stringp arg)
+        (cond
+         ((string-match "\\`-[[:digit:]]+\\'" arg)
+          (setq signum (abs (string-to-number arg))))
+         ((string-match "\\`-\\([[:upper:]]+\\|[[:lower:]]+\\)\\'" arg)
+          (setq signum (abs (string-to-number arg)))))
+        (setq args (cdr args))))
     (while args
-      (let ((id (if (eshell-processp (car args))
-                    (process-id (car args))
-                  (car args))))
-        (when id
-          (cond
-           ((null id)
-            (error "kill: bad signal spec"))
-           ((and (numberp id) (= id 0))
-            (error "kill: bad signal spec `%d'" id))
-           ((and (stringp id)
-                 (string-match "^-?[0-9]+$" id))
-            (setq signum (abs (string-to-number id))))
-           ((stringp id)
-            (let (case-fold-search)
-              (if (string-match "^-\\([A-Z]+[12]?\\)$" id)
-                  (setq signum
-                        (intern (concat "SIG" (match-string 1 id))))
-                (error "kill: bad signal spec `%s'" id))))
-           ((< id 0)
-            (setq signum (abs id)))
-           (t
-            (signal-process id signum)))))
-      (setq args (cdr args)))
-    nil))
+      (let ((arg (if (eshell-processp (car args))
+                     (process-id (car args))
+                   (car args))))
+        (when arg
+          (cond
+           ((null arg)
+            (error "kill: null pid.  Process may actually be a network connection."))
+           ((not (numberp arg))
+            (error "kill: invalid argument type: %s" (type-of arg)))
+           ((and (numberp arg)
+                 (<= arg 0))
+            (error "kill: bad pid: %d" arg))
+           (t
+            (signal-process arg signum)))))
+      (setq args (cdr args))))
+  nil)
 
 (defun eshell-read-process-name (prompt)
   "Read the name of a process from the minibuffer, using completion.
diff --git a/lisp/icomplete.el b/lisp/icomplete.el
index 9407de4f6d9..8e4dd69e199 100644
--- a/lisp/icomplete.el
+++ b/lisp/icomplete.el
@@ -167,8 +167,9 @@ Second entry becomes the first and can be selected with
   (interactive)
   (let* ((comps (completion-all-sorted-completions))
          (last (last comps)))
-    (setcdr last (cons (car comps) (cdr last)))
-    (completion--cache-all-sorted-completions (cdr comps))))
+    (when comps
+      (setcdr last (cons (car comps) (cdr last)))
+      (completion--cache-all-sorted-completions (cdr comps)))))
 
 (defun icomplete-backward-completions ()
   "Step backward completions by one entry.
@@ -178,7 +179,7 @@ Last entry becomes the first and can be selected with
   (let* ((comps (completion-all-sorted-completions))
          (last-but-one (last comps 2))
          (last (cdr last-but-one)))
-    (when last
+    (when (consp last)                ; At least two elements in comps
       (setcdr last-but-one (cdr last))
       (push (car last) comps)
       (completion--cache-all-sorted-completions comps))))
diff --git a/lisp/simple.el b/lisp/simple.el
index d7541f68778..9587d3c006c 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -349,8 +349,7 @@ buffer causes automatic display of the corresponding source code location."
 Other major modes are defined by comparison with this one."
   (interactive)
   (kill-all-local-variables)
-  (unless delay-mode-hooks
-    (run-hooks 'after-change-major-mode-hook)))
+  (run-mode-hooks))
 
 ;; Special major modes to view specially formatted data rather than files.
 
@@ -868,7 +867,8 @@ Don't use this command in Lisp programs!
   ;; If we went to a place in the middle of the buffer,
   ;; adjust it to the beginning of a line.
   (cond ((and arg (not (consp arg))) (forward-line 1))
-        ((> (point) (window-end nil t))
+        ((and (eq (current-buffer) (window-buffer))
+              (> (point) (window-end nil t)))
          ;; If the end of the buffer is not already on the screen,
          ;; then scroll specially to put it near, but not at, the bottom.
          (overlay-recenter (point))
diff --git a/src/ChangeLog b/src/ChangeLog
index 9ffe133e758..46f872ba29d 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,38 @@
+2013-02-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lread.c (skip_dyn_bytes): New function (bug#12598).
+        (read1): Use it.  Use getc instead of READCHAR to read bytes.
+        (load_each_byte): Remove.  Update users.
+
+2013-02-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * search.c (scan_buffer): Calculate end byte position just once.
+        (scan_newline): Do not recalculate start_byte.
+        (search_command): Use eassert.
+        * syntax.c (struct lisp_parse_state): New member location_byte.
+        (scan_sexps_forward): Record from_byte and avoid redundant
+        character to byte position calculation ...
+        (Fparse_partial_sexp): ... here.  Break too long line.
+
+2013-02-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (make_uninit_vector): New function.
+        * alloc.c (Fvector, Fmake_byte_code):
+        * ccl.c (Fregister_ccl_program):
+        * charset.c (Fdefine_charset_internal, define_charset_internal):
+        * coding.c (make_subsidiaries, Fdefine_coding_system_internal):
+        * composite.c (syms_of_composite):
+        * font.c (Fquery_font, Ffont_info, syms_of_font):
+        * fontset.c (FONT_DEF_NEW, Fset_fontset_font):
+        * ftfont.c (ftfont_shape_by_flt):
+        * indent.c (recompute_width_table):
+        * nsselect.m (clean_local_selection_data):
+        * syntax.c (init_syntax_once):
+        * w32unsubscribe.c (uniscribe_shape):
+        * window.c (Fcurrent_window_configuration):
+        * xfaces.c (Fx_family_fonts):
+        * xselect.c (selection_data_to_lisp_data): Use it.
+
 2013-02-07  Dmitry Antipov  <dmantipov@yandex.ru>
 
         * coding.c (Fdefine_coding_system_internal): Use AREF where
diff --git a/src/alloc.c b/src/alloc.c
index 2624650ed2c..80086433e65 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3105,13 +3105,10 @@ Any number of arguments, even zero arguments, are allowed.
 usage: (vector &rest OBJECTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  register Lisp_Object val = make_uninit_vector (nargs);
+  register struct Lisp_Vector *p = XVECTOR (val);
 
-  XSETFASTINT (len, nargs);
-  val = Fmake_vector (len, Qnil);
-  p = XVECTOR (val);
   for (i = 0; i < nargs; i++)
     p->contents[i] = args[i];
   return val;
@@ -3149,9 +3146,9 @@ stack before executing the byte-code.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  register Lisp_Object val = make_uninit_vector (nargs);
+  register struct Lisp_Vector *p = XVECTOR (val);
 
   /* We used to purecopy everything here, if purify-flag was set.  This worked
      OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
@@ -3161,10 +3158,6 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
      just wasteful and other times plainly wrong (e.g. those free vars may want
      to be setcar'd).  */
 
-  XSETFASTINT (len, nargs);
-  val = Fmake_vector (len, Qnil);
-
-  p = XVECTOR (val);
   for (i = 0; i < nargs; i++)
     p->contents[i] = args[i];
   make_byte_code (p);
diff --git a/src/ccl.c b/src/ccl.c
index 9bfd437d885..7f77e1d22fa 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2228,9 +2228,8 @@ Return index number of the registered CCL program.  */)
     Vccl_program_table = larger_vector (Vccl_program_table, 1, -1);
 
   {
-    Lisp_Object elt;
+    Lisp_Object elt = make_uninit_vector (4);
 
-    elt = Fmake_vector (make_number (4), Qnil);
     ASET (elt, 0, name);
     ASET (elt, 1, ccl_prog);
     ASET (elt, 2, resolved);
diff --git a/src/charset.c b/src/charset.c
index c3a4538f223..fdb8eebde8b 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -1053,7 +1053,7 @@ usage: (define-charset-internal ...)  */)
       CHECK_NATNUM (parent_max_code);
       parent_code_offset = Fnth (make_number (3), val);
       CHECK_NUMBER (parent_code_offset);
-      val = Fmake_vector (make_number (4), Qnil);
+      val = make_uninit_vector (4);
       ASET (val, 0, make_number (parent_charset->id));
       ASET (val, 1, parent_min_code);
       ASET (val, 2, parent_max_code);
@@ -1259,7 +1259,7 @@ define_charset_internal (Lisp_Object name,
 
   args[charset_arg_name] = name;
   args[charset_arg_dimension] = make_number (dimension);
-  val = Fmake_vector (make_number (8), make_number (0));
+  val = make_uninit_vector (8);
   for (i = 0; i < 8; i++)
     ASET (val, i, make_number (code_space[i]));
   args[charset_arg_code_space] = val;
diff --git a/src/coding.c b/src/coding.c
index c7bfe25e0cc..b881f162ab9 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -9483,7 +9483,7 @@ make_subsidiaries (Lisp_Object base)
   int i;
 
   memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
-  subsidiaries = Fmake_vector (make_number (3), Qnil);
+  subsidiaries = make_uninit_vector (3);
   for (i = 0; i < 3; i++)
     {
       strcpy (buf + base_name_len, suffixes[i]);
@@ -9988,7 +9988,8 @@ usage: (define-coding-system-internal ...)  */)
           this_name = AREF (eol_type, i);
           this_aliases = Fcons (this_name, Qnil);
           this_eol_type = (i == 0 ? Qunix : i == 1 ? Qdos : Qmac);
-          this_spec = Fmake_vector (make_number (3), attrs);
+          this_spec = make_uninit_vector (3);
+          ASET (this_spec, 0, attrs);
           ASET (this_spec, 1, this_aliases);
           ASET (this_spec, 2, this_eol_type);
           Fputhash (this_name, this_spec, Vcoding_system_hash_table);
@@ -10001,7 +10002,8 @@ usage: (define-coding-system-internal ...)  */)
         }
     }
 
-  spec_vec = Fmake_vector (make_number (3), attrs);
+  spec_vec = make_uninit_vector (3);
+  ASET (spec_vec, 0, attrs);
   ASET (spec_vec, 1, aliases);
   ASET (spec_vec, 2, eol_type);
 
diff --git a/src/composite.c b/src/composite.c
index ddd92389725..54cebc00eb7 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1958,7 +1958,7 @@ syms_of_composite (void)
   }
 
   staticpro (&gstring_work_headers);
-  gstring_work_headers = Fmake_vector (make_number (8), Qnil);
+  gstring_work_headers = make_uninit_vector (8);
   for (i = 0; i < 8; i++)
     ASET (gstring_work_headers, i, Fmake_vector (make_number (i + 2), Qnil));
   staticpro (&gstring_work);
diff --git a/src/doc.c b/src/doc.c
index 16c0d4090a0..fa2eca66a1d 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -176,9 +176,9 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
       if (space_left <= 0)
         {
           ptrdiff_t in_buffer = p - get_doc_string_buffer;
-          get_doc_string_buffer =
-            xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size,
-                     16 * 1024, -1, 1);
+          get_doc_string_buffer
+            = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size,
+                       16 * 1024, -1, 1);
           p = get_doc_string_buffer + in_buffer;
           space_left = (get_doc_string_buffer_size - 1
                         - (p - get_doc_string_buffer));
@@ -279,10 +279,10 @@ Invalid data in documentation file -- %c followed by code %03o",
   else
     {
       /* The data determines whether the string is multibyte.  */
-      ptrdiff_t nchars =
-        multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
-                                  + offset),
-                                 to - (get_doc_string_buffer + offset));
+      ptrdiff_t nchars
+        = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
+                                    + offset),
+                                   to - (get_doc_string_buffer + offset));
       return make_string_from_bytes (get_doc_string_buffer + offset,
                                      nchars,
                                      to - (get_doc_string_buffer + offset));
diff --git a/src/font.c b/src/font.c
index 3cffe2558ae..bed0ac8caf2 100644
--- a/src/font.c
+++ b/src/font.c
@@ -4603,7 +4603,7 @@ If the font is not OpenType font, CAPABILITY is nil.  */)
 
   CHECK_FONT_GET_OBJECT (font_object, font);
 
-  val = Fmake_vector (make_number (9), Qnil);
+  val = make_uninit_vector (9);
   ASET (val, 0, AREF (font_object, FONT_NAME_INDEX));
   ASET (val, 1, AREF (font_object, FONT_FILE_INDEX));
   ASET (val, 2, make_number (font->pixel_size));
@@ -4614,6 +4614,8 @@ If the font is not OpenType font, CAPABILITY is nil.  */)
   ASET (val, 7, make_number (font->average_width));
   if (font->driver->otf_capability)
     ASET (val, 8, Fcons (Qopentype, font->driver->otf_capability (font)));
+  else
+    ASET (val, 8, Qnil);
   return val;
 }
 
@@ -4870,7 +4872,7 @@ If the named font is not yet loaded, return nil.  */)
     return Qnil;
   font = XFONT_OBJECT (font_object);
 
-  info = Fmake_vector (make_number (7), Qnil);
+  info = make_uninit_vector (7);
   ASET (info, 0, AREF (font_object, FONT_NAME_INDEX));
   ASET (info, 1, AREF (font_object, FONT_FULLNAME_INDEX));
   ASET (info, 2, make_number (font->pixel_size));
@@ -5163,7 +5165,7 @@ See `font-weight-table' for the format of the vector. */);
   XSYMBOL (intern_c_string ("font-width-table"))->constant = 1;
 
   staticpro (&font_style_table);
-  font_style_table = Fmake_vector (make_number (3), Qnil);
+  font_style_table = make_uninit_vector (3);
   ASET (font_style_table, 0, Vfont_weight_table);
   ASET (font_style_table, 1, Vfont_slant_table);
   ASET (font_style_table, 2, Vfont_width_table);
diff --git a/src/fontset.c b/src/fontset.c
index b7f3e46d69c..3578bc9403d 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -271,7 +271,8 @@ set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
 /* Macros for FONT-DEF and RFONT-DEF of fontset.  */
 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory)  \
   do {                                                          \
-    (font_def) = Fmake_vector (make_number (3), (font_spec));   \
+    (font_def) = make_uninit_vector (3);                        \
+    ASET ((font_def), 0, font_spec);                            \
     ASET ((font_def), 1, encoding);                             \
     ASET ((font_def), 2, repertory);                            \
   } while (0)
@@ -1591,7 +1592,7 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
     {
       Lisp_Object arg;
 
-      arg = Fmake_vector (make_number (5), Qnil);
+      arg = make_uninit_vector (5);
       ASET (arg, 0, fontset);
       ASET (arg, 1, font_def);
       ASET (arg, 2, add);
diff --git a/src/ftfont.c b/src/ftfont.c
index 03e40bf2e46..1fb1b574a1c 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -2555,9 +2555,8 @@ ftfont_shape_by_flt (Lisp_Object lgstring, struct font *font,
       LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
       if (g->adjusted)
         {
-          Lisp_Object vec;
+          Lisp_Object vec = make_uninit_vector (3);
 
-          vec = Fmake_vector (make_number (3), Qnil);
           ASET (vec, 0, make_number (g->xoff >> 6));
           ASET (vec, 1, make_number (g->yoff >> 6));
           ASET (vec, 2, make_number (g->xadv >> 6));
diff --git a/src/indent.c b/src/indent.c
index 45b6afbd395..44ecbbc8a58 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -138,7 +138,7 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
   struct Lisp_Vector *widthtab;
 
   if (!VECTORP (BVAR (buf, width_table)))
-    bset_width_table (buf, Fmake_vector (make_number (256), make_number (0)));
+    bset_width_table (buf, make_uninit_vector (256));
   widthtab = XVECTOR (BVAR (buf, width_table));
   eassert (widthtab->header.size == 256);
 
diff --git a/src/lisp.h b/src/lisp.h
index dd8d1f38db6..787457b4872 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3048,6 +3048,27 @@ extern void make_byte_code (struct Lisp_Vector *);
 extern Lisp_Object Qautomatic_gc;
 extern Lisp_Object Qchar_table_extra_slots;
 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
+
+/* Make an unitialized vector for SIZE objects.  NOTE: you must
+   be sure that GC cannot happen until the vector is completely
+   initialized.  E.g. the following code is likely to crash:
+
+   v = make_uninit_vector (3);
+   ASET (v, 0, obj0);
+   ASET (v, 1, Ffunction_can_gc ());
+   ASET (v, 2, obj1);  */
+
+LISP_INLINE Lisp_Object
+make_uninit_vector (ptrdiff_t size)
+{
+  Lisp_Object v;
+  struct Lisp_Vector *p;
+
+  p = allocate_vector (size);
+  XSETVECTOR (v, p);
+  return v;
+}
+
 extern struct Lisp_Vector *allocate_pseudovector (int, int, enum pvec_type);
 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag)                            \
   ((typ*)                                                               \
diff --git a/src/lread.c b/src/lread.c
index 09eccb0fb30..c62c62a5e5a 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -96,11 +96,6 @@ static Lisp_Object Qload_in_progress;
    It must be set to nil before all top-level calls to read0.  */
 static Lisp_Object read_objects;
 
-/* True means READCHAR should read bytes one by one (not character)
-   when READCHARFUN is Qget_file_char or Qget_emacs_mule_file_char.
-   This is set by read1 temporarily while handling #@NUMBER.  */
-static bool load_each_byte;
-
 /* List of descriptors now open for Fload.  */
 static Lisp_Object load_descriptor_list;
 
@@ -328,7 +323,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
       return c;
     }
   c = (*readbyte) (-1, readcharfun);
-  if (c < 0 || load_each_byte)
+  if (c < 0)
     return c;
   if (multibyte)
     *multibyte = 1;
@@ -353,6 +348,30 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
   return STRING_CHAR (buf);
 }
 
+static void
+skip_dyn_bytes (Lisp_Object readcharfun, ptrdiff_t n)
+{
+  if (EQ (readcharfun, Qget_file_char)
+      || EQ (readcharfun, Qget_emacs_mule_file_char))
+    {
+      block_input ();           /* FIXME: Not sure if it's needed.  */
+      fseek (instream, n, SEEK_CUR);
+      unblock_input ();
+    }
+  else
+    { /* We're not reading directly from a file.  In that case, it's difficult
+         to reliably count bytes, since these are usually meant for the file's
+         encoding, whereas we're now typically in the internal encoding.
+         But luckily, skip_dyn_bytes is used to skip over a single
+         dynamic-docstring (or dynamic byte-code) which is always quoted such
+         that \037 is the final char.  */
+      int c;
+      do {
+        c = READCHAR;
+      } while (c >= 0 && c != '\037');
+    }
+}
+
 /* Unread the character C in the way appropriate for the stream READCHARFUN.
    If the stream is a user function, call it with the char as argument.  */
 
@@ -407,14 +426,7 @@ unreadchar (Lisp_Object readcharfun, int c)
   else if (EQ (readcharfun, Qget_file_char)
            || EQ (readcharfun, Qget_emacs_mule_file_char))
     {
-      if (load_each_byte)
-        {
-          block_input ();
-          ungetc (c, instream);
-          unblock_input ();
-        }
-      else
-        unread_char = c;
+      unread_char = c;
     }
   else
     call1 (readcharfun, make_number (c));
@@ -2388,7 +2400,6 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
   bool multibyte;
 
   *pch = 0;
-  load_each_byte = 0;
 
  retry:
 
@@ -2598,7 +2609,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           return tmp;
         }
 
-      /* #@NUMBER is used to skip NUMBER following characters.
+      /* #@NUMBER is used to skip NUMBER following bytes.
          That's used in .elc files to skip over doc strings
          and function definitions.  */
       if (c == '@')
@@ -2606,7 +2617,6 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           enum { extra = 100 };
           ptrdiff_t i, nskip = 0;
 
-          load_each_byte = 1;
           /* Read a decimal integer.  */
           while ((c = READCHAR) >= 0
                  && c >= '0' && c <= '9')
@@ -2616,8 +2626,15 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               nskip *= 10;
               nskip += c - '0';
             }
-          UNREAD (c);
-
+          if (nskip > 0)
+            /* We can't use UNREAD here, because in the code below we side-step
+               READCHAR.  Instead, assume the first char after #@NNN occupies
+               a single byte, which is the case normally since it's just
+               a space.  */
+            nskip--;
+          else
+            UNREAD (c);
+            
           if (load_force_doc_strings
               && (EQ (readcharfun, Qget_file_char)
                   || EQ (readcharfun, Qget_emacs_mule_file_char)))
@@ -2659,19 +2676,17 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               saved_doc_string_position = file_tell (instream);
 
               /* Copy that many characters into saved_doc_string.  */
+              block_input ();
               for (i = 0; i < nskip && c >= 0; i++)
-                saved_doc_string[i] = c = READCHAR;
+                saved_doc_string[i] = c = getc (instream);
+              unblock_input ();
 
               saved_doc_string_length = i;
             }
           else
-            {
-              /* Skip that many characters.  */
-              for (i = 0; i < nskip && c >= 0; i++)
-                c = READCHAR;
-            }
+            /* Skip that many bytes.  */
+            skip_dyn_bytes (readcharfun, nskip);
 
-          load_each_byte = 0;
           goto retry;
         }
       if (c == '!')
diff --git a/src/nsselect.m b/src/nsselect.m
index 903448ce0a5..49380f87945 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -117,7 +117,7 @@ clean_local_selection_data (Lisp_Object obj)
 
       if (size == 1)
         return clean_local_selection_data (AREF (obj, 0));
-      copy = Fmake_vector (make_number (size), Qnil);
+      copy = make_uninit_vector (size);
       for (i = 0; i < size; i++)
         ASET (copy, i, clean_local_selection_data (AREF (obj, i)));
       return copy;
diff --git a/src/search.c b/src/search.c
index 545f614a063..c4ccf6c257b 100644
--- a/src/search.c
+++ b/src/search.c
@@ -644,18 +644,23 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
              ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
 {
   struct region_cache *newline_cache;
+  ptrdiff_t end_byte = -1;
   int direction;
 
   if (count > 0)
     {
       direction = 1;
-      if (! end) end = ZV;
+      if (!end)
+        end = ZV, end_byte = ZV_BYTE;
     }
   else
     {
       direction = -1;
-      if (! end) end = BEGV;
+      if (!end) 
+        end = BEGV, end_byte = BEGV_BYTE;
     }
+  if (end_byte == -1)
+    end_byte = CHAR_TO_BYTE (end);
 
   newline_cache_on_off (current_buffer);
   newline_cache = current_buffer->newline_cache;
@@ -673,7 +678,7 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
            the position of the last character before the next such
            obstacle --- the last character the dumb search loop should
            examine.  */
-        ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end) - 1;
+        ptrdiff_t ceiling_byte = end_byte - 1;
         ptrdiff_t start_byte;
         ptrdiff_t tem;
 
@@ -750,7 +755,7 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
     while (start > end)
       {
         /* The last character to check before the next obstacle.  */
-        ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end);
+        ptrdiff_t ceiling_byte = end_byte;
         ptrdiff_t start_byte;
         ptrdiff_t tem;
 
@@ -861,8 +866,6 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
   if (allow_quit)
     immediate_quit++;
 
-  start_byte = CHAR_TO_BYTE (start);
-
   if (count > 0)
     {
       while (start_byte < limit_byte)
@@ -1016,8 +1019,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
 
       if (!EQ (noerror, Qt))
         {
-          if (lim < BEGV || lim > ZV)
-            emacs_abort ();
+          eassert (BEGV <= lim && lim <= ZV);
           SET_PT_BOTH (lim, lim_byte);
           return Qnil;
 #if 0 /* This would be clean, but maybe programs depend on
@@ -1029,9 +1031,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
         return Qnil;
     }
 
-  if (np < BEGV || np > ZV)
-    emacs_abort ();
-
+  eassert (BEGV <= np && np <= ZV);
   SET_PT (np);
 
   return make_number (np);
diff --git a/src/syntax.c b/src/syntax.c
index 72d904914ec..42500b0cb76 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -121,6 +121,7 @@ struct lisp_parse_state
     /* Char number of start of containing expression */
     ptrdiff_t prevlevelstart;
     ptrdiff_t location;      /* Char number at which parsing stopped.  */
+    ptrdiff_t location_byte; /* Corresponding byte position.  */
     ptrdiff_t comstr_start;  /* Position of last comment/string starter.  */
     Lisp_Object levelstarts; /* Char numbers of starts-of-expression
                                 of levels (starting from outermost).  */
@@ -3288,6 +3289,7 @@ do { prev_from = from;				\
   state.prevlevelstart
     = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
   state.location = from;
+  state.location_byte = from_byte;
   state.levelstarts = Qnil;
   while (curlevel > levelstart)
     state.levelstarts = Fcons (make_number ((--curlevel)->last),
@@ -3327,7 +3329,8 @@ Fifth arg OLDSTATE is a list like what this function returns.
 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
  If it is symbol `syntax-table', stop after the start of a comment or a
  string, or after end of a comment or a string.  */)
-  (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth, Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
+  (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth,
+   Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
 {
   struct lisp_parse_state state;
   EMACS_INT target;
@@ -3347,7 +3350,7 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
                       (NILP (commentstop)
                        ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
 
-  SET_PT (state.location);
+  SET_PT_BOTH (state.location, state.location_byte);
 
   return Fcons (make_number (state.depth),
            Fcons (state.prevlevelstart < 0
@@ -3389,8 +3392,8 @@ init_syntax_once (void)
   Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
 
   /* Create objects which can be shared among syntax tables.  */
-  Vsyntax_code_object = Fmake_vector (make_number (Smax), Qnil);
-  for (i = 0; i < ASIZE (Vsyntax_code_object); i++)
+  Vsyntax_code_object = make_uninit_vector (Smax);
+  for (i = 0; i < Smax; i++)
     ASET (Vsyntax_code_object, i, Fcons (make_number (i), Qnil));
 
   /* Now we are ready to set up this property, so we can
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 88227487d35..56931adfac5 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -435,8 +435,8 @@ uniscribe_shape (Lisp_Object lgstring)
                          are zero.  */
                       || (!attributes[j].fClusterStart && items[i].a.fRTL))
                     {
-                      Lisp_Object vec;
-                      vec = Fmake_vector (make_number (3), Qnil);
+                      Lisp_Object vec = make_uninit_vector (3);
+
                       if (items[i].a.fRTL)
                         {
                           /* Empirically, it looks like Uniscribe
diff --git a/src/window.c b/src/window.c
index b9165e21d3b..68dcf28f52f 100644
--- a/src/window.c
+++ b/src/window.c
@@ -6194,11 +6194,11 @@ saved by this function.  */)
   data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window : Qnil;
   data->root_window = FRAME_ROOT_WINDOW (f);
   data->focus_frame = FRAME_FOCUS_FRAME (f);
-  tem = Fmake_vector (make_number (n_windows), Qnil);
+  tem = make_uninit_vector (n_windows);
   data->saved_windows = tem;
   for (i = 0; i < n_windows; i++)
     ASET (tem, i,
-         Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
+          Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
   save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
   XSETWINDOW_CONFIGURATION (tem, data);
   return (tem);
diff --git a/src/xdisp.c b/src/xdisp.c
index fe6aa8ad8c3..8a96a3eadc7 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -21682,11 +21682,15 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 }
 
 
-/* Count up to COUNT lines starting from START_BYTE.
-   But don't go beyond LIMIT_BYTE.
-   Return the number of lines thus found (always nonnegative).
-
-   Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT.  */
+/* Count up to COUNT lines starting from START_BYTE.  COUNT negative
+   means count lines back from START_BYTE.  But don't go beyond
+   LIMIT_BYTE.  Return the number of lines thus found (always
+   nonnegative).
+
+   Set *BYTE_POS_PTR to the byte position where we stopped.  This is
+   either the position COUNT lines after/before START_BYTE, if we
+   found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
+   COUNT lines.  */
 
 static ptrdiff_t
 display_count_lines (ptrdiff_t start_byte,
diff --git a/src/xfaces.c b/src/xfaces.c
index 43535b9ea0c..33a221fdd52 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1585,7 +1585,7 @@ the face font sort order.  */)
   for (i = nfonts - 1; i >= 0; --i)
     {
       Lisp_Object font = AREF (vec, i);
-      Lisp_Object v = Fmake_vector (make_number (8), Qnil);
+      Lisp_Object v = make_uninit_vector (8);
       int point;
       Lisp_Object spacing;
 
diff --git a/src/xselect.c b/src/xselect.c
index d769f86cdef..decea696bfd 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1670,8 +1670,8 @@ selection_data_to_lisp_data (Display *display, const unsigned char *data,
         return x_atom_to_symbol (display, (Atom) idata[0]);
       else
         {
-          Lisp_Object v = Fmake_vector (make_number (size / sizeof (int)),
-                                        make_number (0));
+          Lisp_Object v = make_uninit_vector (size / sizeof (int));
+
           for (i = 0; i < size / sizeof (int); i++)
             ASET (v, i, x_atom_to_symbol (display, (Atom) idata[i]));
           return v;
@@ -1693,8 +1693,8 @@ selection_data_to_lisp_data (Display *display, const unsigned char *data,
   else if (format == 16)
     {
       ptrdiff_t i;
-      Lisp_Object v;
-      v = Fmake_vector (make_number (size / 2), make_number (0));
+      Lisp_Object v = make_uninit_vector (size / 2);
+
       for (i = 0; i < size / 2; i++)
         {
           short j = ((short *) data) [i];
@@ -1705,8 +1705,8 @@ selection_data_to_lisp_data (Display *display, const unsigned char *data,
   else
     {
       ptrdiff_t i;
-      Lisp_Object v = Fmake_vector (make_number (size / X_LONG_SIZE),
-                                    make_number (0));
+      Lisp_Object v = make_uninit_vector (size / X_LONG_SIZE);
+
       for (i = 0; i < size / X_LONG_SIZE; i++)
         {
           int j = ((int *) data) [i];