[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to eshell.texi
From: |
Glenn Morris |
Subject: |
[Emacs-diffs] Changes to eshell.texi |
Date: |
Thu, 06 Sep 2007 04:59:45 +0000 |
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