\input texinfo @c -*-texinfo-*-@c %**start of header@setfilename ../../info/eshell@settitle Eshell: The Emacs Shell@synindex vr fn@c %**end of header@copyingThis manual is for Eshell, the Emacs shell.Copyright @copyright{} 1999, 2000, 2001, 2002, 2003, 2004,2005, 2006, 2007, 2008 Free Software Foundation, Inc.@quotationPermission is granted to copy, distribute and/or modify this documentunder the terms of the GNU Free Documentation License, Version 1.2 orany later version published by the Free Software Foundation; with noInvariant Sections, with the Front-Cover texts being ``A GNUManual'', and with the Back-Cover Texts as in (a) below. A copy of thelicense is included in the section entitled ``GNU Free DocumentationLicense'' in the Emacs manual.(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modifythis GNU Manual, like GNU software. Copies published by the FreeSoftware Foundation raise funds for GNU development.''This document is part of a collection distributed under the GNU FreeDocumentation License. If you want to distribute this documentseparately from the collection, you can do so by adding a copy of thelicense to the document, as described in section 6 of the license.@end quotation@end copying@dircategory Emacs@direntry* Eshell: (eshell). A command shell implemented in Emacs Lisp.@end direntry@setchapternewpage on@titlepage@sp 4@c The title is printed in a large font.@center @titlefont{User's Guide}@sp@center @titlefont{to}@sp@center @titlefont{Eshell: The Emacs Shell}@ignore@sp 2@center release 2.4@c -release-@end ignore@sp 3@center John Wiegley@c -date-@page@vskip 0pt plus 1filll@insertcopying@end titlepage@contents@c ================================================================@c The real text starts here@c ================================================================@ifnottex@node Top, What is Eshell?, (dir), (dir)@top EshellThis manual documents Eshell, a shell-like command interpretorimplemented in Emacs Lisp. It invokes no external processes except forthose requested by the user. It is intended to be a functionalreplacement for command shells such as @command{bash}, @command{zsh},@command{rc}, or @command{4dos}; since Emacs itself is capable ofhandling the sort of tasks accomplished by those tools.@c This manual is updated to release 2.4 of Eshell.@end ifnottex@menu* 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::@end menu@node What is Eshell?@chapter What is Eshell?@cindex what is Eshell?@cindex Eshell, what it isEshell is a @dfn{command shell} written in Emacs Lisp. Everything itdoes, it uses Emacs' facilities to do. This means that Eshell is asportable as Emacs itself. It also means that cooperation with Lisp codeis 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, acomputer is a tool; in order to use that tool, you must tell it what todo---or give it ``commands.'' These commands take many forms, such asclicking with a mouse on certain parts of the screen. But that is onlyone form of command input.By far the most versatile way to express what you want the computer todo is by using an abbreviated language called @dfn{script}. Inscript, 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 computerto list your files.@footnote{This is comparable to viewing thecontents of a folder using a graphical display.}The real flexibility of this approach is apparent only when you realizethat there are many, many different ways to list files. Perhaps youwant them sorted by name, sorted by date, in reverse order, or groupedby type. Most graphical browsers have simple ways to express this. Butwhat about showing only a few files, or only files that meet a certaincriteria? In very complex and specific situations, the request becomestoo difficult to express using a mouse or pointing device. It is justthese kinds of requests that are easily solved using a command shell.For example, what if you want to list every Word file on your harddrive, larger than 100 kilobytes in size, and which hasn't been lookedat in over six months? That is a good candidate list for deletion, whenyou go to clean up your hard drive. But have you ever tried asking yourcomputer for such a list? There is no way to do it! At least, notwithout using a command shell.The role of a command shell is to give you more control over what yourcomputer does for you. Not everyone needs this amount of control, andit does come at a cost: Learning the necessary script commands toexpress what you want done. A complicated query, such as the exampleabove, takes time to learn. But if you find yourself using yourcomputer 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 commandlooks like: But don't let it fool you; once you know what's going on,it's easier than it looks: @code{ls -lt **/*.doc(Lk+50aM+5)}.}@menu* Contributors to Eshell:: People who have helped out!@end menu@node Contributors to Eshell@section Contributors to Eshell@cindex contributors@cindex authorsContributions to Eshell are welcome. I have limited time to work onthis project, but I will gladly add any code you contribute to me tothis package.The following persons have made contributions to Eshell.@itemize @bullet@itemEli Zaretskii made it possible for Eshell to run without requiringasynchronous subprocess support. This is important for MS-DOS, whichdoes not have such support.@refill@itemMiles Bader contributed many fixes during the port to Emacs 21.@refill@itemStefan Monnier fixed the things which bothered him, which of course madethings better for all.@refill@itemGerd Moellmann also helped to contribute bug fixes during the initialintegration with Emacs 21.@refill@itemAlex Schroeder contributed code for interactively querying the userbefore overwriting files.@refill@itemSudish Joseph helped with some XEmacs compatibility issues.@refill@end itemizeApart from these, a lot of people have sent suggestions, ideas,requests, bug reports and encouragement. Thanks a lot! Without youthere would be no new releases of Eshell.@node Command basics@chapter Basic overviewA command shell is a means of entering verbally-formed commands. Thisis really all that it does, and every feature described in this manualis a means to that end. Therefore, it's important to take firm hold onexactly what a command is, and how it fits in the overall picture ofthings.@menu* Commands verbs:: Commands always begin with a verb.* Command arguments:: Some verbs require arguments.@end menu@node Commands verbs@section Commands verbsCommands are expressed using @dfn{script}, a special shorthand languagecomputers can understand with no trouble. Script is an extremely simplelanguage; oddly enough, this is what makes it look so complicated!Whereas normal languages use a variety of embellishments, the form of ascript command is always:@example@var{verb} [@var{arguments}]@end exampleThe verb expresses what you want your computer to do. There are a fixednumber of verbs, although this number is usually quite large. On theauthor'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 singleword, usually related to the task it performs. @command{reboot} is agood example. Entering that on GNU/Linux will reboot thecomputer---assuming you have sufficient privileges.Other verbs require more information. These are usually very capableverbs, and must be told specifically what to do. The extra informationis given in the form of @dfn{arguments}. For example, the@command{echo} verb prints back whatever arguments you type. Itrequires these arguments to know what to echo. A proper use of@command{echo} looks like this:@exampleecho This is an example of using echo!@end exampleThis script command causes the computer to echo back: ``This is anexample of using echo!''Although command verbs are always simple words, like @command{reboot} or@command{echo}, arguments may have a wide variety of forms. There aretextual arguments, numerical arguments---even Lisp arguments.Distinguishing these different types of arguments requires specialtyping, for the computer to know exactly what you mean.@node Command arguments@section Command argumentsEshell recognizes several different kinds of command arguments:@enumerate@item Strings (also called textual arguments)@item Numbers (floating point or integer)@item Lisp lists@item Lisp symbols@item Emacs buffers@item Emacs process handles@end enumerateMost 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 anycharacter. Special characters---those used by Eshellspecifically---must be preceded by a backslash (@samp{\}). When in doubt, itis safe to add backslashes anywhere and everywhere.Here is a more complicated @command{echo} example:@exampleecho A\ Multi-word\ Argument\ With\ A\ \$\ dollar@end exampleBeyond this, things get a bit more complicated. While not beyond thereach of someone wishing to learn, it is definitely beyond the scope ofthis manual to present it all in a simplistic manner. Get comfortablewith Eshell as a basic command invocation tool, and learn more about thecommands on your system; then come back when it all sits more familiarlyon your mind. Have fun!@node Commands@chapter Commands@menu* Invocation::* Completion::* Aliases::* History::* Scripts::* Built-ins::@end menuEssentially, a command shell is all about invoking commands---andeverything that entails. So understanding how Eshell invokes commandsis the key to comprehending how it all works.@node Invocation@section InvocationUnlike regular system shells, Eshell never invokes kernel functionsdirectly, such as @code{exec(3)}. Instead, it uses the Lisp functionsavailable in the Emacs Lisp library. It does this by transforming thecommand you specify into a callable Lisp form.@footnote{To see the Lispform that will be invoked, type: @samp{eshell-parse-command "echohello"}}This transformation, from the string of text typed at the commandprompt, to the ultimate invocation of either a Lisp function or externalcommand, follows these steps:@enumerate@item Parse the command string into separate arguments.@item@end enumerate@node Completion@section Completion@node Aliases@section Aliases@node History@section HistoryEshell knows a few built-in variables:@table @code@item $+@vindex $+This variable always contains the current working directory.@item $-@vindex $-This variable always contains the previous working directory (thecurrent working directory from before the last @code{cd} command).@end table@node Scripts@section Scripts@node Built-ins@section Built-in commandsHere is a list of built-in commands that Eshell knows about:@table @code@item cd@findex cdThis command changes the current working directory. Usually, it isinvoked as @samp{cd foo} where @file{foo} is the new workingdirectory. 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 workingdirectory (this is the same as @samp{cd $-}).The command @samp{cd =} shows the directory stack. Each line isnumbered.With @samp{cd =foo}, Eshell searches the directory stack for adirectory matching the regular expression @samp{foo} and changes tothat directory.With @samp{cd -42}, you can access the directory stack by number.@end table@node Arguments@chapter Arguments@menu* The Parser::* Variables::* Substitution::* Globbing::* Predicates::@end menu@node The Parser@section The Parser@node Variables@section Variables@node Substitution@section Substitution@node Globbing@section Globbing@node Predicates@section Predicates@node Input/Output@chapter Input/Output@node Process control@chapter Process control@node Extension modules@chapter Extension modules@menu* Writing a module::* Module testing::* Directory handling::* Key rebinding::* Smart scrolling::* Terminal emulation::* Built-in UNIX commands::@end menu@node Writing a module@section Writing a module@node Module testing@section Module testing@node Directory handling@section Directory handling@node Key rebinding@section Key rebinding@node Smart scrolling@section Smart scrolling@node Terminal emulation@section Terminal emulation@node Built-in UNIX commands@section Built-in UNIX commands@node Extras and Goodies@chapter Extras and Goodies@node Bugs and ideas@chapter Bugs and ideas@cindex reporting bugs and ideas@cindex bugs, how to report them@cindex author, how to reach@cindex email to the author@cindex FAQ@cindex problems, list of commonIf you find a bug or misfeature, don't hesitate to let me know! Sendemail to @email{johnw@@gnu.org}. Feature requests should also be sentthere. I prefer discussing one thing at a time. If you find severalunrelated bugs, please report them separately.If you have ideas for improvements, or if you have written someextensions to this package, I would like to hear from you. I hope youfind this package useful!@menu* Known problems::@end menu@node Known problems@section Known problems@cindex known bugs@cindex bugs, knownBelow is complete list of known problems with Eshell version 2.4.2,which is the version included with Emacs 22.@table @asis@item Documentation incomplete@item Differentiate between aliases and functionsAllow for a bash-compatible syntax, such as:@examplealias arg=blahfunction arg () @{ blah $* @}@end example@item @samp{for i in 1 2 3 @{ grep -q a b && *echo has it @} | wc -l} outputs result after promptIn fact, piping to a process from a looping construct doesn't work ingeneral. If I change the call to @code{eshell-copy-handles} in@code{eshell-rewrite-for-command} to use @code{eshell-protect}, it seemsto work, but the output occurs after the prompt is displayed. The wholestructured command thing is too complicated at present.@item Error with @command{bc} in @code{eshell-test}On some XEmacs system, the subprocess interaction test failsinexplicably, although @command{bc} works fine at the command prompt.@item 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 thatmultiple instances of the @file{*Help*} buffer can exist.@item Pcomplete sometimes gets stuckYou press @key{TAB}, but no completions appear, even though thedirectory has matching files. This behavior is rare.@item @samp{grep python $<rpm -qa>} doesn't work, but using @samp{*grep} doesThis happens because the @code{grep} Lisp function returns immediately,and then the asynchronous @command{grep} process expects to examine thetemporary file, which has since been deleted.@item Problem with C-r repeating textIf the text @emph{before point} reads "./run", and you type @kbd{C-r r un}, it will repeat the line for every character typed.@item Backspace doesn't scroll back after continuing (in smart mode)Hitting space during a process invocation, such as @command{make}, willcause it to track the bottom of the output; but backspace no longerscrolls back.@item It's not possible to fully @code{unload-feature} Eshell@item Menu support was removed, but never put back@item Using C-p and C-n with rebind gets into a locked stateThis happened a few times in Emacs 21, but has been unreproduciblesince.@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 supportedMake it so that the Lisp command on the right of the pipe is repeatedlycalled with the input strings as arguments. This will require changing@code{eshell-do-pipeline} to handle non-process targets.@item Input redirection is not supportedSee the above entry.@item Problem running @command{less} without arguments on WindowsThe result in the Eshell buffer is:@exampleSpawning child process: invalid argument@end exampleAlso 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, theexpected output is written to the buffer.Note that this happens on NT-Emacs 20.6.1 on Windows 2000. The term.elpackage and the supplied shell both use the @command{cmdproxy} programfor running shells.@item Implement @samp{-r}, @samp{-n} and @samp{-s} switches for @command{cp}@item Make @kbd{M-5 M-x eshell} switch to ``*eshell<5>*'', creating if need be@item @samp{mv @var{dir} @var{file}.tar} does not remove directoriesThis is because the tar option --remove-files doesn't do so. Should itbe Eshell's job?@item Bind @code{standard-output} and @code{standard-error}This would be so that if a Lisp function calls @code{print}, everythingwill happen as it should (albeit slowly).@item When an extension module fails to load, @samp{cd /} gives a Lisp error@item If a globbing pattern returns one match, should it be a list?@item Make sure syntax table is correct in Eshell modeSo that @kbd{M-DEL} acts in a predictable manner, etc.@item Allow all Eshell buffers to share the same history and list-dir@item There is a problem with script commands that output to @file{/dev/null}If a script file, somewhere in the middle, uses @samp{> /dev/null},output from all subsequent commands is swallowed.@item Split up parsing of text after @samp{$} in @file{esh-var.el}Make it similar to the way that @file{esh-arg.el} is structured.Then add parsing of @samp{$[?\n]}.@item After pressing @kbd{M-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 exampleWith @command{zsh}, the glob above expands to all files named@file{Root} in directories named @file{CVS}.@item Typing @samp{echo $@{locate locate@}/bin<TAB>} results in a Lisp errorPerhaps it should interpolate all permutations, and make that theglobbing 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 thepre-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 EshellThis would include: variables, history, buffer, input, dir stack, etc.@item Implement D as an argument predicateIt means that files beginning with a dot should be included in theglob match.@item A comma in a predicate list should mean ORAt the moment, this is not supported.@item Error if a glob doesn't expand due to a predicateAn error should be generated only if @code{eshell-error-if-no-glob} isnon-@code{nil}.@item @samp{(+ RET SPC 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}, thetext is staged as the next Eshell command, rather than being sent to thecurrent interactive process.@item Display file and line number if an error occurs in a script@item @command{wait} doesn't work with process ids at the moment@item Enable the direct-to-process input code in @file{em-term.el}@item Problem with repeating @samp{echo $@{find /tmp@}}With smart display active, if @kbd{RET} is held down, after a while itcan't keep up anymore and starts outputting blank lines. It onlyhappens if an asynchronous process is involved@dots{}I think the problem is that @code{eshell-send-input} is resetting theinput target location, so that if the asynchronous process is not doneby the time the next @kbd{RET} is received, the input processor thinksthat the input is meant for the process; which, when smart display isenabled, will be the text of the last command line! That is a bug initself.In holding down @kbd{RET} while an asynchronous process is running,there will be a point in between termination of the process, and therunning of @code{eshell-post-command-hook}, which would cause@code{eshell-send-input} to call @code{eshell-copy-old-input}, and thenprocess that text as a command to be run after the process. Perhapsthere should be a way of killing pending input between the death of theprocess, and the @code{post-command-hook}.@item Allow for a more aggressive smart display modePerhaps toggled by a command, that makes each output block a smartdisplay block.@item Create more meta variables@table @samp@item $!The reason for the failure of the last disk command, or the text of thelast Lisp error.@item $=A special associate array, which can take references of the form@samp{$=[REGEXP]}. It indexes into the directory ring.@end table@item Eshell scripts can't execute in the background@item Support zsh's ``Parameter Expansion'' syntax, i.e. @samp{$@{@var{name}:-@var{val}@}}@item Write an @command{info} alias that can take argumentsSo that the user can enter @samp{info chmod}, for example.@item Create a mode @code{eshell-browse}It would treat the Eshell buffer as a outline. Collapsing the outlinehides all of the output text. Collapsing again would show only thefirst 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 redirectionIf it's a Lisp function, input redirection implies @command{xargs} (in away@dots{}). If input redirection is added, also update the@code{file-name-quote-list}, and the delimiter list.@item Allow @samp{#<@var{word} @var{arg}>} as a generic syntaxWith the handling of @emph{word} specified by an@code{eshell-special-alist}.@item In @code{eshell-veal-using-options}, allow a @code{:complete} tagIt would be used to provide completion rules for that command. Then themacro will automagically define the completion function.@item For @code{eshell-command-on-region}, apply redirections to the resultSo that @samp{+ > 'blah} would cause the result of the @code{+} (usinginput from the current region) to be inserting into the symbol@code{blah}.If an external command is being invoked, the input is sent as standardinput, as if a @samp{cat <region> |} had been invoked.If a Lisp command, or an alias, is invoked, then if the line has nonewline characters, it is divided by whitespace and passed as argumentsto the Lisp function. Otherwise, it is divided at the newlinecharacters. Thus, invoking @code{+} on a series of numbers will addthem; @code{min} would display the smallest figure, etc.@item Write @code{eshell-script-mode} as a minor modeIt would provide syntax, abbrev, highlighting and indenting support like@code{emacs-lisp-mode} and @code{shell-mode}.@item In the history mechanism, finish the @command{bash}-style supportThis means @samp{!n}, @samp{!#}, @samp{!:%}, and @samp{!:1-} as separatefrom @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 tomodify output with, and a target. Devise a syntax that works well withpipes, and can accommodate multiple functions (i.e., @samp{>'(upcaseregexp-quote)} or @samp{>'upcase}).@item Allow Eshell to read/write to/from standard input and outputThis 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} commandIt 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 doesnothing. Specifying redirection targets replaces (or adds) to the listcurrent being used.@item Have @command{jobs} print only the processes for the current shell@item How can Eshell learn if a background process has requested input?@item Support @samp{2>&1} and @samp{>&} and @samp{2>} and @samp{|&}The syntax table for parsing these should be customizable, such that theuser could change it to use rc syntax: @samp{>[2=1]}.@item Allow @samp{$_[-1]}, which would indicate the last element of the array@item Make @samp{$x[*]} equal to listing out the full contents of @samp{x}Return them as a list, so that @samp{$_[*]} is all the arguments of thelast command.@item Copy ANSI code handling from @file{term.el} into @file{em-term.el}Make it possible for the user to send char-by-char to the underlyingprocess. Ultimately, I should be able to move away from using term.elaltogether, since everything but the ANSI code handling is already partof Eshell. Then, things would work correctly on MS-Windows as well(which doesn't have @file{/bin/sh}, although @file{term.el} tries to useit).@item Make the shell spawning commands be visualThat is, make (@command{su}, @command{bash}, @command{telnet},@command{rlogin}, @command{rsh}, etc.) be part of@code{eshell-visual-commands}. The only exception is if the shell isbeing used to invoke a single command. Then, the behavior should bebased 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 openinga 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 onauto-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 mesh.cThis would run Emacs with the appropriate arguments to invoke Eshellonly. 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 `eshell-send-input'@item Make @kbd{/} electricSo that it automatically expands and corrects pathnames. Or makepathname completion for Pcomplete auto-expand @samp{/u/i/std<TAB>} to@samp{/usr/include/std<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 LispAdd 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 LispThis 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 rewritingThat is, @samp{find X | xargs Y} would be indicated using @samp{Y$@{find X@}}. Maybe @code{eshell-do-pipelines} could be changed toperform this on-thy-fly rewriting.@item Write an alias for @command{less} that brings up a @code{view-mode} bufferSuch that the user can press @key{SPC} and @key{DEL}, and then @key{q}to return to Eshell. It would be equivalent to:@samp{X > #<buffer Y>; view-buffer #<buffer Y>}.@item Make @code{eshell-mode} as much a full citizen as @code{shell-mode}Everywhere in Emacs where @code{shell-mode} is specially noticed, add@code{eshell-mode} there.@item Permit the umask to be selectively set on a @command{cp} target@item Problem using @kbd{M-x eshell} after using @code{eshell-command}If the first thing that I do after entering Emacs is to run@code{eshell-command} and invoke @command{ls}, and then use @kbd{M-xeshell}, it doesn't display anything.@item @kbd{M-RET} during a long command (using smart display) doesn't workSince 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 Key Index@unnumbered Key Index@printindex ky@bye@ignore arch-tag: 776409ba-cb15-42b9-b2b6-d2bdc7ebad01@end ignore