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

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

Copyright @copyright{} 1999--2024 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, The Emacs Editor}) REPL@footnote{Short for
``Read-Eval-Print Loop''.} 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.
* Entry Points::
* Commands::
* Expansion::
* Input/Output::
* Interaction::
* 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::
* Key Index::
@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+100aM+6)}.}

@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 Entry Points
@chapter Entry Points
@cindex starting Eshell
@cindex Eshell, starting

Eshell provides several different ways to start it, depending on the
situation.

@menu
* Interactive Shell::
* One-Off Commands::
* Scripts::
@end menu

@node Interactive Shell
@section Interactive Shell
@cindex interactive session

The most common way to use Eshell is via an interactive shell.  You can
start this via the @code{eshell} command:

@deffn Command eshell &optional arg
Start a new interactive Eshell session, or switch to an already active
session.  The exact behavior depends on the value of @var{arg}
(interactively, the prefix argument):

@table @asis

@item @code{nil} or omitted
Start or switch to the default Eshell session.  This is the behavior
when typing @kbd{M-x eshell @key{RET}}.

@item a number
Start or switch to the Eshell session with the specified number (e.g.@:
@samp{*eshell*<2>}).

@item anything else
Start a new Eshell session, no matter if another one already exists.

@end table
@end deffn

@node One-Off Commands
@section One-Off Commands
@cindex command invocation, from anywhere

You can also run individual Eshell commands from anywhere within Emacs:

@deffn Command eshell-command command &optional output-target error-target
Execute the Eshell command string @var{command} and show the output in a
buffer.  If @var{output-target} is @code{t} (interactively, with the
prefix argument), write the command's standard output to the current
buffer at point.  If @code{nil}, write the output to a new output
buffer.  For any other value, output to that Eshell target
(@pxref{Redirection}).

@var{error-target} is similar to @var{output-target}, except that it
controls where to write standard error, and a @code{nil} value means to
write standard error to the same place as standard output.  (To suppress
standard error, you can write to the Eshell virtual target
@file{/dev/null}.)

When the command ends with @kbd{&}, Eshell will evaluate the command
asynchronously.  Otherwise, it will wait until the command has finished
execution.
@end deffn

@defun eshell-command-result command &optional status-var
Execute the Eshell command string @var{command} and return the result,
like using the variable @code{$$} in an interactive session
(@pxref{Variables}).  If @var{status-var} is a symbol, this function
will set it to the exit status of the command (like using the variable
@code{$?} in an interactive session).
@end defun

@node Scripts
@section Scripts
@cindex scripts

@cmindex source
@cmindex .
Like other shells, you can create Eshell @dfn{scripts}.  An Eshell
script is simply a file containing a sequence of commands that will be
executed as though you entered them one at a time in an interactive
Eshell session.  You can invoke these scripts from within Eshell with
@command{source}, which will run the script in a subshell.  If you wish
to run a script in your @emph{current} Eshell environment, use the
@code{.} command instead.

Like with aliases (@pxref{Aliases}), Eshell scripts can accept any
number of arguments.  Within the script, you can refer to these with
the special variables @code{$0}, @code{$1}, @dots{}, @code{$9}, and
@code{$*}.

You can also invoke Eshell scripts from outside of Eshell:

@deffn Command eshell-execute-file file &optional args output-target error-target
Execute the Eshell commands contained in @var{file}, passing an optional
list of @var{args} to the script.  If @var{output-target} is @code{t}
(interactively, with the prefix argument), write the command output to
the current buffer.  If @code{nil}, don't write the output anywhere.
For any other value, output to the corresponding Eshell target
(@pxref{Redirection}).

@var{error-target} is similar to @var{output-target}, except that it
controls where to write standard error, and a @code{nil} value means to
write standard error to the same place as standard output.  (To suppress
standard error, you can write to the Eshell virtual target
@file{/dev/null\}.)
@end deffn

@cindex batch scripts
@defun eshell-batch-file
This function lets you make an Eshell script file executable from
outside of Emacs by adding it to the script's interpreter directive like
this:

@example
#!/usr/bin/env -S emacs --batch -f eshell-batch-file
@end example

As with other ways of invoking Eshell scripts, you can pass extra
arguments to the script on the command line.
@end defun

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

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 this as the Eshell prompt:
@kbd{eshell-parse-command 'echo hello'}}

@menu
* Invocation::
* Arguments::
* Built-ins::
* Variables::
* Aliases::
* Remote Access::
* Control Flow::
@end menu

@node Invocation
@section Invocation
Eshell is both a command shell and an Emacs Lisp @acronym{REPL}.  As a
result, you can invoke commands in two different ways: in @dfn{command
form} or in @dfn{Lisp form}.

You can use the semicolon (@code{;}) to separate multiple command
invocations on a single line, executing each in turn.  You can also
separate commands with @code{&&} or @code{||}.  When using @code{&&},
Eshell will execute the second command only if the first succeeds
(i.e.@: has an exit status of 0); with @code{||}, Eshell will execute
the second command only if the first fails.

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.

If a command exits abnormally, Eshell will display its exit code
in the next prompt.

@subsection Command form
Command form looks much the same as in other shells.  A command
consists of arguments separated by spaces; the first argument is the
command to run, with any subsequent arguments being passed to that
command.

@example
~ $ echo hello
hello
@end example

@cindex order of looking for commands
@cindex command lookup order
The command can be either an Elisp function or an external command.
Eshell looks for the command in the following order:

@enumerate
@item
As a command alias (@pxref{Aliases})

@item
As a built-in command (@pxref{Built-ins})

@item
As an external program

@item
As an ordinary Lisp function
@end enumerate

@vindex eshell-prefer-lisp-functions
If you would prefer to use ordinary Lisp functions over external
programs, set the option @code{eshell-prefer-lisp-functions} to
@code{t}.  This will swap the lookup order of the last two items.  You
can also force Eshell to look for a command as an external program by
prefixing its name with @kbd{*}, like @code{*@var{command}}
(@pxref{Built-ins}).

You can also group command forms together into a subcommand with curly
braces (@code{@{@}}).  This lets you use the output of a subcommand as
an argument to another command, or within control flow statements
(@pxref{Control Flow}).

@example
~ $ echo @{echo hello; echo there@}
hellothere
@end example

@subsection Lisp form
Lisp form looks like ordinary Emacs Lisp code, because that's what it
is.  As a result, you can use any syntax normally available to an
Emacs Lisp program (@pxref{Top, , , elisp, The Emacs Lisp Reference
Manual}).

@example
~ $ (format "hello, %s" user-login-name)
hello, user
@end example

In addition, you can @emph{combine} command forms and Lisp forms
together into single statements, letting you use whatever form is the
most convenient for expressing your intentions.

@example
~ $ ls *.patch > (format-time-string "%F.log")
@end example

This command writes a list of all files matching the glob pattern
@code{*.patch} (@pxref{Globbing}) to a file named
@code{@var{current-date}.log} (@pxref{Redirection}).

@node Arguments
@section Arguments
When calling external commands (and many built-in Eshell commands,
too) Eshell will flatten the arguments the command receives, so
passing a list as an argument will ``spread'' the elements into
multiple arguments:

@example
~ $ printnl (list 1 2) 3
1
2
3
@end example

@subsection Quoting and Escaping
As with other shells, you can escape special characters and spaces by
prefixing the character with a backslash (@samp{\}), or by surrounding
the string with apostrophes (@samp{''}) or double quotes (@samp{""}).
This is needed especially for file names with special characters like
pipe (@samp{|}) or square brackets (@samp{[} or @samp{]}), which could
be part of remote file names.  In addition, quoting or escaping an
argument will prevent it from being converted to a number when passed to
a Lisp function.

When you escape a character with @samp{\} outside of any quotes, the
result is the literal character immediately following it.  For
example, @code{\$10} means the literal string @code{$10}.

Inside of double quotes, most characters have no special meaning.
However, @samp{\}, @samp{"}, and @samp{$} are still special; to escape
them, use backslash as above.  Thus, if the value of the variable
@var{answer} is @code{42}, then @code{"The answer is: \"$@var{answer}\""}
returns the string @code{The answer is: "42"}.  However, when escaping
characters with no special meaning, the result is the full
@code{\@var{c}} sequence.  For example, @code{"foo\bar"} means the
literal string @code{foo\bar}.

Additionally, when escaping a newline, the whole escape sequence is
removed by the parser.  This lets you continue commands across
multiple lines:

@example
~ $ echo "foo\
bar"
foobar
@end example

Inside apostrophes, escaping works differently.  All characters
between the apostrophes have their literal meaning except @samp{'},
which ends the quoted string.  To insert a literal apostrophe, you can
use @samp{''}, so @code{'It''s me'} means the literal string
@code{It's me}.

When using expansions (@pxref{Expansion}) in an Eshell command, the
result may potentially be of any data type.  To ensure that the result
is always a string, the expansion can be surrounded by double quotes.

@subsection Type Conversion
When invoking a Lisp function via command form, Eshell automatically
converts string arguments that look like numbers to actual Lisp
numbers in order to make it easier to work with numeric values.  You can
prevent this conversion on a case-by-case basis by quoting or escaping
the argument:

@example
~ $ type-of 1
integer
~ $ type-of "1"
string
@end example

When invoking a subcommand in command form, Eshell will split the output
line-by-line into a list.  Additionally, if every line looks like a
number, then Eshell will mark them as numeric so that passing them to a
Lisp function will convert them to Lisp numbers:

@example
~ $ cat numbers.txt
01
02
03
~ $ + $@@@{cat numbers.txt@}
6
@end example

If you find this behavior inconvenient for certain functions, you can
tell Eshell not to perform this conversion for that function:

@example
(put \\='find-file \\='eshell-no-numeric-conversions t)
@end example

@vindex eshell-convert-numeric-arguments
You can also disable this conversion behavior entirely by setting
@code{eshell-convert-numeric-arguments} to @code{nil}.

@subsection Special Argument Types
In addition to strings and numbers, Eshell supports a number of
special argument types.  These let you refer to various other Emacs
Lisp data types, such as lists or buffers.

@table @code

@item #'@var{lisp-form}
This refers to the quoted Emacs Lisp form @var{lisp-form}.  Though
this looks similar to the ``sharp quote'' syntax for functions
(@pxref{Special Read Syntax, , , elisp, The Emacs Lisp Reference
Manual}), it instead corresponds to @code{quote} and can be used for
any quoted form.@footnote{Eshell would interpret a bare apostrophe
(@code{'}) as the start of a single-quoted string.}

@item `@var{lisp-form}
This refers to the backquoted Emacs Lisp form @var{lisp-form}
(@pxref{Backquote, , , elisp, The Emacs Lisp Reference Manual}).  As
in Emacs Lisp, you can use @samp{,} and @samp{,@@} to refer to
non-constant values.

@item #<buffer @var{name}>
@itemx #<@var{name}>
Return the buffer named @var{name}.  This is equivalent to
@samp{$(get-buffer-create "@var{name}")} (@pxref{Creating Buffers, , ,
elisp, The Emacs Lisp Reference Manual}).

@item #<marker @var{position} @var{buffer-or-name}>
Return a marker at @var{position} in the buffer @var{buffer-or-name}.
@var{buffer-or-name} can either be a string naming a buffer or an
actual buffer object.  This is roughly equivalent to creating a new
marker and calling @samp{$(set-marker marker @var{position}
@var{buffer-or-name})} (@pxref{Moving Markers, , , elisp, The Emacs
Lisp Reference Manual}).

@item #<process @var{name}>
Return the process named @var{name}.  This is equivalent to
@samp{$(get-process "@var{name}")} (@pxref{Process Information, , ,
elisp, The Emacs Lisp Reference Manual}).

@end table

@node Built-ins
@section Built-in Commands
Eshell provides a number of built-in commands, many of them
implementing common command-line utilities, but enhanced for Eshell.
(These built-in commands are just ordinary Lisp functions whose names
begin with @code{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; if the Eshell version of a command
doesn't support a particular option, it will automatically invoke the
external command for you.

Some built-in Eshell commands provide enhanced versions of regular
Emacs Lisp functions.  If you want to call the regular Emacs Lisp
version, you can write your command in Lisp form (@pxref{Invocation}).
To call the regular version in command form, you can use
@code{funcall} or @code{apply}, e.g.@: @samp{funcall #'compile "make all"}
(@pxref{Calling Functions,,, elisp, GNU Emacs Lisp Reference Manual}).

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}).  For example:

@example
@group
~ $ alias ls '*ls $@@*'
~ $ which ls
ls is an alias, defined as "*ls $@@*"
@end group
@group
~ $ alias compile 'apply #''compile $*'
~ $ which compile
ls is an alias, defined as "apply #'compile $*"
@end group
@end example

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.

@vindex eshell-default-target-is-dot
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 @code{eshell-xtra} module.  @xref{Extra built-in
commands}.

@menu
* List of Built-ins::
* Defining New Built-ins::
@end menu

@node List of Built-ins
@subsection List of Built-in Commands

@table @code

@cmindex .
@item . @var{file} [@var{argument}]@dots{}
Source an Eshell script named @var{file} in the current environment,
passing any @var{arguments} to the script (@pxref{Scripts}).  This is
not to be confused with the command @command{source}, which sources a
file in a subshell environment.

@cmindex addpath
@item addpath
@itemx addpath [-b] @var{directory}@dots{}
Adds each specified @var{directory} to the @code{$PATH} environment
variable.  By default, this adds the directories to the end of
@code{$PATH}, in the order they were passed on the command line; by
passing @code{-b} or @code{--begin}, Eshell will instead add the
directories to the beginning.

With no directories, print the list of directories currently stored in
@code{$PATH}.

@cmindex alias
@item alias
@itemx alias @var{name} [@var{command}]
Define an alias named @var{name} and expanding to @var{command},
adding it to the aliases file (@pxref{Aliases}).  If @var{command} is
omitted, delete the alias named @var{name}.  With no arguments at all,
list all the currently-defined aliases.

@cmindex basename
@item basename @var{filename}
Return @var{filename} without its directory.

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

@cmindex cd
@cindex directories, changing
@item cd
@itemx cd @var{directory}
@itemx cd -[@var{n}]
@itemx cd =[@var{regexp}]
Change the current working directory.  This command can take several
forms:

@table @code

@item cd
Change to the user's home directory.

@item cd @var{directory}
Change to the specified @var{directory}.

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

@item cd -@var{n}
Change to the directory in the @var{nth} slot of the directory stack.

@item cd =
Show the directory ring.  Each line is numbered.

@item cd =@var{regexp}
Search the directory ring for a directory matching the regular
expression @var{regexp} and change to that directory.

@end table

@vindex eshell-cd-shows-directory
@vindex eshell-list-files-after-cd
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.

@cmindex clear
@item clear [@var{scrollback}]
Scrolls the contents of the Eshell window out of sight, leaving a
blank window.  If @var{scrollback} is non-@code{nil}, the scrollback
contents are cleared instead, as with @command{clear-scrollback}.

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

@cmindex compile
@item compile [-p | -i] [-m @var{mode-name}] @var{command}@dots{}
Run an external command, sending its output to a compilation buffer if
the command would output to the screen and is not part of a pipeline
or subcommand.

With the @code{-p} or @code{--plain} options, always send the output
to the Eshell buffer; similarly, with @code{-i} or
@code{--interactive}, always send the output to a compilation buffer.
You can also set the mode of the compilation buffer with @code{-m
@var{mode-name}} or @code{--mode @var{mode-name}}.

@command{compile} is particularly useful when defining aliases, so
that interactively, the output shows up in a compilation buffer, but
you can still pipe the output elsewhere if desired.  For example, if
you have a grep-like command on your system, you might define an alias
for it like so: @samp{alias mygrep 'compile --mode=grep-mode -- mygrep
$*'}.

@cmindex cp
@item cp [@var{option}@dots{}] @var{source} @var{dest}
@item cp [@var{option}@dots{}] @var{source}@dots{} @var{directory}
Copy the file @var{source} to @var{dest} or @var{source} into
@var{directory}.

@vindex eshell-cp-overwrite-files
@vindex eshell-cp-interactive-query
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.

@command{cp} accepts the following options:

@table @asis

@item @code{-a}, @code{--archive}
Equivalent to @code{--no-dereference --preserve --recursive}.

@item @code{-d}, @code{--no-dereference}
Don't dereference symbolic links when copying; instead, copy the link
itself.

@item @code{-f}, @code{--force}
Never prompt for confirmation before copying a file.

@item @code{-i}, @code{--interactive}
Prompt for confirmation before copying a file if the target already
exists.

@item @code{-n}, @code{--preview}
Run the command, but don't copy anything.  This is useful if you
want to preview what would be removed when calling @command{cp}.

@item @code{-p}, @code{--preserve}
Attempt to preserve file attributes when copying.

@item @code{-r}, @code{-R}, @code{--recursive}
Copy any specified directories and their contents recursively.

@item @code{-v}, @code{--verbose}
Print the name of each file before copying it.

@end table

@cmindex date
@item date [@var{specified-time} [@var{zone}]]
Print the current local time as a human-readable string.  This command
is an alias to the Emacs Lisp function @code{current-time-string}
(@pxref{Time of Day,,, elisp, GNU Emacs Lisp Reference Manual}).

@cmindex diff
@item diff [@var{option}]@dots{} @var{old} @var{new}
Compare the files @var{old} and @var{new} using Emacs's internal
@code{diff} (not to be confused with @code{ediff}).  @xref{Comparing
Files, , , emacs, The GNU Emacs Manual}.

@vindex eshell-plain-diff-behavior
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 $@@*'}.

@cmindex dirname
@item dirname @var{filename}
Return the directory component of @var{filename}.

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

@cmindex du
@item du [@var{option}]@dots{} @var{file}@dots{}
Summarize disk usage for each file, recursing into directories.

@command{du} accepts the following options:

@table @asis

@item @code{-a}, @code{--all}
Print sizes for files, not just directories.

@item @code{--block-size=@var{size}}
Print sizes as number of blocks of size @var{size}.

@item @code{-b}, @code{--bytes}
Print file sizes in bytes.

@item @code{-c}, @code{--total}
Print a grand total of the sizes at the end.

@item @code{-d}, @code{--max-depth=@var{depth}}
Only print sizes for directories (or files with @code{--all}) that are
@var{depth} or fewer levels below the command line arguments.

@item @code{-h}, @code{--human-readable}
Print sizes in human-readable format, with binary prefixes (so 1 KB is
1024 bytes).

@item @code{-H}, @code{--si}
Print sizes in human-readable format, with decimal prefixes (so 1 KB
is 1000 bytes).

@item @code{-k}, @code{--kilobytes}
Print file sizes in kilobytes (like @code{--block-size=1024}).

@item @code{-L}, @code{--dereference}
Follow symbolic links when traversing files.

@item @code{-m}, @code{--megabytes}
Print file sizes in megabytes (like @code{--block-size=1048576}).

@item @code{-s}, @code{--summarize}
Don't recurse into subdirectories (like @code{--max-depth=0}).

@item @code{-x}, @code{--one-file-system}
Skip any directories that reside on different filesystems.

@end table

@cmindex echo
@item echo [-n | -N] [@var{arg}]@dots{}
Prints the value of each @var{arg}.  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.

@vindex eshell-plain-echo-behavior
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.

You can control whether @command{echo} outputs a trailing newline
using @code{-n} to disable the trailing newline (the default behavior)
or @code{-N} to enable it (the default when
@code{eshell-plain-echo-behavior} is non-@code{nil}).

@cmindex env
@item env [@var{var}=@var{value}]@dots{} [@var{command}]@dots{}
With no arguments, print the current environment variables.  If you
pass arguments to this command, then @command{env} will execute the
arguments as a command.  If you pass any initial arguments of the form
@samp{@var{var}=@var{value}}, @command{env} will first set @var{var}
to @var{value} before running the command.

@cmindex eshell-debug
@item eshell-debug [error | form | process]@dots{}
Toggle debugging information for Eshell itself.  You can pass this
command one or more of the following arguments:

@itemize @bullet

@item
@code{error}, to enable/disable Eshell trapping errors when
evaluating commands;

@item
@code{form}, to show/hide Eshell command form manipulation in the
buffer @code{*eshell last cmd*}; or

@item
@code{process}, to show/hide external process events in the buffer
@code{*eshell last cmd*}.

@end itemize

@cmindex exit
@item exit
@vindex eshell-kill-on-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.

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

@cmindex funcall
@item funcall @var{function} [@var{arg}]@dots{}
Call @var{function} with the specified arguments (@var{function} may be
a symbol or a string naming a Lisp function).  This command is useful
when you want to call an ordinary Lisp function using Eshell's command
form (@pxref{Invocation}), even if there may be an external program of
the same name.

@cmindex grep
@item grep [@var{arg}]@dots{}
@cmindex agrep
@itemx agrep [@var{arg}]@dots{}
@cmindex egrep
@itemx egrep [@var{arg}]@dots{}
@cmindex fgrep
@itemx fgrep [@var{arg}]@dots{}
@cmindex rgrep
@itemx rgrep [@var{arg}]@dots{}
@cmindex glimpse
@itemx glimpse [@var{arg}]@dots{}
The @command{grep} commands are compatible with GNU @command{grep},
but open a compilation buffer in @code{grep-mode} instead.
@xref{Grep Searching, , , emacs, The GNU Emacs Manual}.

@vindex eshell-plain-grep-behavior
If @code{eshell-plain-grep-behavior} is non-@code{nil}, then these
commands do not use open a compilation buffer, instead printing output
to Eshell's buffer.  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.

@cmindex history
@item history [@var{n}]
@itemx history [-arw] [@var{filename}]
Prints Eshell's input history.  With a numeric argument @var{n}, this
command prints the @var{n} most recent items in the history.
Alternately, you can specify the following options:

@table @asis

@item @code{-a}, @code{--append}
Append new history items to the history file.

@item @code{-r}, @code{--read}
Read history items from the history file and append them to the
current shell's history.

@item @code{-w}, @code{--write}
Write the current history list to the history file.

@end table

@cmindex info
@item info [@var{manual} [@var{item}]@dots{}]
Browse the available Info documentation.  With no arguments, browse
the top-level menu.  Otherwise, show the manual for @var{manual},
selecting the menu entry for @var{item}.

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

@cmindex jobs
@cindex processes, listing
@item jobs
List subprocesses of the Emacs process, if any, using the function
@code{list-processes}.

@cmindex kill
@cindex processes, signaling
@item kill [-@var{signal}] [@var{pid} | @var{process}]
Kill processes.  Takes a PID or a process object and an optional
@var{signal} specifier which can either be a number or a signal name.

@cmindex listify
@item listify [@var{arg}]@dots{}
Return the arguments as a single list.  With a single argument, return
it as-is if it's already a list, or otherwise wrap it in a list.  With
multiple arguments, return a list of all of them.

@cmindex ln
@item ln [@var{option}]@dots{} @var{target} [@var{link-name}]
@itemx ln [@var{option}]@dots{} @var{target}@dots{} @var{directory}
Create a link to the specified @var{target} named @var{link-name} or
create links to multiple @var{targets} in @var{directory}.

@vindex eshell-ln-overwrite-files
@vindex eshell-ln-interactive-query
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.

@command{ln} accepts the following options:

@table @asis

@item @code{-f}, @code{--force}
Never prompt for confirmation before linking a target.

@item @code{-i}, @code{--interactive}
Prompt for confirmation before linking to an item if the source
already exists.

@item @code{-n}, @code{--preview}
Run the command, but don't move anything.  This is useful if you
want to preview what would be linked when calling @command{ln}.

@item @code{-s}, @code{--symbolic}
Make symbolic links instead of hard links.

@item @code{-v}, @code{--verbose}
Print the name of each file before linking it.

@end table

@cmindex locate
@item locate @var{arg}@dots{}
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}.

@vindex eshell-plain-locate-behavior
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 $@@*'}.

@cmindex ls
@item ls [@var{option}]@dots{} [@var{file}]@dots{}
List information about each @var{file}, including the contents of any
specified directories.  If @var{file} is unspecified, list the
contents of the current directory.

@vindex eshell-ls-initial-args
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.

@vindex eshell-ls-use-colors
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}}}.

@command{ls} supports the following options:

@table @asis

@item @code{-a}, @code{--all}
List all files, including ones starting with @samp{.}.

@item @code{-A}, @code{--almost-all}
Like @code{--all}, but don't list the current directory (@file{.}) or
the parent directory (@file{..}).

@item @code{-c}, @code{--by-ctime}
Sort files by last status change time, with newest files first.

@item @code{-C}
List entries by columns.

@item @code{-d}, @code{--directory}
List directory entries instead of their contents.

@item @code{-h}, @code{--human-readable}
Print sizes in human-readable format, with binary prefixes (so 1 KB is
1024 bytes).

@item @code{-H}, @code{--si}
Print sizes in human-readable format, with decimal prefixes (so 1 KB
is 1000 bytes).

@item @code{-I@var{pattern}}, @code{--ignore=@var{pattern}}
Don't list directory entries matching @var{pattern}.

@item @code{-k}, @code{--kilobytes}
Print sizes as 1024-byte kilobytes.

@vindex eshell-ls-date-format
@item @code{-l}
Use a long listing format showing details for each file.  The user
option @code{eshell-ls-date-format} determines how the date is
displayed when using this option.  The date is produced using the
function @code{format-time-string} (@pxref{Time Parsing,,, elisp, GNU
Emacs Lisp Reference Manual}).

@item @code{-L}, @code{--dereference}
Follow symbolic links when listing entries.

@item @code{-n}, @code{--numeric-uid-gid}
Show UIDs and GIDs numerically, instead of using their names.

@item @code{-r}, @code{--reverse}
Reverse order when sorting.

@item @code{-R}, @code{--recursive}
List subdirectories recursively.

@item @code{-s}, @code{--size}
Show the size of each file in blocks.

@vindex eshell-ls-default-blocksize
@item @code{-S}
Sort by file size, with largest files first.  The user option
@code{eshell-ls-default-blocksize} determines the default blocksize
used when displaying file sizes with this option.

@item @code{-t}
Sort by modification time, with newest files first.

@item @code{-u}
Sort by last access time, with newest files first.

@item @code{-U}
Do not sort results.  Instead, list entries in their directory order.

@item @code{-x}
List entries by lines instead of by columns.

@item @code{-X}
Sort alphabetically by file extension.

@item @code{-1}
List one file per line.

@end table

@cmindex make
@item make [@var{arg}]@dots{}
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.

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

@cmindex mkdir
@item mkdir [-p] @var{directory}@dots{}
Make new directories.  With @code{-p} or @code{--parents},
automatically make any necessary parent directories as well.

@cmindex mv
@item mv [@var{option}]@dots{} @var{source} @var{dest}
@itemx mv [@var{option}]@dots{} @var{source}@dots{} @var{directory}
Rename the file @var{source} to @var{dest} or move @var{source} into
@var{directory}.

@vindex eshell-mv-overwrite-files
@vindex eshell-mv-interactive-query
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.

@command{mv} accepts the following options:

@table @asis

@item @code{-f}, @code{--force}
Never prompt for confirmation before moving an item.

@item @code{-i}, @code{--interactive}
Prompt for confirmation before moving an item if the target already
exists.

@item @code{-n}, @code{--preview}
Run the command, but don't move anything.  This is useful if you
want to preview what would be moved when calling @command{mv}.

@item @code{-v}, @code{--verbose}
Print the name of each item before moving it.

@end table

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

@cmindex popd
@cindex directory stack, removing from
@item popd
@item popd +@var{n}
Pop a directory from the directory stack and switch to a another place
in the stack.  This command can take the following forms:

@table @code

@item popd
Remove the current directory from the directory stack and change to
the directory beneath it.

@item popd +@var{n}
Remove the current directory from the directory stack and change to
the @var{nth} directory in the stack (counting from zero).

@end table

@cmindex printnl
@item printnl [@var{arg}]@dots{}
Print all the @var{arg}s separated by newlines.

@cmindex pushd
@cindex directory stack, adding to
@item pushd
@itemx pushd @var{directory}
@itemx pushd +@var{n}
Push the current directory onto the directory stack, then change to
another directory.  This command can take the following forms:

@table @code

@vindex eshell-pushd-tohome
@item pushd
Swap the current directory with the directory on the top of the stack.
If @code{eshell-pushd-tohome} is non-@code{nil}, push the current
directory onto the stack and change to the user's home directory (like
@samp{pushd ~}).

@vindex eshell-pushd-dunique
@item pushd @var{directory}
Push the current directory onto the stack and change to
@var{directory}.  If @code{eshell-pushd-dunique} is non-@code{nil},
then only unique directories will be added to the stack.

@vindex eshell-pushd-dextract
@item pushd +@var{n}
Change to the @var{nth} directory in the directory stack (counting
from zero), and ``rotate'' the stack by moving any elements before the
@var{nth} to the bottom.  If @code{eshell-pushd-dextract} is
non-@code{nil}, then @samp{pushd +@var{n}} will instead pop the
@var{n}th directory to the top of the stack.

@end table

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

@cmindex rm
@item rm [@var{option}]@dots{} @var{item}@dots{}
Removes files, buffers, processes, or Emacs Lisp symbols, depending on
the type of each @var{item}.

@vindex eshell-rm-interactive-query
@vindex eshell-rm-removes-directories
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.

@command{rm} accepts the following options:

@table @asis

@item @code{-f}, @code{--force}
Never prompt for confirmation before removing an item.

@item @code{-i}, @code{--interactive}
Prompt for confirmation before removing each item.

@item @code{-n}, @code{--preview}
Run the command, but don't remove anything.  This is useful if you
want to preview what would be removed when calling @command{rm}.

@item @code{-r}, @code{-R}, @code{--recursive}
Remove any specified directories and their contents recursively.

@item @code{-v}, @code{--verbose}
Print the name of each item before removing it.

@end table

@cmindex rmdir
@item rmdir @var{directory}@dots{}
Removes directories if they are empty.

@cmindex set
@item set [@var{var} @var{value}]@dots{}
Set variable values, using the function @code{set} like a command
(@pxref{Setting Variables,,, elisp, GNU Emacs Lisp Reference Manual}).
The value of @var{var} can be a symbol, in which case it refers to a
Lisp variable, or a string, referring to an environment variable
(@pxref{Arguments}).

@cmindex setq
@item setq [@var{symbol} @var{value}]@dots{}
Set variable values, using the function @code{setq} like a command
(@pxref{Setting Variables,,, elisp, GNU Emacs Lisp Reference Manual}).

@cmindex source
@item source @var{file} [@var{argument}]@dots{}
Source an Eshell script named @var{file} in a subshell environment,
passing any @var{argument}s to the script (@pxref{Scripts}).  This is
not to be confused with the command @command{.}, which sources a file
in the current environment.

@cmindex time
@item time @var{command}@dots{}
Show the time elapsed during the execution of @var{command}.

@cmindex umask
@item umask [-S]
@itemx umask @var{mode}
View the default file permissions for newly created files and
directories.  If you pass @code{-S} or @code{--symbolic}, view the
mode symbolically.  With @var{mode}, set the default permissions to
this value.

@cmindex unset
@item unset [@var{var}]@dots{}
Unset one or more variables.  As with @command{set}, the value of
@var{var} can be a symbol, in which case it refers to a Lisp variable,
or a string, referring to an environment variable.

@cmindex wait
@cindex processes, waiting for
@item wait [-t @var{timeout}] [@var{process}]@dots{}
Wait until each specified @var{process} has exited.  Processes can
either be process objects (@pxref{Processes, , , elisp, GNU Emacs Lisp
Reference Manual}) or integer PIDs.  If you pass @code{-t} or
@code{--timeout}, wait at most that many seconds before exiting.

@cmindex which
@item which @var{command}@dots{}
For each @var{command}, identify what kind of command it is and its
location.

@cmindex whoami
@item whoami
Print the current user.  This Eshell version of @command{whoami} is
connection-aware, so for remote directories, it will print the user
associated with that connection.
@end table

@node Defining New Built-ins
@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-@code{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-@code{nil}.

@item long
This element, if non-@code{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

@node Variables
@section Variables
@vindex eshell-prefer-lisp-variables
Since Eshell is a combination of an Emacs @acronym{REPL} and a command
shell, it can refer to variables from two different sources: ordinary
Emacs Lisp variables, as well as environment variables.  By default,
when using a variable in Eshell, it will first look in the list of
built-in variables, then in the list of environment variables, and
finally in the list of Lisp variables.  If you would prefer to use
Lisp variables over environment variables, you can set
@code{eshell-prefer-lisp-variables} to @code{t}.

You can set variables in a few different ways.  To set a Lisp
variable, you can use the command @samp{setq @var{name} @var{value}},
which works much like its Lisp counterpart (@pxref{Setting Variables,
, , elisp, The Emacs Lisp Reference Manual}).  To set an environment
variable, use @samp{export @var{name}=@var{value}}.  You can also use
@samp{set @var{variable} @var{value}}, which sets a Lisp variable if
@var{variable} is a symbol, or an environment variable if it's a
string (@pxref{Arguments}).  Finally, you can temporarily set
environment variables for a single command with
@samp{@var{name}=@var{value} @var{command} @dots{}}.  This is
equivalent to:

@example
@{
  export @var{name}=@var{value}
  @var{command} @dots{}
@}
@end example

@subsection Built-in variables
Eshell knows a few built-in variables:

@table @code

@vindex $PWD
@vindex $+
@item $PWD
@itemx $+
This variable always contains the current working directory.

@vindex $OLDPWD
@vindex $-
@item $OLDPWD
@itemx $-
This variable always contains the previous working directory (the
current working directory from before the last @code{cd} command).
When using @code{$-}, you can also access older directories in the
directory ring via subscripting, e.g.@: @samp{$-[1]} refers to the
working directory @emph{before} the previous one.

@vindex $PATH
@item $PATH
This specifies the directories to search for executable programs.  Its
value is a string, separated by @code{":"} for Unix and GNU systems,
and @code{";"} for MS systems.  This variable is connection-aware, so
whenever you change the current directory to a different host
(@pxref{Remote Files, , , emacs, The GNU Emacs Manual}),
the value will automatically update to reflect the search path on that
host.

@vindex $UID
@item $UID
This returns the effective @acronym{UID} for the current user.  This
variable is connection-aware, so when the current directory is remote,
its value will be @acronym{UID} for the user associated with that
remote connection.

@vindex $GID
@item $GID
This returns the effective @acronym{GID} for the current user.  Like
@code{$UID}, this variable is connection-aware, so when the current
directory is remote, its value will be @acronym{GID} for the user
associated with that remote connection.

@vindex $_
@item $_
This refers to the last argument of the last command.  With a
subscript, you can access any argument of the last command.  For
example, @samp{$_[1]} refers to the second argument of the last
command (excluding the command name itself).  To get all arguments of
the last command, you can use an index range like @samp{$_[..]}
(@pxref{Dollars Expansion}).

@vindex $$
@item $$
This is the result of the last command.  For external commands, it is
@code{t} if the exit code was 0 or @code{nil} otherwise.

@vindex eshell-lisp-form-nil-is-failure
@vindex $?
@item $?
This variable contains the exit code of the last command.  If the last
command was a Lisp function, it is 0 for successful completion or 1
otherwise.  If @code{eshell-lisp-form-nil-is-failure} is
non-@code{nil}, then a command with a Lisp form, like
@samp{(@var{command} @var{args}@dots{})}, that returns @code{nil} will
set this variable to 2.

@vindex $COLUMNS
@vindex $LINES
@item $COLUMNS
@itemx $LINES
These variables tell the number of columns and lines, respectively,
that are currently visible in the Eshell window.  They are both
copied to the environment, so external commands invoked from
Eshell can consult them to do the right thing.

@vindex $INSIDE_EMACS
@item $INSIDE_EMACS
This variable indicates to external commands that they are being
invoked from within Emacs so they can adjust their behavior if
necessary.  By default, its value is
@code{@var{emacs-version},eshell}.  Other parts of Emacs, such as
Tramp, may add extra information to this value.

@vindex $PAGER
@item $PAGER
This variable indicates the pager that commands should use when they
wish to paginate long output.  Its value is that of
@code{comint-pager} if non-@code{nil}; otherwise, it uses the value of
@code{$PAGER} from the @code{process-environment}.

@end table

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

@node Aliases
@section Aliases

@findex eshell-read-aliases-list
@vindex eshell-aliases-file
Aliases are commands that expand to a longer input line.  For example,
@command{ll} is a common alias for @code{ls -l}.  To define this alias
in Eshell, you can use 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.  After
doing so, use @w{@kbd{M-x eshell-read-aliases-list}} to load the
edited aliases.

Note that unlike aliases in Bash, arguments must be handled
explicitly.  Within aliases, you can use the special variables
@samp{$*}, @samp{$0}, @samp{$1}, @samp{$2}, etc. to refer to the
arguments passed to the alias.

@table @code

@vindex $*
@item $*
This expands to the list of arguments passed to the alias.  For
example, if you run @code{my-alias 1 2 3}, then @samp{$*} would be the
list @code{(1 2 3)}.  Note that since this variable is a list, using
@samp{$*} in an alias will pass this list as a single argument to the
aliased command.  Therefore, when defining an alias, you should
usually use @samp{$@@*} to pass all arguments along, splicing them
into your argument list (@pxref{Dollars Expansion}).

@vindex $0
@item $0
This expands to the name of the alias currently being executed.

@vindex $1, $2, @dots{}, $9
@item $1, $2, @dots{}, $9
These variables expand to the nth argument (starting at 1) passed to
the alias.  This lets you selectively use an alias's arguments, so
@kbd{alias mcd 'mkdir $1 && cd $1'} would cause @kbd{mcd foo} to
create and switch to a directory called @samp{foo}.

@end table

@node Remote Access
@section Remote Access
@cindex remote access

Since Eshell uses Emacs facilities for most of its functionality, you
can access remote hosts transparently.  To connect to a remote host,
simply @code{cd} into it:

@example
~ $ cd /ssh:user@@remote:
/ssh:user@@remote:~ $
@end example

Additionally, built-in Eshell commands (@pxref{Built-ins}) and
ordinary Lisp functions accept remote file names, so you can access
them even without explicitly connecting first.  For example, to print
the contents of a remote file, you could type @samp{cat
/ssh:user@@remote:~/output.log}.  However, this means that when using
built-in commands or Lisp functions from a remote directory, you must
be careful about specifying absolute file names: @samp{cat
/var/output.log} will always print the contents of your @emph{local}
@file{/var/output.log}, even from a remote directory.  If you find
this behavior annoying, you can enable the optional electric forward
slash module (@pxref{Electric forward slash}).

@vindex eshell-explicit-remote-commands
When running commands, you can also make them explicitly remote by
prefixing the command name with a remote identifier, e.g.@:
@samp{/ssh:user@@remote:whoami}.  This runs the command @code{whoami}
over the SSH connection for @code{user@@remote}, no matter your current
directory.  If you want to explicitly run a command on your @emph{local}
machine even when in a remote directory, you can prefix the command name
with @kbd{/local:}, like @samp{/local:whoami}.  In either case, you can
also specify the absolute path to the program, e.g.@:
@samp{/ssh:user@@remote:/usr/bin/whoami}.  If you need to refer to a
program whose file name would be interpreted as an explicitly-remote
command, you can use @kbd{/:} to quote the name, e.g.@:
@samp{/:/ssh:user@@remote:whoami} (@pxref{Quoted File Names,,, emacs,
The GNU Emacs Manual}).  To disable explicitly-remote commands entirely,
you can set the option @code{eshell-explicit-remote-commands} to
@code{nil}.

@node Control Flow
@section Control Flow
Because Eshell commands can not (easily) be combined with Lisp forms,
Eshell provides command-oriented control flow statements for
convenience.

Most of Eshell's control flow statements accept a @var{conditional}.
This can take a few different forms.  If @var{conditional} is a dollar
expansion, the condition is satisfied if the result is a non-@code{nil}
value.  Alternately, @var{conditional} may be a subcommand, either in
command form, e.g.@: @samp{@{@var{subcommand}@}}; or in Lisp form,
e.g.@: @samp{(@var{lisp form})}.  In that case, the condition is
satisfied if the subcommand's exit status is 0.

@table @code

@item if @var{conditional} @var{true-subcommand}
@itemx if @var{conditional} @var{true-subcommand} else @var{false-subcommand}
Evaluate @var{true-subcommand} if @var{conditional} is satisfied;
otherwise, evaluate @var{false-subcommand}.  Both @var{true-subcommand}
and @var{false-subcommand} should be subcommands, as with
@var{conditional}.

You can also chain together @code{if}/@code{else} forms, for example:

@example
if @{[ -f file.txt ]@} @{
  echo found file
@} else if @{[ -f alternate.txt ]@} @{
  echo found alternate
@} else @{
  echo not found!
@}
@end example

@item unless @var{conditional} @var{false-subcommand}
@itemx unless @var{conditional} @var{false-subcommand} else @var{true-subcommand}
Evaluate @var{false-subcommand} if @var{conditional} is not satisfied;
otherwise, evaluate @var{true-subcommand}.  Like above, you can also
chain together @code{unless}/@code{else} forms.

@item while @var{conditional} @var{subcommand}
Repeatedly evaluate @var{subcommand} so long as @var{conditional} is
satisfied.

@item until @var{conditional} @var{subcommand}
Repeatedly evaluate @var{subcommand} until @var{conditional} is
satisfied.

@item for @var{var} in @var{list}@dots{} @var{subcommand}
Iterate over each element of @var{list}, storing the element in
@var{var} and evaluating @var{subcommand}.  If @var{list} is not a list,
treat it as a list of one element.  If you specify multiple @var{lists},
this will iterate over each of them in turn.

@end table

@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{var}} on
a line expands to the value of the variable @var{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{var}} at
the prompt is equivalent to entering the value of @var{var} at the
prompt.}

You can concatenate expansions with regular string arguments or even
other expansions.  In the simplest case, when the expansion returns a
string value, this is equivalent to ordinary string concatenation; for
example, @samp{$@{echo "foo"@}bar} returns @samp{foobar}.  The exact
behavior depends on the types of each value being concatenated:

@table @asis

@item both strings
Concatenate both values together.

@item one or both numbers
Concatenate the string representation of each value.  If either value is
numeric, mark the concatenated value as numeric if possible.

@item one or both (non-@code{nil}) lists
Concatenate ``adjacent'' elements of each value (possibly converting
back to a number as above).  For example, @samp{$(list "a" "b")c}
returns @samp{("a" "bc")}.

@item anything else
Concatenate the string representation of each value.

@end table

@menu
* Dollars Expansion::
* Globbing::
* Argument Predication and Modification::
@end menu

@node Dollars Expansion
@section Dollars Expansion
Like in many other shells, you can use @code{$} expansions to insert
various values into your Eshell invocations.  While Eshell's @code{$}
expansion syntax has some similarities to the syntax from other
shells, there are also many differences.  Don't let these similarities
lull you into a false sense of familiarity.

When using command form (@pxref{Invocation}), Eshell will ignore any
leading @code{nil} values, so if @var{foo} is @code{nil},
@samp{$@var{foo} echo hello} is equivalent to @samp{echo hello}.

@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 inside double quotes or within a longer 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.  Similar
to @code{$(@var{lisp})}, this is identical to @code{@{@var{command}@}}
when on its own, but the @code{$} allows it to be used inside double
quotes or as part of a string.

@vindex eshell-convert-numeric-arguments
Normally, the output is split line-by-line, returning a list (or the
first element if there's only one line of output); if
@code{eshell-convert-numeric-arguments} is non-@code{nil} and every
line of output looks like a number, convert each line to a number.
However, when this expansion is surrounded by double quotes, it
returns the output as a single string instead.

@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@dots{}}]
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, , , elisp, The Emacs Lisp
Reference Manual}).  If @var{i} is negative, @var{i} counts from the
end, so -1 refers to the last element of the sequence.

If @var{i} is a range like @code{@var{start}..@var{end}}, this expands
to a subsequence from the indices @var{start} to @var{end}, where
@var{end} is excluded@footnote{This behavior is different from ranges
in Bash (where both the start and end are included in the range), but
matches the behavior of similar Emacs Lisp functions, like
@code{substring} (@pxref{Creating Strings, , , elisp, The Emacs Lisp
Reference Manual}).}.  @var{start} and/or @var{end} can also be
omitted, which is equivalent to the start and/or end of the entire
list.  For example, @samp{$@var{expr}[-2..]} expands to the last two
values of @var{expr}.

@item a string
Split the string at whitespace, and then expand to the @var{i}th
element of the resulting sequence.  As above, @var{i} can be a range
like @code{@var{start}..@var{end}}.

@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@dots{}}]
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.

@cindex length operator, in variable expansion
@item $#@var{expr}
This is the @dfn{length operator}.  It 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.

@cindex splice operator, in variable expansion
@item $@@@var{expr}
This is the @dfn{splice operator}.  It ``splices'' the elements of
@var{expr} (an expression of one of the above forms) into the
resulting list of arguments, much like the @samp{,@@} marker in Emacs
Lisp (@pxref{Backquote, , , elisp, The Emacs Lisp Reference Manual}).
The elements of @var{expr} become arguments at the same level as the
other arguments around it.  For example, if @var{numbers} is the list
@code{(1 2 3)}, then:

@example
@group
~ $ echo 0 $numbers
(0
 (1 2 3))
@end group
@group
~ $ echo 0 $@@numbers
(0 1 2 3)
@end group
@end example

@end table

@node Globbing
@section Globbing
Eshell's globbing syntax is very similar to that of Zsh
(@pxref{Filename Generation, , , zsh, The Z Shell Manual}).  Users
coming from Bash can still use Bash-style globbing, as there are no
incompatibilities.

@vindex eshell-glob-case-insensitive
Globs are case sensitive by default, except on MS-DOS/MS-Windows
systems.  You can control this behavior via the
@code{eshell-glob-case-insensitive} option.

@vindex eshell-glob-splice-results
By default, Eshell expands the results of a glob as a sublist into the
list of arguments.  You can change this to splice the results in-place
by setting @code{eshell-glob-splice-results} to a non-@code{nil}
value.  If you want to splice a glob in-place for just one use, you
can use a subcommand form like @samp{$@@@{listify @var{my-glob}@}}.
(Conversely, you can explicitly expand a glob as a sublist via
@samp{$@{listify @var{my-glob}@}}.)

You can further customize the syntax and behavior of globbing in
Eshell via the Customize group @code{eshell-glob} (@pxref{Easy
Customization, , , emacs, The GNU Emacs Manual}).

@table @samp

@item *
Matches any string (including the empty string).  For example,
@samp{*.el} matches any file with the @file{.el} extension.

@item ?
Matches any single character.  For example, @samp{?at} matches
@file{cat} and @file{bat}, but not @file{goat}.

@item **/
Matches zero or more subdirectories in a file name.  For example,
@samp{**/foo.el} matches @file{foo.el}, @file{bar/foo.el},
@file{bar/baz/foo.el}, etc.  Note that this cannot be combined with
any other patterns in the same file name segment, so while
@samp{foo/**/bar.el} is allowed, @samp{foo**/bar.el} is not.

@item ***/
Like @samp{**/}, but follows symlinks as well.

@cindex character sets, in Eshell glob patterns
@cindex character classes, in Eshell glob patterns
@item [ @dots{} ]
Defines a @dfn{character set} (@pxref{Regexps, , , emacs, The GNU
Emacs Manual}).  A character set matches characters between the two
brackets; for example, @samp{[ad]} matches @file{a} and @file{d}.  You
can also include ranges of characters in the set by separating the
start and end with @samp{-}.  Thus, @samp{[a-z]} matches any
lower-case @acronym{ASCII} letter.  Note that, unlike in Zsh,
character ranges are interpreted in the Unicode codepoint order, not
in the locale-dependent collation order.

Additionally, you can include @dfn{character classes} in a character
set.  A @samp{[:} and balancing @samp{:]} enclose a character class
inside a character set.  For instance, @samp{[[:alnum:]]}
matches any letter or digit.  @xref{Char Classes, , , elisp, The Emacs
Lisp Reference Manual}, for a list of character classes.

@cindex complemented character sets, in Eshell glob patterns
@item [^ @dots{} ]
Defines a @dfn{complemented character set}.  This behaves just like a
character set, but matches any character @emph{except} the ones
specified.

@cindex groups, in Eshell glob patterns
@item ( @dots{} )
Defines a @dfn{group}.  A group matches the pattern between @samp{(}
and @samp{)}.  Note that a group can only match a single file name
component, so a @samp{/} inside a group will signal an error.

@item @var{x}|@var{y}
Inside of a group, matches either @var{x} or @var{y}.  For example,
@samp{e(m|sh)-*} matches any file beginning with @file{em-} or
@file{esh-}.

@item @var{x}#
Matches zero or more copies of the glob pattern @var{x}.  For example,
@samp{fo#.el} matches @file{f.el}, @file{fo.el}, @file{foo.el}, etc.

@item @var{x}##
Matches one or more copies of the glob pattern @var{x}.  Thus,
@samp{fo#.el} matches @file{fo.el}, @file{foo.el}, @file{fooo.el},
etc.

@item @var{x}~@var{y}
Matches anything that matches the pattern @var{x} but not @var{y}.  For
example, @samp{[[:digit:]]#~4?} matches @file{1} and @file{12}, but
not @file{42}.  Note that unlike in Zsh, only a single @samp{~}
operator can be used in a pattern, and it cannot be inside of a group
like @samp{(@var{x}~@var{y})}.

@end table

@node Argument Predication and Modification
@section Argument Predication and Modification
@cindex argument predication
@cindex argument modification
Eshell supports @dfn{argument predication}, to filter elements of a
glob, and @dfn{argument modification}, to manipulate argument values.
These are similar to glob qualifiers in Zsh (@pxref{Glob Qualifiers, ,
, zsh, The Z Shell Manual}).

Predicates and modifiers are introduced with @samp{(@var{filters})}
after any list argument, where @var{filters} is a list of predicates
or modifiers.  For example, @samp{*(.)} expands to all regular files
in the current directory and @samp{*(^@@:U^u0)} expands to all
non-symlinks not owned by @code{root}, upper-cased.

Some predicates and modifiers accept string parameters, such as
@samp{*(u'@var{user}')}, which matches all files owned by @var{user}.
These parameters must be surrounded by delimiters; you can use any of
the following pairs of delimiters: @code{"@dots{}"}, @code{'@dots{}'},
@code{/@dots{}/}, @code{|@dots{}|}, @code{(@dots{})},
@code{[@dots{}]}, @code{<@dots{}>}, or @code{@{@dots{}@}}.

You can customize the syntax and behavior of predicates and modifiers
in Eshell via the Customize group @code{eshell-pred} (@pxref{Easy
Customization, , , emacs, The GNU Emacs Manual}).

@menu
* Argument Predicates::
* Argument Modifiers::
@end menu

@node Argument Predicates
@subsection Argument Predicates
You can use argument predicates to filter lists of file names based on
various properties of those files.  This is most useful when combined
with globbing, but can be used on any list of files names.  Eshell
supports the following argument predicates:

@table @asis

@item @samp{/}
Matches directories.

@item @samp{.} @r{(Period)}
Matches regular files.

@item @samp{@@}
Matches symbolic links.

@item @samp{=}
Matches sockets.

@item @samp{p}
Matches named pipes.

@item @samp{%}
Matches block or character devices.

@item @samp{%b}
Matches block devices.

@item @samp{%c}
Matches character devices.

@item @samp{*}
Matches regular files that can be executed by the current user.

@item @samp{r}
@item @samp{A}
@item @samp{R}
Matches files that are readable by their owners (@samp{r}), their
groups (@samp{A}), or the world (@samp{R}).

@item @samp{w}
@item @samp{I}
@item @samp{W}
Matches files that are writable by their owners (@samp{w}), their
groups (@samp{I}), or the world (@samp{W}).

@item @samp{x}
@item @samp{E}
@item @samp{X}
Matches files that are executable by their owners (@samp{x}), their
groups (@samp{E}), or the world (@samp{X}).

@item @samp{s}
Matches files with the setuid flag set.

@item @samp{S}
Matches files with the setgid flag set.

@item @samp{t}
Matches files with the sticky bit set.

@item @samp{U}
Matches files owned by the current effective user ID.

@item @samp{G}
Matches files owned by the current effective group ID.

@item @samp{l@option{[+-]}@var{n}}
Matches files with @var{n} links.  With @option{+} (or @option{-}),
matches files with more than (or less than) @var{n} links,
respectively.

@item @samp{u@var{uid}}
@item @samp{u'@var{user-name}'}
Matches files owned by user ID @var{uid} or user name @var{user-name}.

@item @samp{g@var{gid}}
@item @samp{g'@var{group-name}'}
Matches files owned by group ID @var{gid} or group name
@var{group-name}.

@item @samp{a@option{[@var{unit}]}@option{[+-]}@var{n}}
@item @samp{a@option{[+-]}'@var{file}'}
Matches files last accessed exactly @var{n} days ago.  With @option{+}
(or @option{-}), matches files accessed more than (or less than)
@var{n} days ago, respectively.

With @var{unit}, @var{n} is a quantity in that unit of time, so
@samp{aw-1} matches files last accessed within one week.  @var{unit}
can be @samp{M} (30-day months), @samp{w} (weeks), @samp{h} (hours),
@samp{m} (minutes), or @samp{s} (seconds).

If @var{file} is specified instead, compare against the modification
time of @file{file}.  Thus, @samp{a-'hello.txt'} matches all files
accessed after @file{hello.txt} was last accessed.

@item @samp{m@option{[@var{unit}]}@option{[+-]}@var{n}}
@item @samp{m@option{[+-]}'@var{file}'}
Like @samp{a}, but examines modification time.

@item @samp{c@option{[@var{unit}]}@option{[+-]}@var{n}}
@item @samp{c@option{[+-]}'@var{file}'}
Like @samp{a}, but examines status change time.

@item @samp{L@option{[@var{unit}]}@option{[+-]}@var{n}}
Matches files exactly @var{n} bytes in size.  With @option{+} (or
@option{-}), matches files larger than (or smaller than) @var{n}
bytes, respectively.

With @var{unit}, @var{n} is a quantity in that unit of size, so
@samp{Lm+5} matches files larger than 5 MiB in size.  @var{unit} can
be one of the following (case-insensitive) characters: @samp{m}
(megabytes), @samp{k} (kilobytes), or @samp{p} (512-byte blocks).

@end table

The @samp{^} and @samp{-} operators are not argument predicates
themselves, but they modify the behavior of all subsequent predicates.
@samp{^} inverts the meaning of subsequent predicates, so
@samp{*(^RWX)} expands to all files whose permissions disallow the
world from accessing them in any way (i.e., reading, writing to, or
modifying them).  When examining a symbolic link, @samp{-} applies the
subsequent predicates to the link's target instead of the link itself.

@node Argument Modifiers
@subsection Argument Modifiers
You can use argument modifiers to manipulate argument values.  For
example, you can sort lists, remove duplicate values, capitalize
words, etc.  All argument modifiers are prefixed by @samp{:}, so
@samp{$exec-path(:h:u:x/^\/home/)} lists all of the unique parent
directories of the elements in @code{exec-path}, excluding those in
@file{/home}.

@table @samp

@item E
Re-evaluates the value as an Eshell argument.  For example, if
@var{foo} is @code{"$@{echo hi@}"}, then the result of @samp{$foo(:E)}
is @code{hi}.

@item L
Converts the value to lower case.

@item U
Converts the value to upper case.

@item C
Capitalizes the value.

@item h
Treating the value as a file name, gets the directory name (the
``head'').  For example, @samp{foo/bar/baz.el(:h)} expands to
@samp{foo/bar/}.

@item t
Treating the value as a file name, gets the base name (the ``tail'').
For example, @samp{foo/bar/baz.el(:t)} expands to @samp{baz.el}.

@item e
Treating the value as a file name, gets the final extension of the
file, excluding the dot.  For example, @samp{foo.tar.gz(:e)}
expands to @code{gz}.

@item r
Treating the value as a file name, gets the file name excluding the
final extension.  For example, @samp{foo/bar/baz.tar.gz(:r)} expands
to @samp{foo/bar/baz.tar}.

@item q
Marks that the value should be interpreted by Eshell literally, so
that any special characters like @samp{$} no longer have any special
meaning.

@item s/@var{pattern}/@var{replace}/
Replaces the first instance of the regular expression @var{pattern}
with @var{replace}.  Signals an error if no match is found.

As with other modifiers taking string parameters, you can use
different delimiters to separate @var{pattern} and @var{replace}, such
as @samp{s'@dots{}'@dots{}'}, @samp{s[@dots{}][@dots{}]}, or even
@samp{s[@dots{}]/@dots{}/}.

@item gs/@var{pattern}/@var{replace}/
Replaces all instances of the regular expression @var{pattern} with
@var{replace}.

@item i/@var{pattern}/
Filters a list of values to include only the elements matching the
regular expression @var{pattern}.

@item x/@var{pattern}/
Filters a list of values to exclude all the elements matching the
regular expression @var{pattern}.

@item S
@item S/@var{pattern}/
Splits the value using the regular expression @var{pattern} as a
delimiter.  If @var{pattern} is omitted, split on spaces.

@item j
@item j/@var{delim}/
Joins a list of values, inserting the string @var{delim} between each
value.  If @var{delim} is omitted, use a single space as the
delimiter.

@item o
Sorts a list of strings in ascending lexicographic order, comparing
pairs of characters according to their character codes (@pxref{Text
Comparison, , , elisp, The Emacs Lisp Reference Manual}).

@item O
Sorts a list of strings in descending lexicographic order.

@item u
Removes any duplicate elements from a list of values.

@item R
Reverses the order of a list of values.

@end table

@node Input/Output
@chapter Input/Output
Since Eshell does not communicate with a terminal like most command
shells, IO is a little different.

@menu
* Visual Commands::
* Redirection::
* Pipelines::
@end menu

@node Visual Commands
@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.

@vindex eshell-visual-commands
@vindex eshell-visual-subcommands
@vindex eshell-visual-options
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}.

@node Redirection
@section Redirection
Redirection in Eshell is similar to that of other command shells.  You
can use the output redirection operators @code{>} and @code{>>}, but
there is not yet any support for input redirection.  In the cases
below, @var{fd} specifies the file descriptor to redirect; if not
specified, file descriptor 1 (standard output) will be used by
default.

@table @code

@item > @var{dest}
@itemx @var{fd}> @var{dest}
Redirect output to @var{dest}, overwriting its contents with the new
output.

@item >> @var{dest}
@itemx @var{fd}>> @var{dest}
Redirect output to @var{dest}, appending it to the existing contents
of @var{dest}.

@item >>> @var{dest}
@itemx @var{fd}>>> @var{dest}
Redirect output to @var{dest}, inserting it at the current mark if
@var{dest} is a buffer, at the beginning of the file if @var{dest} is
a file, or otherwise behaving the same as @code{>>}.

@item &> @var{dest}
@itemx >& @var{dest}
Redirect both standard output and standard error to @var{dest},
overwriting its contents with the new output.

@item &>> @var{dest}
@itemx >>& @var{dest}
Redirect both standard output and standard error to @var{dest},
appending it to the existing contents of @var{dest}.

@item &>>> @var{dest}
@itemx >>>& @var{dest}
Redirect both standard output and standard error to @var{dest},
inserting it like with @code{>>> @var{dest}}.

@item >&@var{other-fd}
@itemx @var{fd}>&@var{other-fd}
Duplicate the file descriptor @var{other-fd} to @var{fd} (or 1 if
unspecified).  The order in which this is used is significant, so

@example
@var{command} > @var{file} 2>&1
@end example

redirects both standard output and standard error to @var{file},
whereas

@example
@var{command} 2>&1 > @var{file}
@end example

only redirects standard output to @var{file} (and sends standard error
to the display via standard output's original handle).

@end table

Eshell supports redirecting output to several different types of
targets:

@itemize @bullet

@item
files, including virtual targets (see below);

@item
buffers (@pxref{Buffers, , , elisp, GNU Emacs Lisp Reference Manual});

@item
markers (@pxref{Markers, , , elisp, GNU Emacs Lisp Reference Manual});

@item
processes (@pxref{Processes, , , elisp, GNU Emacs Lisp Reference
Manual}); and

@item
symbols (@pxref{Symbols, , , elisp, GNU Emacs Lisp Reference Manual}).

@end itemize

@subsection Virtual Targets
Virtual targets are mapping of device names to functions.  Eshell
comes with four virtual devices:

@table @file

@item /dev/null
Does nothing with the output passed to it.

@item /dev/eshell
Writes the text passed to it to the display.

@item /dev/kill
Adds the text passed to it to the kill ring.

@item /dev/clip
Adds the text passed to it to the clipboard.

@end table

@vindex eshell-virtual-targets
@vindex eshell-generic-target
@findex eshell-output-object-to-target
@findex eshell-close-target
You can, of course, define your own virtual targets.  These are entries
in @code{eshell-virtual-targets} with the form @samp{(@var{filename}
@var{output-function} @var{pass-mode})}.  The first element,
@var{filename}, is the device name, usually of the form
@samp{"/dev/@var{name}"}.  The second, @var{output-function}, should be a
function: Eshell will repeatedly call it with the redirected output.
This argument can also be an @code{eshell-generic-target} instance.  In
this case, Eshell will repeatedly call the generic function
@code{eshell-output-object-to-target} with the output; once the
redirection has completed, Eshell will then call the generic function
@code{eshell-close-target}, passing non-@code{nil} if the redirected
command succeeded.

If @var{pass-mode} is non-@code{nil}, then Eshell will pass the
redirection mode as an argument to @code{output-function} as a
symbol: @code{overwrite} for @code{>}, @code{append} for @code{>>}, or
@code{insert} for @code{>>>}.  In this case, @code{output-function}
should return the real output function (either an ordinary function or
an @code{eshell-generic-target} as described above).

@defun eshell-function-target-create output-function &optional close-function
Create a new virtual target for Eshell that repeatedly calls
@var{output-function} with the redirected output, as described above.
If @var{close-function} is non-@code{nil}, Eshell will call it when
closing the target, passing non-@code{nil} if the redirected command
succeeded.
@end defun

@node Pipelines
@section Pipelines
As with most other shells, Eshell supports pipelines to pass the
output of one command the input of the next command.  You can send the
standard output of one command to the standard input of another using
the @code{|} operator.  For example,

@example
~ $ echo hello | rev
olleh
@end example

To send both the standard output and standard error of a command to
another command's input, you can use the @code{|&} operator.

@subsection 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 recognizes 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 occurring 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 Interaction
@chapter Interaction

As an interactive shell, Eshell contains many features for helping to
interact with your command environment.  In addition, since Eshell is a
part of Emacs, all of the usual Emacs commands work within Eshell as
well.

@menu
* Navigation::
* Completion::
* History::
@end menu

@node Navigation
@section Navigation

@table @kbd

@kindex C-c C-n
@kindex C-c C-p
@item C-c C-n
@itemx C-c C-p
Move point to the beginning of the input for the next or previous
prompt.  With a prefix argument, move to the n-th next or previous
prompt.

@kindex C-c C-r
@kindex C-M-l
@item C-c C-r
@itemx C-M-l
Move point to the start of the previous command's output and display it
at the top of the window.  With a prefix argument, this also narrows the
region to the last command's output.

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

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

@kindex M-?
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 History
@section History
@cmindex history
@vindex eshell-history-size
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}.

@vindex eshell-history-file-name
@vindex eshell-history-append
The history is loaded to the history ring from the file
@code{eshell-history-file-name} at the start of every session, and
saved to that file at the end of every session.  The default history
saving behavior is to overwrite the history file with the whole
history ring of the session.  If @code{eshell-history-append} is
non-@code{nil}, the history will instead be saved by appending new
entries from the session to the history file, which could prevent
potential history loss with multiple Eshell sessions.  Unlike other
shells, such as Bash, Eshell cannot currently be configured to control
the size of the history file.  In particular, when
@code{eshell-history-append} is non-@code{nil}, the size of the file
will keep increasing, and the recommended way to truncate the file is
to run the @samp{history -w} command in an Eshell session.

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
@kindex M-r
@kindex M-s
@item M-r
@itemx M-s
History I-search.

@kindex M-p
@kindex M-n
@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 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.}

@menu
* Optional modules::
* Writing a module::
@end menu

@node Optional modules
@section Optional modules

@vindex eshell-modules-list
In addition to the various modules enabled by default (documented
above), Eshell provides several other modules which are @emph{not}
enabled by default.  If you want to enable these, you can add them to
@code{eshell-modules-list}.

@menu
* Key rebinding::
* Smart scrolling::
* Electric forward slash::
* Tramp extensions::
* Extra built-in commands::
@end menu

@node Key rebinding
@subsection Key rebinding

This module allows for special keybindings that only take effect
while the point is in a region of input text.  The default keybindings
mimic the bindings used in other shells when the user is editing new
input text.  To enable this module, add @code{eshell-rebind} to
@code{eshell-modules-list}.

@kindex C-u
@kindex C-w
@kindex C-p
@kindex C-n
For example, it binds @kbd{C-u} to kill the current input text and
@kbd{C-w} to @code{backward-kill-word}.  If the history module is
enabled, it also binds @kbd{C-p} and @kbd{C-n} to move through the
input history.

@vindex eshell-confine-point-to-input
If @code{eshell-confine-point-to-input} is non-@code{nil}, this module
prevents certain commands from causing the point to leave the input
area, such as @code{backward-word}, @code{previous-line}, etc.

@node Smart scrolling
@subsection Smart scrolling

This module combines the facility of normal, modern shells with some
of the edit/review concepts inherent in the design of Plan 9's 9term.
To enable it, add @code{eshell-smart} to @code{eshell-modules-list}.

@itemize @bullet
@item
When you invoke a command, it is assumed that you want to read the
output of that command.

@item
If the output is not what you wanted, it is assumed that you will want
to edit, and then resubmit a refined version of that command.

@item
If the output is valid, pressing any self-inserting character key will
jump to end of the buffer and insert that character, in order to begin
entry of a new command.

@item
If you show an intention to edit the previous command -- by moving
around within it -- then the next self-inserting characters will
insert *there*, instead of at the bottom of the buffer.

@item
If you show an intention to review old commands, such as @kbd{M-p} or
@kbd{M-r}, point will jump to the bottom of the buffer before invoking
that command.

@item
If none of the above has happened yet (i.e.@: your point is just
sitting on the previous command), you can use @kbd{SPC} and
@kbd{BACKSPACE} (or @kbd{Delete}) to page forward and backward
@emph{through the output of the last command only}.  It will constrain
the movement of the point and window so that the maximum amount of
output is always displayed at all times.

@item
While output is being generated from a command, the window will be
constantly reconfigured (until it would otherwise make no difference)
in order to always show you the most output from the command possible.
This happens if you change window sizes, scroll, etc.
@end itemize

@node Electric forward slash
@subsection Electric forward slash

To help with supplying absolute file name arguments to remote
commands, you can add the @code{eshell-elecslash} module to
@code{eshell-modules-list}.  Then, typing @kbd{/} as the first
character of a command line argument will automatically insert the
Tramp prefix @file{/method:host:}.  If this is not what you want
(e.g.@: because you want to refer to a local file), you can type
another @kbd{/} to undo the automatic insertion.  Typing @kbd{~/} also
inserts the Tramp prefix.  The automatic insertion applies only when
@code{default-directory} is remote and the command is a Lisp function.
In particular, typing arguments to external commands doesn't insert
the prefix.

The result is that in most cases of supplying absolute file name
arguments to commands you should see the Tramp prefix inserted
automatically only when that's what you'd reasonably expect.  This
frees you from having to keep track of whether commands are Lisp
functions or external when typing command line arguments.  For
example, suppose you execute

@example
 cd /ssh:root@@example.com:
 find /etc -name "*gnu*"
@end example

@noindent and in reviewing the output of the command, you identify a
file @file{/etc/gnugnu} that should be moved somewhere else.  So you
type

@example
 mv /etc/gnugnu /tmp
@end example

@noindent But since @command{mv} refers to the local Lisp function
@code{eshell/mv}, not a remote shell command, to say this is to
request that the local file @file{/etc/gnugnu} be moved into the local
@file{/tmp} directory.  After you add @code{eshell-elecslash} to
@code{eshell-modules-list}, then when you type the above @command{mv}
invocation you will get the following input, which is what you
intended:

@example
 mv /ssh:root@@example.com:/etc/gnugnu /ssh:root@@example.com:/tmp
@end example

The code that determines whether or not the Tramp prefix should be
inserted uses simple heuristics.  A limitation of the current
implementation is that it inspects whether only the command at the
very beginning of input is a Lisp function or external program.  Thus
when chaining commands with the operators @code{&&}, @code{||},
@code{|} and @code{;}, the electric forward slash is active only
within the first command.

@node Tramp extensions
@subsection Tramp extensions

This module adds built-in commands that use Tramp to handle running
other commands as different users, replacing the corresponding
external commands.  To enable it, add @code{eshell-tramp} to
@code{eshell-modules-list}.

@table @code

@cmindex su
@item su [- | -l] [@var{user}]
Uses TRAMP's @command{su} method (@pxref{Inline methods, , , tramp,
The Tramp Manual}) to change the current user to @var{user} (or root
if unspecified).  With @code{-}, @code{-l}, or @code{--login}, provide
a login environment.

@cmindex sudo
@item sudo [-u @var{user}] [-s | @var{command}@dots{}]
@cmindex doas
@itemx doas [-u @var{user}] [-s | @var{command}@dots{}]
Uses TRAMP's @command{sudo} or @command{doas} method (@pxref{Inline
methods, , , tramp, The Tramp Manual}) to run @var{command} as root
via @command{sudo} or @command{doas}.  When specifying @code{-u
@var{user}} or @code{--user @var{user}}, run the command as @var{user}
instead.  With @code{-s} or @code{--shell}, start a shell instead of
running @var{command}.

@end table

@node Extra built-in commands
@subsection Extra built-in commands

This module provides several extra built-in commands documented below,
primarily for working with lists of strings in Eshell.  To enable it,
add @code{eshell-xtra} to @code{eshell-modules-list}.

@table @code

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

@cmindex expr
@item expr @var{str} [@var{separator}] [@var{arg}]@dots{}
An implementation of @command{expr} using the Calc package.
@xref{Top,,, calc, The GNU Emacs Calculator}.

@cmindex ff
@item ff @var{directory} @var{pattern}
Shorthand for the function @code{find-name-dired} (@pxref{Dired
and Find, , , emacs, The Emacs Editor}).

@cmindex gf
@item gf @var{directory} @var{regexp}
Shorthand for the function @code{find-grep-dired} (@pxref{Dired
and Find, , , emacs, The Emacs Editor}).

@cmindex intersection
@item intersection @var{list1} @var{list2} [@var{option}]@dots{}
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.

@cmindex mismatch
@item mismatch @var{seq1} @var{seq2} [@var{option}]@dots{}
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.

@cmindex set-difference
@item set-difference @var{list1} @var{list2} [@var{option}]@dots{}
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.

@cmindex set-exclusive-or
@item set-exclusive-or @var{list1} @var{list2} [@var{option}]@dots{}
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.

@cmindex substitute
@item substitute @var{new} @var{old} @var{seq} [@var{option}]@dots{}
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.

@cmindex union
@item union @var{list1} @var{list2} [@var{option}]@dots{}
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.

@end table

@node Writing a module
@section Writing a module

An Eshell module is defined the same as any other library but with two
additional requirements: first, the module's source file should be
named @file{em-@var{name}.el}; second, the module must define an
autoloaded Customize group (@pxref{Customization, , , elisp, The Emacs
Lisp Reference Manual}) with @code{eshell-module} as the parent group.
In order to properly autoload this group, you should wrap its
definition with @code{progn} as follows:

@example
;;;###autoload
(progn
(defgroup eshell-my-module nil
  "My module lets you do very cool things in Eshell."
  :tag "My module"
  :group 'eshell-module))
@end example

Even if you don't have any Customize options in your module, you
should still define the group so that Eshell can include your module
in the Customize interface for @code{eshell-modules-list}.

@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 Differentiate between aliases and functions

Allow for a Bash-compatible syntax, such as:

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

@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 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 Menu support was removed, but never put back

@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 @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 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 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 @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 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 Support zsh's ``Parameter Expansion'' syntax, i.e., @samp{$@{@var{name}:-@var{val}@}}

@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 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 Make a customizable syntax table for redirects

This way, the user could change it to use rc syntax: @samp{>[2=1]}.

@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{ssh}, 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{/} more electric

@noindent so that it automatically expands and corrects file names,
beyond what the @code{em-elecslash} module is able to do.  Or make
file name 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 @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

@node Key Index
@unnumbered Key Index

@printindex ky

@bye