[Emacs-diffs] Changes to eshell.texi

[Glenn Morris]

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Glenn Morris <gm>       07/09/06 04:59:45

Index: eshell.texi
===================================================================
RCS file: eshell.texi
diff -N eshell.texi
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ eshell.texi 6 Sep 2007 04:59:45 -0000       1.1
@@ -0,0 +1,948 @@
+\input texinfo  @c -*-texinfo-*-
address@hidden %**start of header
address@hidden ../info/eshell
address@hidden Eshell: The Emacs Shell
address@hidden vr fn
address@hidden %**end of header
+
address@hidden
+This manual is for Eshell, the Emacs shell.
+
+Copyright @copyright{} 1999, 2000, 2001, 2002, 2003, 2004,
+2005, 2006, 2007 Free Software Foundation, Inc.
+
address@hidden
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.2 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'' in the Emacs manual.
+
+(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
+this GNU Manual, like GNU software.  Copies published by the Free
+Software Foundation raise funds for GNU development.''
+
+This document is part of a collection distributed under the GNU Free
+Documentation License.  If you want to distribute this document
+separately from the collection, you can do so by adding a copy of the
+license to the document, as described in section 6 of the license.
address@hidden quotation
address@hidden copying
+
address@hidden Emacs
address@hidden
+* Eshell: (eshell).     A command shell implemented in Emacs Lisp.
address@hidden direntry
+
address@hidden on
+
address@hidden
address@hidden 4
address@hidden The title is printed in a large font.
address@hidden @titlefont{User's Guide}
address@hidden
address@hidden @titlefont{to}
address@hidden
address@hidden @titlefont{Eshell: The Emacs Shell}
address@hidden
address@hidden 2
address@hidden release 2.4
address@hidden -release-
address@hidden ignore
address@hidden 3
address@hidden John Wiegley
address@hidden -date-
+
address@hidden
address@hidden 0pt plus 1filll
address@hidden
address@hidden titlepage
+
address@hidden
+
address@hidden ================================================================
address@hidden                   The real text starts here
address@hidden ================================================================
+
address@hidden
address@hidden Top, What is Eshell?, (dir), (dir)
address@hidden Eshell
+
+This manual documents Eshell, a shell-like command interpretor
+implemented in Emacs Lisp.  It invokes no external processes except for
+those requested by the user.  It is intended to be a functional
+replacement for command shells such as @command{bash}, @command{zsh},
address@hidden, or @command{4dos}; since Emacs itself is capable of
+handling the sort of tasks accomplished by those tools.
address@hidden This manual is updated to release 2.4 of Eshell.
address@hidden ifnottex
+
address@hidden
+* What is Eshell?::             A brief introduction to the Emacs Shell.
+* Command basics::              The basics of command usage.
+* Commands::
+* Arguments::
+* Input/Output::
+* Process control::
+* Extension modules::
+* Extras and Goodies::
+* Bugs and ideas::              Known problems, and future ideas.
+* GNU Free Documentation License:: The license for this documentation.
+* Concept Index::
+* Function and Variable Index::
+* Key Index::
address@hidden menu
+
address@hidden What is Eshell?
address@hidden What is Eshell?
address@hidden what is Eshell?
address@hidden Eshell, what it is
+
+Eshell is a @dfn{command shell} written in Emacs Lisp.  Everything it
+does, it uses Emacs' 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 address@hidden  Typing
address@hidden in a command shell is a script way of telling the computer
+to list your address@hidden 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.
address@hidden the understandably curious, here is what that command
+looks like: But don't let it fool you; once you know what's going on,
+it's easier than it looks: @code{ls -lt **/*.doc(Lk+50aM+5)}.}
+
address@hidden
+* Contributors to Eshell::      People who have helped out!
address@hidden menu
+
address@hidden Contributors to Eshell
address@hidden Contributors to Eshell
address@hidden contributors
address@hidden 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.
+
address@hidden @bullet
address@hidden
+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 address@hidden
+
address@hidden
+Miles Bader contributed many fixes during the port to Emacs address@hidden
+
address@hidden
+Stefan Monnier fixed the things which bothered him, which of course made
+things better for address@hidden
+
address@hidden
+Gerd Moellmann also helped to contribute bug fixes during the initial
+integration with Emacs address@hidden
+
address@hidden
+Alex Schroeder contributed code for interactively querying the user
+before overwriting address@hidden
+
address@hidden
+Sudish Joseph helped with some XEmacs compatibility address@hidden
address@hidden 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.
+
address@hidden Command basics
address@hidden Basic overview
+
+A command shell is a means of entering verbally-formed commands.  This
+is really all that it does, and every feature described in this manual
+is a means to that end.  Therefore, it's important to take firm hold on
+exactly what a command is, and how it fits in the overall picture of
+things.
+
address@hidden
+* Commands verbs::              Commands always begin with a verb.
+* Command arguments::           Some verbs require arguments.
address@hidden menu
+
address@hidden Commands verbs
address@hidden Commands verbs
+
+Commands are expressed using @dfn{script}, a special shorthand language
+computers can understand with no trouble.  Script is an extremely simple
+language; oddly enough, this is what makes it look so complicated!
+Whereas normal languages use a variety of embellishments, the form of a
+script command is always:
+
address@hidden
address@hidden address@hidden
address@hidden example
+
+The verb expresses what you want your computer to do.  There are a fixed
+number of verbs, although this number is usually quite large.  On the
+author's computer, it reaches almost 1400 in number.  But of course,
+only a handful of these are really necessary.
+
+Sometimes, the verb is all that's written.  A verb is always a single
+word, usually related to the task it performs.  @command{reboot} is a
+good example.  Entering that on GNU/Linux will reboot the
+computer---assuming you have sufficient privileges.
+
+Other verbs require more information.  These are usually very capable
+verbs, and must be told specifically what to do.  The extra information
+is given in the form of @dfn{arguments}.  For example, the
address@hidden verb prints back whatever arguments you type.  It
+requires these arguments to know what to echo.  A proper use of
address@hidden looks like this:
+
address@hidden
+echo This is an example of using echo!
address@hidden example
+
+This script command causes the computer to echo back: ``This is an
+example of using echo!''
+
+Although command verbs are always simple words, like @command{reboot} or
address@hidden, arguments may have a wide variety of forms.  There are
+textual arguments, numerical arguments---even Lisp arguments.
+Distinguishing these different types of arguments requires special
+typing, for the computer to know exactly what you mean.
+
address@hidden Command arguments
address@hidden Command arguments
+
+Eshell recognizes several different kinds of command arguments:
+
address@hidden
address@hidden Strings (also called textual arguments)
address@hidden Numbers (floating point or integer)
address@hidden Lisp lists
address@hidden Lisp symbols
address@hidden Emacs buffers
address@hidden Emacs process handles
address@hidden enumerate
+
+Most users need to worry only about the first two.  The third, Lisp lists,
+occur very frequently, but almost always behind the scenes.
+
+Strings are the most common type of argument, and consist of nearly any
+character.  Special characters---those used by Eshell
+specifically---must be preceded by a backslash (@samp{\}).  When in doubt, it
+is safe to add backslashes anywhere and everywhere.
+
+Here is a more complicated @command{echo} example:
+
address@hidden
+echo A\ Multi-word\ Argument\ With\ A\ \$\ dollar
address@hidden example
+
+Beyond this, things get a bit more complicated.  While not beyond the
+reach of someone wishing to learn, it is definitely beyond the scope of
+this manual to present it all in a simplistic manner.  Get comfortable
+with Eshell as a basic command invocation tool, and learn more about the
+commands on your system; then come back when it all sits more familiarly
+on your mind.  Have fun!
+
address@hidden Commands
address@hidden Commands
+
address@hidden
+* Invocation::
+* Completion::
+* Aliases::
+* History::
+* Scripts::
+* Built-ins::
address@hidden menu
+
+Essentially, a command shell is all about invoking commands---and
+everything that entails.  So understanding how Eshell invokes commands
+is the key to comprehending how it all works.
+
address@hidden Invocation
address@hidden Invocation
+
+Unlike regular system shells, Eshell never invokes kernel functions
+directly, such as @code{exec(3)}.  Instead, it uses the Lisp functions
+available in the Emacs Lisp library.  It does this by transforming the
+command you specify into a callable Lisp address@hidden see the Lisp
+form that will be invoked, type: @samp{eshell-parse-command "echo
+hello"}}
+
+This transformation, from the string of text typed at the command
+prompt, to the ultimate invocation of either a Lisp function or external
+command, follows these steps:
+
address@hidden
address@hidden Parse the command string into separate arguments.
address@hidden
address@hidden enumerate
+
address@hidden Completion
address@hidden Completion
+
address@hidden Aliases
address@hidden Aliases
+
address@hidden History
address@hidden History
+
+Eshell knows a few built-in variables:
+
address@hidden @code
+
address@hidden $+
address@hidden $+
+This variable always contains the current working directory.
+
address@hidden $-
address@hidden $-
+This variable always contains the previous working directory (the
+current working directory from before the last @code{cd} command).
+
address@hidden table
+
address@hidden Scripts
address@hidden Scripts
+
+
address@hidden Built-ins
address@hidden Built-in commands
+
+Here is a list of built-in commands that Eshell knows about:
+
address@hidden @code
+
address@hidden cd
address@hidden cd
+This command changes the current working directory.  Usually, it is
+invoked as @samp{cd foo} where @file{foo} is the new working
+directory.  But @code{cd} knows about a few special arguments:
+
+When it receives no argument at all, it changes to the home directory.
+
+Giving the command @samp{cd -} changes back to the previous working
+directory (this is the same as @samp{cd $-}).
+
+The command @samp{cd =} shows the directory stack.  Each line is
+numbered.
+
+With @samp{cd =foo}, Eshell searches the directory stack for a
+directory matching the regular expression @samp{foo} and changes to
+that directory.
+
+With @samp{cd -42}, you can access the directory stack by number.
+
address@hidden table
+
+
address@hidden Arguments
address@hidden Arguments
+
address@hidden
+* The Parser::
+* Variables::
+* Substitution::
+* Globbing::
+* Predicates::
address@hidden menu
+
address@hidden The Parser
address@hidden The Parser
+
address@hidden Variables
address@hidden Variables
+
address@hidden Substitution
address@hidden Substitution
+
address@hidden Globbing
address@hidden Globbing
+
address@hidden Predicates
address@hidden Predicates
+
+
address@hidden Input/Output
address@hidden Input/Output
+
address@hidden Process control
address@hidden Process control
+
+
address@hidden Extension modules
address@hidden Extension modules
+
address@hidden
+* Writing a module::
+* Module testing::
+* Directory handling::
+* Key rebinding::
+* Smart scrolling::
+* Terminal emulation::
+* Built-in UNIX commands::
address@hidden menu
+
address@hidden Writing a module
address@hidden Writing a module
+
address@hidden Module testing
address@hidden Module testing
+
address@hidden Directory handling
address@hidden Directory handling
+
address@hidden Key rebinding
address@hidden Key rebinding
+
address@hidden Smart scrolling
address@hidden Smart scrolling
+
address@hidden Terminal emulation
address@hidden Terminal emulation
+
address@hidden Built-in UNIX commands
address@hidden Built-in UNIX commands
+
+
address@hidden Extras and Goodies
address@hidden Extras and Goodies
+
address@hidden Bugs and ideas
address@hidden Bugs and ideas
address@hidden reporting bugs and ideas
address@hidden bugs, how to report them
address@hidden author, how to reach
address@hidden email to the author
address@hidden FAQ
address@hidden problems, list of common
+
+If you find a bug or misfeature, don't hesitate to let me know!  Send
+email to @email{johnw@@gnu.org}.  Feature requests should also be sent
+there.  I prefer discussing one thing at a time.  If you find several
+unrelated bugs, please report them separately.
+
+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!
+
address@hidden
+* Known problems::
address@hidden menu
+
address@hidden Known problems
address@hidden Known problems
address@hidden known bugs
address@hidden bugs, known
+
+Below is complete list of known problems with Eshell version 2.4.2,
+which is the version included with Emacs 22.
+
address@hidden @asis
address@hidden Documentation incomplete
+
address@hidden Differentiate between aliases and functions
+
+Allow for a bash-compatible syntax, such as:
+
address@hidden
+alias arg=blah
+function arg () @{ blah $* @}
address@hidden example
+
address@hidden @samp{for i in 1 2 3 @{ grep -q a b && *echo has it @} | wc -l} 
outputs result after prompt
+
+In fact, piping to a process from a looping construct doesn't work in
+general.  If I change the call to @code{eshell-copy-handles} in
address@hidden to use @code{eshell-protect}, it seems
+to work, but the output occurs after the prompt is displayed.  The whole
+structured command thing is too complicated at present.
+
address@hidden Error with @command{bc} in @code{eshell-test}
+
+On some XEmacs system, the subprocess interaction test fails
+inexplicably, although @command{bc} works fine at the command prompt.
+
address@hidden Eshell does not delete @file{*Help*} buffers in XEmacs 21.1.8+
+
+In XEmacs 21.1.8, the @file{*Help*} buffer has been renamed such that
+multiple instances of the @file{*Help*} buffer can exist.
+
address@hidden Pcomplete sometimes gets stuck
+
+You press @key{TAB}, but no completions appear, even though the
+directory has matching files.  This behavior is rare.
+
address@hidden @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.
+
address@hidden Problem with C-r repeating text
+
+If the text @emph{before point} reads "./run", and you type @kbd{C-r r u
+n}, it will repeat the line for every character typed.
+
address@hidden 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.
+
address@hidden It's not possible to fully @code{unload-feature} Eshell
+
address@hidden Menu support was removed, but never put back
+
address@hidden Using C-p and C-n with rebind gets into a locked state
+
+This happened a few times in Emacs 21, but has been unreproducible
+since.
+
address@hidden If an interactive process is currently running, @kbd{M-!} 
doesn't work
+
address@hidden Use a timer instead of @code{sleep-for} when killing child 
processes
+
address@hidden 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
address@hidden to handle non-process targets.
+
address@hidden Input redirection is not supported
+
+See the above entry.
+
address@hidden Problem running @command{less} without arguments on Windows
+
+The result in the Eshell buffer is:
+
address@hidden
+Spawning child process: invalid argument
address@hidden example
+
+Also a new @command{less} buffer was created with nothing in address@hidden
+(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.
+
address@hidden Implement @samp{-r}, @samp{-n} and @samp{-s} switches for 
@command{cp}
+
address@hidden Make @kbd{M-5 M-x eshell} switch to ``*eshell<5>*'', creating if 
need be
+
address@hidden @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?
+
address@hidden 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).
+
address@hidden When an extension module fails to load, @samp{cd /} gives a Lisp 
error
+
address@hidden If a globbing pattern returns one match, should it be a list?
+
address@hidden Make sure syntax table is correct in Eshell mode
+
+So that @kbd{M-DEL} acts in a predictable manner, etc.
+
address@hidden Allow all Eshell buffers to share the same history and list-dir
+
address@hidden There is a problem with script commands that output to 
@file{/dev/null}
+
+If a script file, somewhere in the middle, uses @samp{> /dev/null},
+output from all subsequent commands is swallowed.
+
address@hidden 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]}.
+
address@hidden After pressing @kbd{M-RET}, redisplay before running the next 
command
+
address@hidden Argument predicates and modifiers should work anywhere in a path
+
address@hidden
+/usr/local/src/editors/vim $ vi **/CVS(/)/Root(.)
+Invalid regexp: "Unmatched ( or \\("
address@hidden example
+
+With @command{zsh}, the glob above expands to all files named
address@hidden in directories named @file{CVS}.
+
address@hidden Typing @samp{echo address@hidden address@hidden/bin<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
address@hidden only C backup files by using @samp{ls address@hidden 
address@hidden
+In that case, having an alias command name @command{glob} for
address@hidden would be useful.
+
address@hidden Once symbolic mode is supported for @command{umask}, implement 
@command{chmod} in Lisp
+
address@hidden Create @code{eshell-expand-file-name}
+
+This would use a data table to transform things such as @samp{~+},
address@hidden, etc.
+
address@hidden 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.''
+
address@hidden Allow for fully persisting the state of Eshell
+
+This would include: variables, history, buffer, input, dir stack, etc.
+
address@hidden Implement D as an argument predicate
+
+It means that files beginning with a dot should be included in the
+glob match.
+
address@hidden A comma in a predicate list should mean OR
+
+At the moment, this is not supported.
+
address@hidden Error if a glob doesn't expand due to a predicate
+
+An error should be generated only if @code{eshell-error-if-no-glob} is
address@hidden
+
address@hidden @samp{(+ RET SPC TAB} does not cause 
@code{indent-according-to-mode} to occur
+
address@hidden 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.
+
address@hidden Display file and line number if an error occurs in a script
+
address@hidden @command{wait} doesn't work with process ids at the moment
+
address@hidden Enable the direct-to-process input code in @file{em-term.el}
+
address@hidden Problem with repeating @samp{echo address@hidden /address@hidden
+
+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 address@hidden
+
+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
address@hidden 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}.
+
address@hidden Allow for a more aggressive smart display mode
+
+Perhaps toggled by a command, that makes each output block a smart
+display block.
+
address@hidden Create more meta variables
+
address@hidden @samp
address@hidden $!
+The reason for the failure of the last disk command, or the text of the
+last Lisp error.
+
address@hidden $=
+A special associate array, which can take references of the form
address@hidden  It indexes into the directory ring.
address@hidden table
+
address@hidden Eshell scripts can't execute in the background
+
address@hidden Support zsh's ``Parameter Expansion'' syntax, i.e. 
@address@hidden@var{name}:address@hidden@}}
+
address@hidden Write an @command{info} alias that can take arguments
+
+So that the user can enter @samp{info chmod}, for example.
+
address@hidden Create a mode @code{eshell-browse}
+
+It would treat the Eshell buffer as a outline.  Collapsing the outline
+hides all of the output text.  Collapsing again would show only the
+first command run in each directory
+
address@hidden Allow other revisions of a file to be referenced using 
@address@hidden@}}
+
+This would be expanded by @code{eshell-expand-file-name} (see above).
+
address@hidden Print ``You have new mail'' when the ``Mail'' icon is turned on
+
address@hidden Implement @kbd{M-|} for Eshell
+
address@hidden Implement input redirection
+
+If it's a Lisp function, input redirection implies @command{xargs} (in a
address@hidden).  If input redirection is added, also update the
address@hidden, and the delimiter list.
+
address@hidden Allow @samp{#<@var{word} @var{arg}>} as a generic syntax
+
+With the handling of @emph{word} specified by an
address@hidden
+
address@hidden In @code{eshell-veal-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.
+
address@hidden 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
address@hidden
+
+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.
+
address@hidden Write @code{eshell-script-mode} as a minor mode
+
+It would provide syntax, abbrev, highlighting and indenting support like
address@hidden and @code{shell-mode}.
+
address@hidden In the history mechanism, finish the @command{bash}-style support
+
+This means @samp{!n}, @samp{!#}, @samp{!:%}, and @samp{!:1-} as separate
+from @samp{!:1*}.
+
address@hidden Support the -n command line option for @command{history}
+
address@hidden Implement @command{fc} in Lisp
+
address@hidden Specifying a frame as a redirection target should imply the 
currently active window's buffer
+
address@hidden 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}).
+
address@hidden 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).
+
address@hidden Write a @command{help} command
+
+It would call subcommands with @option{--help}, or @option{-h} or
address@hidden/?}, as appropriate.
+
address@hidden Implement @command{stty} in Lisp
+
address@hidden Support @command{rc}'s matching operator, e.g. @samp{~ 
(@var{list}) @var{regexp}}
+
address@hidden 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.
+
address@hidden Have @command{jobs} print only the processes for the current 
shell
+
address@hidden How can Eshell learn if a background process has requested input?
+
address@hidden Support @samp{2>&1} and @samp{>&} and @samp{2>} and @samp{|&}
+
+The syntax table for parsing these should be customizable, such that the
+user could change it to use rc syntax: @samp{>[2=1]}.
+
address@hidden Allow @samp{$_[-1]}, which would indicate the last element of 
the array
+
address@hidden Make @samp{$x[*]} equal to listing out the full contents of 
@samp{x}
+
+Return them as a list, so that @samp{$_[*]} is all the arguments of the
+last command.
+
address@hidden 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).
+
address@hidden Make the shell spawning commands be visual
+
+That is, make (@command{su}, @command{bash}, @command{telnet},
address@hidden, @command{rsh}, etc.) be part of
address@hidden  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.
+
address@hidden 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).
+
address@hidden Alias @command{read} to be the same as @command{open}, only 
read-only
+
address@hidden 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
address@hidden alias which assumes an upper limit of
address@hidden characters per line.
+
address@hidden Make @command{dgrep} load @code{dired}, mark everything, then 
invoke @code{dired-do-search}
+
address@hidden Write mesh.c
+
+This would run Emacs with the appropriate arguments to invoke Eshell
+only.  That way, it could be listed as a login shell.
+
address@hidden Use an intangible @code{PS2} string for multi-line input prompts
+
address@hidden Auto-detect when a command is visual, by checking @code{TERMCAP} 
usage
+
address@hidden The first keypress after @kbd{M-x watson} triggers 
`eshell-send-input'
+
address@hidden Make @kbd{/} electric
+
+So that it automatically expands and corrects pathnames.  Or make
+pathname completion for Pcomplete auto-expand @samp{/u/i/std<TAB>} to
address@hidden/usr/include/std<TAB>}.
+
address@hidden Write the @command{pushd} stack to disk along with 
@code{last-dir-ring}
+
address@hidden Add options to @code{eshell/cat} which would allow it to sort 
and uniq
+
address@hidden Implement @command{wc} in Lisp
+
+Add support for counting sentences, paragraphs, pages, etc.
+
address@hidden Once piping is added, implement @command{sort} and 
@command{uniq} in Lisp
+
address@hidden Implement @command{touch} in Lisp
+
address@hidden Implement @command{comm} in Lisp
+
address@hidden Implement an @command{epatch} command in Lisp
+
+This would call @code{ediff-patch-file}, or @code{ediff-patch-buffer},
+depending on its argument.
+
address@hidden Have an option such that @samp{ls -l} generates a dired buffer
+
address@hidden Write a version of @command{xargs} based on command rewriting
+
+That is, @samp{find X | xargs Y} would be indicated using @samp{Y
address@hidden address@hidden  Maybe @code{eshell-do-pipelines} could be 
changed to
+perform this on-thy-fly rewriting.
+
address@hidden 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 @key{q}
+to return to Eshell.  It would be equivalent to:
address@hidden > #<buffer Y>; view-buffer #<buffer Y>}.
+
address@hidden Make @code{eshell-mode} as much a full citizen as 
@code{shell-mode}
+
+Everywhere in Emacs where @code{shell-mode} is specially noticed, add
address@hidden there.
+
address@hidden Permit the umask to be selectively set on a @command{cp} target
+
address@hidden Problem using @kbd{M-x eshell} after using @code{eshell-command}
+
+If the first thing that I do after entering Emacs is to run
address@hidden and invoke @command{ls}, and then use @kbd{M-x
+eshell}, it doesn't display anything.
+
address@hidden @kbd{M-RET} during a long command (using smart display) doesn't 
work
+
+Since it keeps the cursor up where the command was invoked.
+
address@hidden table
+
address@hidden GNU Free Documentation License
address@hidden GNU Free Documentation License
address@hidden doclicense.texi
+
address@hidden Concept Index
address@hidden Concept Index
+
address@hidden cp
+
address@hidden Function and Variable Index
address@hidden Function and Variable Index
+
address@hidden fn
+
address@hidden Key Index
address@hidden Key Index
+
address@hidden ky
address@hidden
+
address@hidden
+   arch-tag: 776409ba-cb15-42b9-b2b6-d2bdc7ebad01
address@hidden ignore