emacs/doc/misc/eshell.texi

\input texinfo  @c -*-texinfo-*-
@c %**start of header
@setfilename ../../info/eshell.info
@settitle Eshell: The Emacs Shell
@include docstyle.texi
@defindex cm
@synindex vr fn
@c %**end of header

@copying
This manual is for Eshell, the Emacs shell.

Copyright @copyright{} 1999--2022 Free Software Foundation, Inc.

@quotation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with the Front-Cover Texts being ``A GNU Manual'',
and with the Back-Cover Texts as in (a) below.  A copy of the license
is included in the section entitled ``GNU Free Documentation License''.

(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
modify this GNU manual.''
@end quotation
@end copying

@dircategory Emacs misc features
@direntry
* Eshell: (eshell).             A command shell implemented in Emacs Lisp.
@end direntry

@titlepage
@sp 4
@c The title is printed in a large font.
@center @titlefont{User's Guide}
@sp 1
@center @titlefont{to}
@sp 1
@center @titlefont{Eshell: The Emacs Shell}
@ignore
@sp 2
@center release 2.4
@c -release-
@end ignore
@sp 3
@center John Wiegley & Aidan Gauland
@c -date-

@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage

@contents

@c ================================================================
@c                   The real text starts here
@c ================================================================

@ifnottex
@node Top
@top Eshell

Eshell is a shell-like command interpreter implemented in Emacs Lisp.
It invokes no external processes except for those requested by the
user.  It is intended to be an alternative to the IELM (@pxref{Lisp Interaction, Emacs Lisp Interaction, , emacs, The Emacs Editor})
REPL for Emacs @emph{and} with an interface similar to command shells
such as @command{bash}, @command{zsh}, @command{rc}, or
@command{4dos}.
@c This manual is updated to release 2.4 of Eshell.

@insertcopying
@end ifnottex

@menu
* Introduction::             A brief introduction to the Emacs Shell.
* Commands::
* Expansion::
* Input/Output::
* Extension modules::
* Bugs and ideas::              Known problems, and future ideas.
* GNU Free Documentation License:: The license for this documentation.
* Concept Index::
* Function and Variable Index::
* Command Index::
@ignore
* Key Index::
@end ignore
@end menu

@node Introduction
@chapter Introduction
@section What is Eshell?
@cindex what is Eshell?
@cindex Eshell, what it is

Eshell is a @dfn{command shell} written in Emacs Lisp.  Everything it
does, it uses Emacs's facilities to do.  This means that Eshell is as
portable as Emacs itself.  It also means that cooperation with Lisp code
is natural and seamless.

What is a command shell?  To properly understand the role of a shell,
it's necessary to visualize what a computer does for you.  Basically, a
computer is a tool; in order to use that tool, you must tell it what to
do---or give it ``commands.''  These commands take many forms, such as
clicking with a mouse on certain parts of the screen.  But that is only
one form of command input.

By far the most versatile way to express what you want the computer to
do is by using an abbreviated language called @dfn{script}.  In
script, instead of telling the computer, ``list my files, please'',
one writes a standard abbreviated command word---@samp{ls}.  Typing
@samp{ls} in a command shell is a script way of telling the computer
to list your files.@footnote{This is comparable to viewing the
contents of a folder using a graphical display.}

The real flexibility of this approach is apparent only when you realize
that there are many, many different ways to list files.  Perhaps you
want them sorted by name, sorted by date, in reverse order, or grouped
by type.  Most graphical browsers have simple ways to express this.  But
what about showing only a few files, or only files that meet a certain
criteria?  In very complex and specific situations, the request becomes
too difficult to express using a mouse or pointing device.  It is just
these kinds of requests that are easily solved using a command shell.

For example, what if you want to list every Word file on your hard
drive, larger than 100 kilobytes in size, and which hasn't been looked
at in over six months?  That is a good candidate list for deletion, when
you go to clean up your hard drive.  But have you ever tried asking your
computer for such a list?  There is no way to do it!  At least, not
without using a command shell.

The role of a command shell is to give you more control over what your
computer does for you.  Not everyone needs this amount of control, and
it does come at a cost: Learning the necessary script commands to
express what you want done.  A complicated query, such as the example
above, takes time to learn.  But if you find yourself using your
computer frequently enough, it is more than worthwhile in the long run.
Any tool you use often deserves the time spent learning to master it.
@footnote{For the understandably curious, here is what that command
looks like: But don't let it fool you; once you know what's going on,
it's easier than it looks: @code{ls -lt **/*.doc(Lk+50aM+5)}.}

@menu
* Contributors to Eshell::      People who have helped out!
@end menu

@node Contributors to Eshell
@section Contributors to Eshell
@cindex contributors
@cindex authors

Contributions to Eshell are welcome.  I have limited time to work on
this project, but I will gladly add any code you contribute to me to
this package.

The following persons have made contributions to Eshell.

@itemize @bullet
@item
John Wiegley is the original author of Eshell.

@item
Eli Zaretskii made it possible for Eshell to run without requiring
asynchronous subprocess support.  This is important for MS-DOS, which
does not have such support.

@item
Miles Bader contributed many fixes during the port to Emacs 21.

@item
Stefan Monnier fixed the things which bothered him, which of course made
things better for all.

@item
Gerd Moellmann also helped to contribute bug fixes during the initial
integration with Emacs 21.

@item
Alex Schroeder contributed code for interactively querying the user
before overwriting files.
@end itemize

Apart from these, a lot of people have sent suggestions, ideas,
requests, bug reports and encouragement.  Thanks a lot!  Without you
there would be no new releases of Eshell.

@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::
* Arguments::
* Built-ins::
* Variables::
* Aliases::
* History::
* Completion::
* for loop::
* Scripts::
@end menu

@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
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 alias (@pxref{Aliases}) with the same name as the
command, then a built-in (@pxref{Built-ins}) 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
apostrophes (@code{''}) and double quotes (@code{""}).  This is needed
especially for file names with special characters like pipe
(@code{|}), which could be part of remote file names.

@node Built-ins
@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
what will be applied by the @code{which} command:

@example
~ $ which ls
eshell/ls is a compiled Lisp function in `em-ls.el'
~ $ which *ls
/bin/ls
@end example

If you want to discard a given built-in command, you could declare an
alias (@pxref{Aliases}).  Example:

@example
~ $ which sudo
eshell/sudo is a compiled Lisp function in `em-tramp.el'.
~ $ alias sudo '*sudo $*'
~ $ which sudo
sudo is an alias, defined as "*sudo $*"
@end example

@vindex eshell-prefer-lisp-functions
If you would prefer to use the built-in commands instead of the external
commands, set @code{eshell-prefer-lisp-functions} to @code{t}.

Some of the built-in commands have different behavior from their
external counterparts, and some have no external counterpart.  Most of
these will print a usage message when given the @code{--help} option.

In some cases, a built-in command's behavior can be configured via
user settings, some of which are mentioned below.  For example,
certain commands have two user settings to allow them to overwrite
files without warning and to ensure that they always prompt before
overwriting files.  If both settings are non-@code{nil}, the commands
always prompt.  If both settings are @code{nil} (the default), the
commands signal an error.

Several commands observe the value of
@code{eshell-default-target-is-dot}.  If non-@code{nil}, then the
default target for the commands @command{cp}, @command{mv}, and
@command{ln} is the current directory.

A few commands are wrappers for more niche Emacs features, and can be
loaded as part of the eshell-xtra module.  @xref{Extension modules}.

@table @code

@item .
@cmindex .
Source an Eshell file in the current environment.  This is not to be
confused with the command @command{source}, which sources a file in a
subshell environment.

@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 adds it to the aliases file.

@item basename
@cmindex basename
Return a file name without its directory.

@item cat
@cmindex cat
Concatenate file contents into standard output.  If in a pipeline, or
if the file is not a regular file, directory, or symlink, then this
command reverts to the system's definition of @command{cat}.

@item cd
@cmindex cd
This command changes the current working directory.  Usually, it is
invoked as @kbd{cd @var{dir}} where @file{@var{dir}} is the new
working directory.  But @command{cd} knows about a few special
arguments:

@itemize @minus{}
@item
When it receives no argument at all, it changes to the home directory.

@item
Giving the command @kbd{cd -} changes back to the previous working
directory (this is the same as @kbd{cd $-}).

@item
The command @kbd{cd =} shows the directory stack.  Each line is
numbered.

@item
With @kbd{cd =foo}, Eshell searches the directory stack for a directory
matching the regular expression @samp{foo}, and changes to that
directory.

@item
With @kbd{cd -42}, you can access the directory stack slots by number.

@item
If @code{eshell-cd-shows-directory} is non-@code{nil}, @command{cd}
will report the directory it changes to.  If
@code{eshell-list-files-after-cd} is non-@code{nil}, then @command{ls}
is called with any remaining arguments after changing directories.
@end itemize

@item clear
@cmindex clear
Scrolls the contents of the Eshell window out of sight, leaving a
blank window.  If provided with an optional non-@code{nil} argument,
the scrollback contents are cleared instead.

@item clear-scrollback
@cmindex clear-scrollback
Clear the scrollback contents of the Eshell window.  Unlike the
command @command{clear}, this command deletes content in the Eshell
buffer.

@item cp
@cmindex cp
Copy a file to a new location or copy multiple files to the same
directory.

If @code{eshell-cp-overwrite-files} is non-@code{nil}, then
@command{cp} will overwrite files without warning.  If
@code{eshell-cp-interactive-query} is non-@code{nil}, then
@command{cp} will ask before overwriting anything.

@item date
@cmindex date
Print the current local time as a human-readable string.  This command
is similar to, but slightly different from, the GNU Coreutils
@command{date} command.

@item define
@cmindex define
Define a variable alias.
@xref{Variable Aliases, , , elisp, The Emacs Lisp Reference Manual}.

@item diff
@cmindex diff
Compare files using Emacs's internal @code{diff} (not to be confused
with @code{ediff}).  @xref{Comparing Files, , , emacs, The GNU Emacs
Manual}.

If @code{eshell-plain-diff-behavior} is non-@code{nil}, then this
command does not use Emacs's internal @code{diff}.  This is the same
as using @samp{alias diff '*diff $*'}.

@item dirname
@cmindex dirname
Return the directory component of a file name.

@item dirs
@cmindex dirs
Prints the directory stack.  Directories can be added or removed from
the stack using the commands @command{pushd} and @command{popd},
respectively.

@item du
@cmindex du
Summarize disk usage for each file.

@item echo
@cmindex echo
Echoes its input.  By default, this prints in a Lisp-friendly fashion
(so that the value is useful to a Lisp command using the result of
@command{echo} as an argument).  If a single argument is passed,
@command{echo} prints that; if multiple arguments are passed, it
prints a list of all the arguments; otherwise, it prints the empty
string.

If @code{eshell-plain-echo-behavior} is non-@code{nil}, @command{echo}
will try to behave more like a plain shell's @command{echo}, printing
each argument as a string, separated by a space.

@item env
@cmindex env
Prints the current environment variables.  Unlike in Bash, this
command does not yet support running commands with a modified
environment.

@item exit
@cmindex exit
Exit Eshell and save the history.  By default, this command kills the
Eshell buffer, but if @code{eshell-kill-on-exit} is @code{nil}, then
the buffer is merely buried instead.

@item export
@cmindex export
Set environment variables using input like Bash's @command{export}, as
in @samp{export @var{var1}=@var{val1} @var{var2}=@var{val2} @dots{}}.

@item expr
@cmindex expr
An implementation of @command{expr} using the Calc package.
@xref{Top,,, calc, The GNU Emacs Calculator}.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@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.
@xref{Grep Searching, , , emacs, The GNU Emacs Manual}.

If @code{eshell-plain-grep-behavior} is non-@code{nil}, then these
commands do not use Emacs's internal @code{grep}.  This is the same as
using @samp{alias grep '*grep $*'}, though this setting applies to all
of the built-in commands for which you would need to create a separate
alias.

@item history
@cmindex history
Prints Eshell's input history.  With a numeric argument @var{N}, this
command prints the @var{N} most recent items in the history.

@item info
@cmindex info
Browse the available Info documentation.  This command is the same as
the external @command{info} command, but uses Emacs's internal Info
reader.
@xref{Misc Help, , , emacs, The GNU Emacs Manual}.

@item intersection
@cmindex intersection
A wrapper around the function @code{cl-intersection} (@pxref{Lists as
Sets,,, cl, GNU Emacs Common Lisp Emulation}).  This command
can be used for comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@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 which can either be a number or a signal name.

@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 ln
@cmindex ln
Create links to files.

If @code{eshell-ln-overwrite-files} is non-@code{nil}, @command{ln}
will overwrite files without warning.  If
@code{eshell-ln-interactive-query} is non-@code{nil}, then
@command{ln} will ask before overwriting files.

@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, , , emacs, The GNU Emacs Manual}.

If @code{eshell-plain-locate-behavior} is non-@code{nil}, then Emacs's
internal @code{locate} is not used.  This is the same as using
@samp{alias locate '*locate $*'}.

@item ls
@cmindex ls
Lists the contents of directories.

If @code{eshell-ls-use-colors} is non-@code{nil}, the contents of a
directory is color-coded according to file type and status.  These
colors and the regexps used to identify their corresponding files can
be customized via @w{@kbd{M-x customize-group @key{RET} eshell-ls @key{RET}}}.

The user option @code{eshell-ls-date-format} determines how the date
is displayed when using the @option{-l} option.  The date is produced
using the function @code{format-time-string} (@pxref{Time Parsing,,,
elisp, GNU Emacs Lisp Reference Manual}).

The user option @code{eshell-ls-initial-args} contains a list of
arguments to include with any call to @command{ls}.  For example, you
can include the option @option{-h} to always use a more human-readable
format.

The user option @code{eshell-ls-default-blocksize} determines the
default blocksize used when displaying file sizes with the option
@option{-s}.

@item make
@cmindex make
Run @command{make} through @code{compile} when run asynchronously
(e.g., @samp{make &}).  @xref{Compilation, , , emacs, The GNU Emacs
Manual}.  Otherwise call the external @command{make} command.

@item man
@cmindex man
Display Man pages using the Emacs @code{man} command.
@xref{Man Page, , , emacs, The GNU Emacs Manual}.

@item mismatch
@cmindex mismatch
A wrapper around the function @code{cl-mismatch} (@pxref{Searching
Sequences,,, cl, GNU Emacs Common Lisp Emulation}).  This command can
be used for comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@item mkdir
@cmindex mkdir
Make new directories.

@item mv
@cmindex mv
Move or rename files.

If @code{eshell-mv-overwrite-files} is non-@code{nil}, @command{mv}
will overwrite files without warning.  If
@code{eshell-mv-interactive-query} is non-@code{nil}, @command{mv}
will prompt before overwriting anything.

@item occur
@cmindex occur
Alias to Emacs's @code{occur}.
@xref{Other Repeating Search, , , emacs, The GNU Emacs Manual}.

@item popd
@cmindex popd
Pop a directory from the directory stack and switch to a another place
in the stack.

@item printnl
@cmindex printnl
Print the arguments separated by newlines.

@item pushd
@cmindex pushd
Push the current directory onto the directory stack, then change to
another directory.

If @code{eshell-pushd-dunique} is non-@code{nil}, then only unique
directories will be added to the stack.  If
@code{eshell-pushd-dextract} is non-@code{nil}, then @samp{pushd
+@var{n}} will pop the @var{n}th directory to the top of the stack.

@item pwd
@cmindex pwd
Prints the current working directory.

@item rm
@cmindex rm
Removes files, buffers, processes, or Emacs Lisp symbols, depending on
the argument.

If @code{eshell-rm-interactive-query} is non-@code{nil}, @command{rm}
will prompt before removing anything.  If
@code{eshell-rm-removes-directories} is non-@code{nil}, then
@command{rm} can also remove directories.  Otherwise, @command{rmdir}
is required.

@item rmdir
@cmindex rmdir
Removes directories if they are empty.

@item set-difference
@cmindex set-difference
A wrapper around the function @code{cl-set-difference} (@pxref{Lists as
Sets,,, cl, GNU Emacs Common Lisp Emulation}).  This command
can be used for comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@item set-exclusive-or
@cmindex set-exclusive-or
A wrapper around the function @code{cl-set-exclusive-or} (@pxref{Lists
as Sets,,, cl, GNU Emacs Common Lisp Emulation}).  This command can be
used for comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@item setq
@cmindex setq
Set variable values, using the function @code{setq} like a command.
@xref{Setting Variables,,, elisp, GNU Emacs Lisp Reference Manual}.

@item source
@cmindex source
Source an Eshell file in a subshell environment.  This is not to be
confused with the command @command{.}, which sources a file in the
current environment.

@item su
@cmindex su
@itemx sudo
@cmindex sudo
Uses TRAMP's @command{su} or @command{sudo} method @pxref{Inline methods, , , tramp}
to run a command via @command{su} or @command{sudo}.  These commands
are in the eshell-tramp module, which is disabled by default.


@item substitute
@cmindex substitute
A wrapper around the function @code{cl-substitute} (@pxref{Sequence
Functions,,, cl, GNU Emacs Common Lisp Emulation}).  This command can
be used for comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@item time
@cmindex time
Show the time elapsed during a command's execution.

@item umask
@cmindex umask
Set or view the default file permissions for newly created files and
directories.

@item union
@cmindex union
A wrapper around the function @code{cl-union} (@pxref{Lists as Sets,,,
cl, GNU Emacs Common Lisp Emulation}).  This command can be used for
comparing lists of strings.

This command can be loaded as part of the eshell-xtra module, which is
disabled by default.

@item unset
@cmindex unset
Unset an environment variable.

@item wait
@cmindex wait
Wait until a process has successfully completed.

@item which
@cmindex which
Identify a command and its location.

@item whoami
@cmindex whoami
Print the current user.  This Eshell version of @command{whoami}
supports Tramp.
@end table

@subsection Defining new built-in commands
While Eshell can run Lisp functions directly as commands, it may be
more convenient to provide a special built-in command for
Eshell.  Built-in commands are just ordinary Lisp functions designed
to be called from Eshell.  When defining an Eshell-specific version of
an existing function, you can give that function a name starting with
@code{eshell/} so that Eshell knows to use it.

@defmac eshell-eval-using-options name macro-args options body@dots{}
This macro processes a list of @var{macro-args} for the command
@var{name} using a set of command line @var{options}.  If the
arguments are parsed successfully, it will store the resulting values
in local symbols and execute @var{body}; any remaining arguments will
be available in the locally let-bound variable @code{args}.  The
return value is the value of the last form in @var{body}.

If an unknown option was passed in @var{macro-args} and an external
command was specified (see below), this macro will start a process for
that command and throw the tag @code{eshell-external} with the new
process as its value.

@var{options} should be a list beginning with one or more elements of
the following form, with each element representing a particular
command-line switch:

@example
(@var{short} @var{long} @var{value} @var{symbol} @var{help-string})
@end example

@table @var
@item short
This element, if non-nil, should be a character to be used as a short
switch, like @code{-@var{short}}.  At least one of this element and
@var{long} must be non-nil.

@item long
This element, if non-nil, should be a string to be used as a long
switch, like @code{--@var{long}}.

@item value
This element is the value associated with the option.  It can be
either:

@table @asis
@item @code{t}
The option needs a value to be specified after the switch.

@item @code{nil}
The option is given the value @code{t}.

@item anything else
The option is given the specified value.
@end table

@item symbol
This element is the Lisp symbol that will be bound to @var{value}.  If
@var{symbol} is @code{nil}, specifying this switch will instead call
@code{eshell-show-usage}, and so is appropriate for an option like
@code{--help}.

@item help-string
This element is a documentation string for the option, which will be
displayed when @code{eshell-show-usage} is invoked.
@end table

After the list of command-line switch elements, @var{options} can
include additional keyword arguments to control how
@code{eshell-eval-using-options} behaves.  Some of these take
arguments, while others don't.  The recognized keywords are:

@table @code
@item :external @var{string}
Specify @var{string} as an external command to run if there are
unknown switches in @var{macro-args}.

@item :usage @var{string}
Set @var{string} as the initial part of the command's documentation
string.  It appears before the options are listed.

@item :post-usage @var{string}
Set @var{string} to be the (optional) trailing part of the command's
documentation string.  It appears after the list of options, but
before the final part of the documentation about the associated
external command, if there is one.

@item :show-usage
If present, then show the usage message if the command is called with
no arguments.

@item :preserve-args
Normally, @code{eshell-eval-using-options} flattens the list of
arguments in @var{macro-args} and converts each to a string.  If this
keyword is present, avoid doing that, instead preserving the original
arguments.  This is useful for commands which want to accept arbitrary
Lisp objects.

@item :parse-leading-options-only
If present, do not parse dash or switch arguments after the first
positional argument.  Instead, treat them as positional arguments
themselves.
@end table

For example, you could handle a subset of the options for the
@code{ls} command like this:

@example
(eshell-eval-using-options
 "ls" macro-args
 '((?a  nil      nil show-all       "show all files")
   (?I  "ignore" t   ignore-pattern "ignore files matching pattern")
   (nil "help"   nil nil            "show this help message")
 :external "ls"
 :usage "[OPTION]... [FILE]...
  List information about FILEs (the current directory by default).")
 ;; List the files in ARGS somehow...
 )
@end example

@end defmac

@subsection 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

@xref{Aliases}, for the built-in variables @samp{$*}, @samp{$1},
@samp{$2}, @dots{}, in alias definitions.

@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

@vindex $*
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 @kbd{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 @code{eshell-aliases-file},
which you can also edit directly (although you will have to manually
reload it).

@vindex $1, $2, @dots{}
Note that unlike aliases in Bash, arguments must be handled
explicitly.  Typically the alias definition would end in @samp{$*} to
pass all arguments along.  More selective use of arguments via
@samp{$1}, @samp{$2}, etc., is also possible.  For example,
@kbd{alias mcd 'mkdir $1 && cd $1'} would cause @kbd{mcd foo} to
create and switch to a directory called @samp{foo}.

@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
command invocation, therefore the @samp{history} command shall be
applied before using the expansion mechanism with history numbers.

The n-th entry of the history ring can be applied with the @samp{!n}
command.  If @code{n} is negative, the entry is counted from the end
of the history ring.

@cindex event designators
@findex eshell-expand-history-references
When history event designators are enabled (by adding
@code{eshell-expand-history-references} to
@code{eshell-expand-input-functions}), @samp{!foo} expands to the last
command beginning with @code{foo}, and @samp{!?foo} to the last
command containing @code{foo}.  The n-th argument of the last command
beginning with @code{foo} is accessible by @code{!foo:n}.

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 @code{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
previous 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, the
pattern will be removed from the input line, and replaced by the
completion.

If you want to see the entire list of possible completions (e.g. when it's
below the @code{completion-cycle-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 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
@code{for VAR in TOKENS @{ command invocation(s) @}}
@end example

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 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
* Dollars Expansion::
* Globbing::
@end menu

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

@table @code

@item $@var{var}
Expands to the value bound to @var{var}.  This is the main way to use
variables in command invocations.

@item $"@var{var}"
@item $'@var{var}'
Expands to the value bound to @var{var}.  This is useful to
disambiguate the variable name when concatenating it with another
value, such as @samp{$"@var{var}"-suffix}.

@item $(@var{lisp})
Expands to the result of evaluating the S-expression @code{(@var{lisp})}.  On
its own, this is identical to just @code{(@var{lisp})}, but with the @code{$},
it can be used in a string, such as @samp{/some/path/$(@var{lisp}).txt}.

@item $@{@var{command}@}
Returns the output of @command{@var{command}}, which can be any valid Eshell
command invocation, and may even contain expansions.

@item $<@var{command}>
As with @samp{$@{@var{command}@}}, evaluates the Eshell command invocation
@command{@var{command}}, but writes the output to a temporary file and
returns the file name.

@item $@var{expr}[@var{i...}]
Expands to the @var{i}th element of the result of @var{expr}, an
expression in one of the above forms listed here.  If multiple indices
are supplied, this will return a list containing the elements for each
index.  The exact behavior depends on the type of @var{expr}'s value:

@table @asis

@item a sequence
Expands to the element at the (zero-based) index @var{i} of the
sequence (@pxref{Sequences Arrays Vectors, Sequences, , elisp, The
Emacs Lisp Reference Manual}).

@item a string
Split the string at whitespace, and then expand to the @var{i}th
element of the resulting sequence.

@item an alist
If @var{i} is a non-numeric value, expand to the value associated with
the key @code{"@var{i}"} in the alist.  For example, if @var{var} is
@samp{(("dog" . "fido") ("cat" . "felix"))}, then
@samp{$@var{var}[dog]} expands to @code{"fido"}.  Otherwise, this
behaves as with sequences; e.g., @samp{$@var{var}[0]} expands to
@code{("dog" . "fido")}.  @xref{Association List Type, Association
Lists, , elisp, The Emacs Lisp Reference Manual}.

@item anything else
Signals an error.

@end table

Multiple sets of indices can also be specified.  For example, if
@var{var} is @samp{((1 2) (3 4))}, then @samp{$@var{var}[0][1]} will
expand to @code{2}, i.e.@: the second element of the first list member
(all indices are zero-based).

@item $@var{expr}[@var{regexp} @var{i...}]
As above (when @var{expr} expands to a string), but use @var{regexp}
to split the string.  @var{regexp} can be any form other than a
number.  For example, @samp{$@var{var}[: 0]} will return the first
element of a colon-delimited string.

@item $#@var{expr}
Expands to the length of the result of @var{expr}, an expression in
one of the above forms.  For example, @samp{$#@var{var}} returns the
length of the variable @var{var} and @samp{$#@var{var}[0]} returns the
length of the first element of @var{var}.  Again, signals an error if
the result of @var{expr} is not a string or a sequence.

@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.  @xref{Filename Generation, , ,
zsh, The Z Shell Manual},
for full syntax.  To customize the syntax and behavior of globbing in
Eshell see the Customize@footnote{@xref{Easy Customization, , , emacs,
The GNU Emacs Manual}.}
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.

@section Visual Commands
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 such programs in Emacs's
terminal emulator.

Programs that need a terminal to display output properly are referred
to in this manual as ``visual commands'', because they are not simply
line-oriented.  You must tell Eshell which commands are visual, by
adding them to @code{eshell-visual-commands}; for commands that are
visual for only certain @emph{sub}-commands -- e.g., @samp{git log} but
not @samp{git status} -- use @code{eshell-visual-subcommands}; and for
commands that are visual only when passed certain options, use
@code{eshell-visual-options}.

Caution: Some tools such as Git use the pager @samp{less} by default
to paginate their output but call it with its @samp{-F} option.  This
option causes @samp{less} to echo the output instead of paginating it
if the output is less than one page long.  This causes undesirable
behavior if, e.g., @samp{git diff}, is defined as a visual subcommand.
It'll work if the output is big enough and fail if it is less than one
page long.  If that occurs to you, search for configuration options
for calling @samp{less} without the @samp{-F} option.  For Git, you
can do that using @samp{git config --global core.pager 'less -+F'}.

@vindex eshell-destroy-buffer-when-process-dies
If you want the buffers created by visual programs killed when the
program exits, customize the variable
@code{eshell-destroy-buffer-when-process-dies} to a non-@code{nil}
value; the default is @code{nil}.

@section Redirection
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 buffers, using
the @code{>>>} redirection operator, and Elisp functions, using
virtual devices.

The buffer redirection operator, @code{>>>}, expects a buffer object
on the right-hand side, into which it inserts the output of the
left-hand side.  e.g., @samp{echo hello >>> #<buffer *scratch*>}
inserts the string @code{"hello"} into the @file{*scratch*} buffer.
The convenience shorthand variant @samp{#<@var{buffer-name}>}, as in
@samp{#<*scratch*>}, is also accepted.

@code{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 @samp{("/dev/name" @var{function} @var{mode})} to
@code{eshell-virtual-targets}.  The first element is the device name;
@var{function} may be either a lambda or a function name.  If
@var{mode} is @code{nil}, then the function is the output function; if it is
non-@code{nil}, then the function is passed the redirection mode as a
symbol--@code{overwrite} for @code{>}, @code{append} for @code{>>}, or
@code{insert} for @code{>>>}--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.

@section Running Shell Pipelines Natively
When constructing shell pipelines that will move a lot of data, it is
a good idea to bypass Eshell's own pipelining support and use the
operating system shell's instead.  This is especially relevant when
executing commands on a remote machine using Eshell's Tramp
integration: using the remote shell's pipelining avoids copying the
data which will flow through the pipeline to local Emacs buffers and
then right back again.

Eshell recognises a special syntax to make it easier to convert
pipelines so as to bypass Eshell's pipelining.  Prefixing at least one
@code{|}, @code{<} or @code{>} with an asterisk marks a command as
intended for the operating system shell.  To make it harder to invoke
this functionality accidentally, it is also required that the asterisk
be preceded by whitespace or located at the start of input.  For
example,

@example
 cat *.ogg *| my-cool-decoder >file
@end example

Executing this command will not copy all the data in the *.ogg files,
nor the decoded data, into Emacs buffers, as would normally happen.

The command is interpreted as extending up to the next @code{|}
character which is not preceded by an unescaped asterisk following
whitespace, or the end of the input if there is no such character.
Thus, all @code{<} and @code{>} redirections occuring before the next
asterisk-unprefixed @code{|} are implicitly prefixed with (whitespace
and) asterisks.  An exception is that Eshell-specific redirects right
at the end of the command are excluded.  This allows input like this:

@example
 foo *| baz >#<buffer quux>
@end example

@noindent which is equivalent to input like this:

@example
 sh -c "foo | baz" >#<buffer quux>
@end example

@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, , ,
elisp, The Emacs Lisp Reference Manual}.}
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-lib)
  (require 'esh-mode)
  (require 'eshell))

(require 'esh-util)
@end example

@menu
* Writing a module::
* Module testing::
* Directory handling::
* Key rebinding::
* Smart scrolling::
* Terminal emulation::
@end menu

@node Writing a module
@section Writing a module

This section is not yet written.

@node Module testing
@section Module testing

This section is not yet written.

@node Directory handling
@section Directory handling

This section is not yet written.

@node Key rebinding
@section Key rebinding

This section is not yet written.

@node Smart scrolling
@section Smart scrolling

This section is not yet written.

@node Terminal emulation
@section Terminal emulation

This section is not yet written.

@node Bugs and ideas
@chapter Bugs and ideas
@cindex reporting bugs and ideas
@cindex bugs, how to report them
@cindex author, how to reach
@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 report it, by
using @kbd{M-x report-emacs-bug}.  The same applies to feature requests.
It is best to discuss one thing at a time.  If you find several
unrelated bugs, please report them separately.

@ignore
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!
@end ignore

Below is a list of some known problems with Eshell version 2.4.2,
which is the version included with Emacs 22.

@table @asis
@item Documentation incomplete

@item Differentiate between aliases and functions

Allow for a Bash-compatible syntax, such as:

@example
alias arg=blah
function arg () @{ blah $* @}
@end example

@item @samp{for i in 1 2 3 @{ grep -q a b && *echo has it @} | wc -l} outputs result after prompt

In fact, piping to a process from a looping construct doesn't work in
general.  If I change the call to @code{eshell-copy-handles} in
@code{eshell-rewrite-for-command} to use @code{eshell-protect}, it seems
to work, but the output occurs after the prompt is displayed.  The whole
structured command thing is too complicated at present.

@item Pcomplete sometimes gets stuck

You press @key{TAB}, but no completions appear, even though the
directory has matching files.  This behavior is rare.

@item @samp{grep python $<rpm -qa>} doesn't work, but using @samp{*grep} does

This happens because the @code{grep} Lisp function returns immediately,
and then the asynchronous @command{grep} process expects to examine the
temporary file, which has since been deleted.

@item Problem with C-r repeating text

If the text @emph{before point} reads "./run", and you type @kbd{C-r r u
n}, it will repeat the line for every character typed.

@item Backspace doesn't scroll back after continuing (in smart mode)

Hitting space during a process invocation, such as @command{make}, will
cause it to track the bottom of the output; but backspace no longer
scrolls back.

@item It's not possible to fully @code{unload-feature} Eshell

@item Menu support was removed, but never put back

@item Using C-p and C-n with rebind gets into a locked state

This happened a few times in Emacs 21, but has been irreproducible
since.

@item If an interactive process is currently running, @kbd{M-!} doesn't work

@item Use a timer instead of @code{sleep-for} when killing child processes

@item Piping to a Lisp function is not supported

Make it so that the Lisp command on the right of the pipe is repeatedly
called with the input strings as arguments.  This will require changing
@code{eshell-do-pipelines} to handle non-process targets.

@item Input redirection is not supported

See the above entry.

@item Problem running @command{less} without arguments on Windows

The result in the Eshell buffer is:

@example
Spawning child process: invalid argument
@end example

Also a new @command{less} buffer was created with nothing in it@dots{}
(presumably this holds the output of @command{less}).

If @command{less.exe} is invoked from the Eshell command line, the
expected output is written to the buffer.

Note that this happens on NT-Emacs 20.6.1 on Windows 2000. The term.el
package and the supplied shell both use the @command{cmdproxy} program
for running shells.

@item Implement @samp{-r}, @samp{-n} and @samp{-s} switches for @command{cp}

@item Make @kbd{M-5 M-x eshell} switch to ``*eshell<5>*'', creating if need be

@item @samp{mv @var{dir} @var{file}.tar} does not remove directories

This is because the tar option --remove-files doesn't do so.  Should it
be Eshell's job?

@item Bind @code{standard-output} and @code{standard-error}

This would be so that if a Lisp function calls @code{print}, everything
will happen as it should (albeit slowly).

@item When an extension module fails to load, @samp{cd /} gives a Lisp error

@item If a globbing pattern returns one match, should it be a list?

@item Make sure syntax table is correct in Eshell mode

So that @kbd{M-@key{DEL}} acts in a predictable manner, etc.

@item Allow all Eshell buffers to share the same history and list-dir

@item There is a problem with script commands that output to @file{/dev/null}

If a script file, somewhere in the middle, uses @samp{> /dev/null},
output from all subsequent commands is swallowed.

@item Split up parsing of text after @samp{$} in @file{esh-var.el}

Make it similar to the way that @file{esh-arg.el} is structured.
Then add parsing of @samp{$[?\n]}.

@item After pressing @kbd{M-@key{RET}}, redisplay before running the next command

@item Argument predicates and modifiers should work anywhere in a path

@example
/usr/local/src/editors/vim $ vi **/CVS(/)/Root(.)  Invalid regexp:
"Unmatched ( or \\("
@end example

With @command{zsh}, the glob above expands to all files named
@file{Root} in directories named @file{CVS}.

@item Typing @samp{echo $@{locate locate@}/bin@key{TAB}} results in a Lisp error

Perhaps it should interpolate all permutations, and make that the
globbing result, since otherwise hitting return here will result in
``(list of filenames)/bin'', which is never valuable.  Thus, one could
@command{cat} only C backup files by using @samp{ls $@{identity *.c@}~}.
In that case, having an alias command name @command{glob} for
@command{identity} would be useful.

@item Once symbolic mode is supported for @command{umask}, implement @command{chmod} in Lisp

@item Create @code{eshell-expand-file-name}

This would use a data table to transform things such as @samp{~+},
@samp{...}, etc.

@item Abstract @file{em-smart.el} into @file{smart-scroll.el}

It only really needs: to be hooked onto the output filter and the
pre-command hook, and to have the input-end and input-start markers.
And to know whether the last output group was ``successful.''

@item Allow for fully persisting the state of Eshell

This would include: variables, history, buffer, input, dir stack, etc.

@item Implement D as an argument predicate

It means that files beginning with a dot should be included in the
glob match.

@item A comma in a predicate list should mean OR

At the moment, this is not supported.

@item Error if a glob doesn't expand due to a predicate

An error should be generated only if @code{eshell-error-if-no-glob} is
non-@code{nil}.

@item @samp{(+ @key{RET} @key{SPC} @key{TAB}} does not cause @code{indent-according-to-mode} to occur

@item Create @code{eshell-auto-accumulate-list}

This is a list of commands for which, if the user presses @kbd{RET}, the
text is staged as the next Eshell command, rather than being sent to the
current interactive process.

@item Display file and line number if an error occurs in a script

@item @command{wait} doesn't work with process ids at the moment

@item Enable the direct-to-process input code in @file{em-term.el}

@item Problem with repeating @samp{echo $@{find /tmp@}}

With smart display active, if @kbd{RET} is held down, after a while it
can't keep up anymore and starts outputting blank lines.  It only
happens if an asynchronous process is involved@dots{}

I think the problem is that @code{eshell-send-input} is resetting the
input target location, so that if the asynchronous process is not done
by the time the next @kbd{RET} is received, the input processor thinks
that the input is meant for the process; which, when smart display is
enabled, will be the text of the last command line!  That is a bug in
itself.

In holding down @kbd{RET} while an asynchronous process is running,
there will be a point in between termination of the process, and the
running of @code{eshell-post-command-hook}, which would cause
@code{eshell-send-input} to call @code{eshell-copy-old-input}, and then
process that text as a command to be run after the process.  Perhaps
there should be a way of killing pending input between the death of the
process, and the @code{post-command-hook}.

@item Allow for a more aggressive smart display mode

Perhaps toggled by a command, that makes each output block a smart
display block.

@item Create more meta variables

@table @samp
@item $!
The reason for the failure of the last disk command, or the text of the
last Lisp error.

@item $=
A special associate array, which can take references of the form
@samp{$=[REGEXP]}.  It indexes into the directory ring.
@end table

@item Eshell scripts can't execute in the background

@item Support zsh's ``Parameter Expansion'' syntax, i.e., @samp{$@{@var{name}:-@var{val}@}}

@item Write an @command{info} alias that can take arguments

So that the user can enter @samp{info chmod}, for example.

@item Create a mode @code{eshell-browse}

It would treat the Eshell buffer as an outline.  Collapsing the outline
hides all of the output text.  Collapsing again would show only the
first command run in each directory

@item Allow other revisions of a file to be referenced using @samp{file@{rev@}}

This would be expanded by @code{eshell-expand-file-name} (see above).

@item Print ``You have new mail'' when the ``Mail'' icon is turned on

@item Implement @kbd{M-|} for Eshell

@item Implement input redirection

If it's a Lisp function, input redirection implies @command{xargs} (in a
way@dots{}).  If input redirection is added, also update the
@code{file-name-quote-list}, and the delimiter list.

@item Allow @samp{#<@var{word} @var{arg}>} as a generic syntax

With the handling of @emph{word} specified by an
@code{eshell-special-alist}.

@item In @code{eshell-eval-using-options}, allow a @code{:complete} tag

It would be used to provide completion rules for that command.  Then the
macro will automagically define the completion function.

@item For @code{eshell-command-on-region}, apply redirections to the result

So that @samp{+ > 'blah} would cause the result of the @code{+} (using
input from the current region) to be inserting into the symbol
@code{blah}.

If an external command is being invoked, the input is sent as standard
input, as if a @samp{cat <region> |} had been invoked.

If a Lisp command, or an alias, is invoked, then if the line has no
newline characters, it is divided by whitespace and passed as arguments
to the Lisp function.  Otherwise, it is divided at the newline
characters.  Thus, invoking @code{+} on a series of numbers will add
them; @code{min} would display the smallest figure, etc.

@item Write @code{eshell-script-mode} as a minor mode

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 Bash-style support

This means @samp{!n}, @samp{!#}, @samp{!:%}, and @samp{!:1-} as separate
from @samp{!:1*}.

@item Support the -n command line option for @command{history}

@item Implement @command{fc} in Lisp

@item Specifying a frame as a redirection target should imply the currently active window's buffer

@item Implement @samp{>@var{func-or-func-list}}

This would allow for an ``output translators'', that take a function to
modify output with, and a target.  Devise a syntax that works well with
pipes, and can accommodate multiple functions (i.e., @samp{>'(upcase
regexp-quote)} or @samp{>'upcase}).

@item Allow Eshell to read/write to/from standard input and output

This would be optional, rather than always using the Eshell buffer.
This would allow it to be run from the command line (perhaps).

@item Write a @command{help} command

It would call subcommands with @option{--help}, or @option{-h} or
@option{/?}, as appropriate.

@item Implement @command{stty} in Lisp

@item Support @command{rc}'s matching operator, e.g., @samp{~ (@var{list}) @var{regexp}}

@item Implement @command{bg} and @command{fg} as editors of @code{eshell-process-list}

Using @command{bg} on a process that is already in the background does
nothing.  Specifying redirection targets replaces (or adds) to the list
current being used.

@item Have @command{jobs} print only the processes for the current shell

@item How can Eshell learn if a background process has requested input?

@item Support @samp{2>&1} and @samp{>&} and @samp{2>} and @samp{|&}

The syntax table for parsing these should be customizable, such that the
user could change it to use rc syntax: @samp{>[2=1]}.

@item Allow @samp{$_[-1]}, which would indicate the last element of the array

@item Make @samp{$x[*]} equal to listing out the full contents of @samp{x}

Return them as a list, so that @samp{$_[*]} is all the arguments of the
last command.

@item Copy ANSI code handling from @file{term.el} into @file{em-term.el}

Make it possible for the user to send char-by-char to the underlying
process.  Ultimately, I should be able to move away from using term.el
altogether, since everything but the ANSI code handling is already part
of Eshell.  Then, things would work correctly on MS-Windows as well
(which doesn't have @file{/bin/sh}, although @file{term.el} tries to use
it).

@item Make the shell spawning commands be visual

That is, make (@command{su}, @command{bash}, @command{telnet},
@command{rlogin}, @command{rsh}, etc.)@: be part of
@code{eshell-visual-commands}.  The only exception is if the shell is
being used to invoke a single command.  Then, the behavior should be
based on what that command is.

@item Create a smart viewing command named @command{open}

This would search for some way to open its argument (similar to opening
a file in the Windows Explorer).

@item Alias @command{read} to be the same as @command{open}, only read-only

@item Write a @command{tail} command which uses @code{view-file}

It would move point to the end of the buffer, and then turns on
auto-revert mode in that buffer at frequent intervals---and a
@command{head} alias which assumes an upper limit of
@code{eshell-maximum-line-length} characters per line.

@item Make @command{dgrep} load @code{dired}, mark everything, then invoke @code{dired-do-search}

@item Write @file{mesh.c}

This would run Emacs with the appropriate arguments to invoke Eshell
only.  That way, it could be listed as a login shell.

@item Use an intangible @code{PS2} string for multi-line input prompts

@item Auto-detect when a command is visual, by checking @code{TERMCAP} usage

@item The first keypress after @kbd{M-x watson} triggers
@code{eshell-send-input}

@item Make @kbd{/} electric

So that it automatically expands and corrects pathnames.  Or make
pathname completion for Pcomplete auto-expand @samp{/u/i/std@key{TAB}} to
@samp{/usr/include/std@key{TAB}}.

@item Write the @command{pushd} stack to disk along with @code{last-dir-ring}

@item Add options to @code{eshell/cat} which would allow it to sort and uniq

@item Implement @command{wc} in Lisp

Add support for counting sentences, paragraphs, pages, etc.

@item Once piping is added, implement @command{sort} and @command{uniq} in Lisp

@item Implement @command{touch} in Lisp

@item Implement @command{comm} in Lisp

@item Implement an @command{epatch} command in Lisp

This would call @code{ediff-patch-file}, or @code{ediff-patch-buffer},
depending on its argument.

@item Have an option such that @samp{ls -l} generates a dired buffer

@item Write a version of @command{xargs} based on command rewriting

That is, @samp{find X | xargs Y} would be indicated using @samp{Y
$@{find X@}}.  Maybe @code{eshell-do-pipelines} could be changed to
perform this on-thy-fly rewriting.

@item Write an alias for @command{less} that brings up a @code{view-mode} buffer

Such that the user can press @key{SPC} and @key{DEL}, and then @kbd{q}
to return to Eshell.  It would be equivalent to:
@samp{X > #<buffer Y>; view-buffer #<buffer Y>}.

@item Make @code{eshell-mode} as much a full citizen as @code{shell-mode}

Everywhere in Emacs where @code{shell-mode} is specially noticed, add
@code{eshell-mode} there.

@item Permit the umask to be selectively set on a @command{cp} target

@item Problem using @kbd{M-x eshell} after using @code{eshell-command}

If the first thing that I do after entering Emacs is to run
@code{eshell-command} and invoke @command{ls}, and then use @kbd{M-x
eshell}, it doesn't display anything.

@item @kbd{M-@key{RET}} during a long command (using smart display) doesn't work

Since it keeps the cursor up where the command was invoked.

@end table

@node GNU Free Documentation License
@appendix GNU Free Documentation License
@include doclicense.texi

@node Concept Index
@unnumbered Concept Index

@printindex cp

@node Function and Variable Index
@unnumbered Function and Variable Index

@printindex fn

@node Command Index
@unnumbered Command Index

@printindex cm

@c There are no @kindex entries in this manual; avoid generating an
@c empty menu.
@ignore
@node Key Index
@unnumbered Key Index

@printindex ky
@end ignore

@bye