* net/tramp-sh.el (tramp-sh-handle-set-file-acl): Add argument to
[bpt/emacs.git] / doc / misc / eshell.texi
CommitLineData
4009494e
GM
1\input texinfo @c -*-texinfo-*-
2@c %**start of header
db78a8cb 3@setfilename ../../info/eshell
4009494e
GM
4@settitle Eshell: The Emacs Shell
5@synindex vr fn
6@c %**end of header
7
8@copying
9This manual is for Eshell, the Emacs shell.
10
f99f1641 11Copyright @copyright{} 1999--2012 Free Software Foundation, Inc.
4009494e
GM
12
13@quotation
14Permission is granted to copy, distribute and/or modify this document
6a2c4aec 15under the terms of the GNU Free Documentation License, Version 1.3 or
4009494e 16any later version published by the Free Software Foundation; with no
debf4439
GM
17Invariant Sections, with the Front-Cover texts being ``A GNU Manual'',
18and with the Back-Cover Texts as in (a) below. A copy of the license
19is included in the section entitled ``GNU Free Documentation License''.
4009494e 20
6f093307 21(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
6bf430d1 22modify this GNU manual.''
4009494e
GM
23@end quotation
24@end copying
25
0c973505 26@dircategory Emacs misc features
4009494e 27@direntry
62e034c2 28* Eshell: (eshell). A command shell implemented in Emacs Lisp.
4009494e
GM
29@end direntry
30
4009494e
GM
31@titlepage
32@sp 4
33@c The title is printed in a large font.
34@center @titlefont{User's Guide}
35@sp
36@center @titlefont{to}
37@sp
38@center @titlefont{Eshell: The Emacs Shell}
39@ignore
40@sp 2
41@center release 2.4
42@c -release-
43@end ignore
44@sp 3
45@center John Wiegley
46@c -date-
47
48@page
49@vskip 0pt plus 1filll
50@insertcopying
51@end titlepage
52
53@contents
54
55@c ================================================================
56@c The real text starts here
57@c ================================================================
58
59@ifnottex
563a450c 60@node Top
4009494e
GM
61@top Eshell
62
53964682 63Eshell is a shell-like command interpreter
4009494e
GM
64implemented in Emacs Lisp. It invokes no external processes except for
65those requested by the user. It is intended to be a functional
66replacement for command shells such as @command{bash}, @command{zsh},
67@command{rc}, or @command{4dos}; since Emacs itself is capable of
68handling the sort of tasks accomplished by those tools.
69@c This manual is updated to release 2.4 of Eshell.
5dc584b5
KB
70
71@insertcopying
4009494e
GM
72@end ifnottex
73
74@menu
75* What is Eshell?:: A brief introduction to the Emacs Shell.
76* Command basics:: The basics of command usage.
77* Commands::
78* Arguments::
79* Input/Output::
80* Process control::
81* Extension modules::
82* Extras and Goodies::
83* Bugs and ideas:: Known problems, and future ideas.
84* GNU Free Documentation License:: The license for this documentation.
85* Concept Index::
86* Function and Variable Index::
87* Key Index::
88@end menu
89
90@node What is Eshell?
91@chapter What is Eshell?
92@cindex what is Eshell?
93@cindex Eshell, what it is
94
95Eshell is a @dfn{command shell} written in Emacs Lisp. Everything it
44e97401 96does, it uses Emacs's facilities to do. This means that Eshell is as
4009494e
GM
97portable as Emacs itself. It also means that cooperation with Lisp code
98is natural and seamless.
99
100What is a command shell? To properly understand the role of a shell,
101it's necessary to visualize what a computer does for you. Basically, a
102computer is a tool; in order to use that tool, you must tell it what to
103do---or give it ``commands.'' These commands take many forms, such as
104clicking with a mouse on certain parts of the screen. But that is only
105one form of command input.
106
107By far the most versatile way to express what you want the computer to
108do is by using an abbreviated language called @dfn{script}. In
109script, instead of telling the computer, ``list my files, please'',
110one writes a standard abbreviated command word---@samp{ls}. Typing
111@samp{ls} in a command shell is a script way of telling the computer
112to list your files.@footnote{This is comparable to viewing the
113contents of a folder using a graphical display.}
114
115The real flexibility of this approach is apparent only when you realize
116that there are many, many different ways to list files. Perhaps you
117want them sorted by name, sorted by date, in reverse order, or grouped
118by type. Most graphical browsers have simple ways to express this. But
119what about showing only a few files, or only files that meet a certain
120criteria? In very complex and specific situations, the request becomes
121too difficult to express using a mouse or pointing device. It is just
122these kinds of requests that are easily solved using a command shell.
123
124For example, what if you want to list every Word file on your hard
125drive, larger than 100 kilobytes in size, and which hasn't been looked
126at in over six months? That is a good candidate list for deletion, when
127you go to clean up your hard drive. But have you ever tried asking your
128computer for such a list? There is no way to do it! At least, not
129without using a command shell.
130
131The role of a command shell is to give you more control over what your
132computer does for you. Not everyone needs this amount of control, and
133it does come at a cost: Learning the necessary script commands to
134express what you want done. A complicated query, such as the example
135above, takes time to learn. But if you find yourself using your
136computer frequently enough, it is more than worthwhile in the long run.
137Any tool you use often deserves the time spent learning to master it.
138@footnote{For the understandably curious, here is what that command
139looks like: But don't let it fool you; once you know what's going on,
140it's easier than it looks: @code{ls -lt **/*.doc(Lk+50aM+5)}.}
141
142@menu
143* Contributors to Eshell:: People who have helped out!
144@end menu
145
146@node Contributors to Eshell
147@section Contributors to Eshell
148@cindex contributors
149@cindex authors
150
151Contributions to Eshell are welcome. I have limited time to work on
152this project, but I will gladly add any code you contribute to me to
153this package.
154
155The following persons have made contributions to Eshell.
156
157@itemize @bullet
158@item
159Eli Zaretskii made it possible for Eshell to run without requiring
160asynchronous subprocess support. This is important for MS-DOS, which
161does not have such support.@refill
162
163@item
164Miles Bader contributed many fixes during the port to Emacs 21.@refill
165
166@item
167Stefan Monnier fixed the things which bothered him, which of course made
168things better for all.@refill
169
170@item
171Gerd Moellmann also helped to contribute bug fixes during the initial
172integration with Emacs 21.@refill
173
174@item
175Alex Schroeder contributed code for interactively querying the user
176before overwriting files.@refill
177
178@item
179Sudish Joseph helped with some XEmacs compatibility issues.@refill
180@end itemize
181
182Apart from these, a lot of people have sent suggestions, ideas,
183requests, bug reports and encouragement. Thanks a lot! Without you
184there would be no new releases of Eshell.
185
186@node Command basics
187@chapter Basic overview
188
189A command shell is a means of entering verbally-formed commands. This
190is really all that it does, and every feature described in this manual
191is a means to that end. Therefore, it's important to take firm hold on
192exactly what a command is, and how it fits in the overall picture of
193things.
194
195@menu
196* Commands verbs:: Commands always begin with a verb.
197* Command arguments:: Some verbs require arguments.
198@end menu
199
200@node Commands verbs
201@section Commands verbs
202
203Commands are expressed using @dfn{script}, a special shorthand language
204computers can understand with no trouble. Script is an extremely simple
205language; oddly enough, this is what makes it look so complicated!
206Whereas normal languages use a variety of embellishments, the form of a
207script command is always:
208
209@example
210@var{verb} [@var{arguments}]
211@end example
212
213The verb expresses what you want your computer to do. There are a fixed
214number of verbs, although this number is usually quite large. On the
215author's computer, it reaches almost 1400 in number. But of course,
216only a handful of these are really necessary.
217
218Sometimes, the verb is all that's written. A verb is always a single
219word, usually related to the task it performs. @command{reboot} is a
220good example. Entering that on GNU/Linux will reboot the
221computer---assuming you have sufficient privileges.
222
223Other verbs require more information. These are usually very capable
224verbs, and must be told specifically what to do. The extra information
225is given in the form of @dfn{arguments}. For example, the
226@command{echo} verb prints back whatever arguments you type. It
227requires these arguments to know what to echo. A proper use of
228@command{echo} looks like this:
229
230@example
231echo This is an example of using echo!
232@end example
233
234This script command causes the computer to echo back: ``This is an
235example of using echo!''
236
237Although command verbs are always simple words, like @command{reboot} or
238@command{echo}, arguments may have a wide variety of forms. There are
239textual arguments, numerical arguments---even Lisp arguments.
240Distinguishing these different types of arguments requires special
241typing, for the computer to know exactly what you mean.
242
243@node Command arguments
244@section Command arguments
245
246Eshell recognizes several different kinds of command arguments:
247
248@enumerate
249@item Strings (also called textual arguments)
250@item Numbers (floating point or integer)
251@item Lisp lists
252@item Lisp symbols
253@item Emacs buffers
254@item Emacs process handles
255@end enumerate
256
257Most users need to worry only about the first two. The third, Lisp lists,
258occur very frequently, but almost always behind the scenes.
259
260Strings are the most common type of argument, and consist of nearly any
261character. Special characters---those used by Eshell
262specifically---must be preceded by a backslash (@samp{\}). When in doubt, it
263is safe to add backslashes anywhere and everywhere.
264
265Here is a more complicated @command{echo} example:
266
267@example
268echo A\ Multi-word\ Argument\ With\ A\ \$\ dollar
269@end example
270
271Beyond this, things get a bit more complicated. While not beyond the
272reach of someone wishing to learn, it is definitely beyond the scope of
273this manual to present it all in a simplistic manner. Get comfortable
274with Eshell as a basic command invocation tool, and learn more about the
275commands on your system; then come back when it all sits more familiarly
276on your mind. Have fun!
277
278@node Commands
279@chapter Commands
280
281@menu
282* Invocation::
283* Completion::
284* Aliases::
285* History::
286* Scripts::
287* Built-ins::
288@end menu
289
290Essentially, a command shell is all about invoking commands---and
291everything that entails. So understanding how Eshell invokes commands
292is the key to comprehending how it all works.
293
294@node Invocation
295@section Invocation
296
297Unlike regular system shells, Eshell never invokes kernel functions
298directly, such as @code{exec(3)}. Instead, it uses the Lisp functions
299available in the Emacs Lisp library. It does this by transforming the
300command you specify into a callable Lisp form.@footnote{To see the Lisp
301form that will be invoked, type: @samp{eshell-parse-command "echo
302hello"}}
303
304This transformation, from the string of text typed at the command
305prompt, to the ultimate invocation of either a Lisp function or external
306command, follows these steps:
307
308@enumerate
309@item Parse the command string into separate arguments.
310@item
311@end enumerate
312
313@node Completion
314@section Completion
315
316@node Aliases
317@section Aliases
318
319@node History
320@section History
321
322Eshell knows a few built-in variables:
323
324@table @code
325
326@item $+
327@vindex $+
328This variable always contains the current working directory.
329
330@item $-
331@vindex $-
332This variable always contains the previous working directory (the
333current working directory from before the last @code{cd} command).
334
020335df
MA
335@item $_
336@vindex $_
337It refers to the last argument of the last command.
338
339@item $$
340@vindex $$
341This is the result of the last command. In case of an external
342command, it is @code{t} or @code{nil}.
343
344@item $?
345@vindex $?
346This variable contains the exit code of the last command (0 or 1 for
347Lisp functions, based on successful completion).
348
4009494e
GM
349@end table
350
351@node Scripts
352@section Scripts
353
354
355@node Built-ins
356@section Built-in commands
357
020335df
MA
358Several commands are built-in in Eshell. In order to call the
359external variant of a built-in command @code{foo}, you could call
360@code{*foo}. Usually, this should not be necessary. You can check
361what will be applied by the @code{which} command:
362
363@example
364~ $ which ls
365eshell/ls is a compiled Lisp function in `em-ls.el'
366~ $ which *ls
367/bin/ls
368@end example
369
9841cb4f
MA
370If you want to discard a given built-in command, you could declare an
371alias, @ref{Aliases}. Eample:
372
373@example
374~ $ which sudo
375eshell/sudo is a compiled Lisp function in `em-unix.el'
376~ $ alias sudo '*sudo $*'
377~ $ which sudo
378sudo is an alias, defined as "*sudo $*"
379@end example
380
91af3942 381Some of the built-in commands have a special behavior in Eshell:
4009494e
GM
382
383@table @code
384
385@item cd
386@findex cd
387This command changes the current working directory. Usually, it is
388invoked as @samp{cd foo} where @file{foo} is the new working
389directory. But @code{cd} knows about a few special arguments:
390
391When it receives no argument at all, it changes to the home directory.
392
393Giving the command @samp{cd -} changes back to the previous working
394directory (this is the same as @samp{cd $-}).
395
396The command @samp{cd =} shows the directory stack. Each line is
397numbered.
398
399With @samp{cd =foo}, Eshell searches the directory stack for a
400directory matching the regular expression @samp{foo} and changes to
401that directory.
402
403With @samp{cd -42}, you can access the directory stack by number.
404
020335df
MA
405@item history
406@findex history
407The @samp{history} command shows all commands kept in the history ring
408as numbered list. If the history ring contains
409@code{eshell-history-size} commands, those numbers change after every
410command invocation, therefore the @samp{history} command shall be
411applied before using the expansion mechanism with history numbers.
412
413The n-th entry of the history ring can be applied with the @samp{!n}
414command. If @code{n} is negative, the entry is counted from the end
415of the history ring.
416
417@samp{!foo} expands to the last command beginning with @code{foo}, and
418@samp{!?foo} to the last command containing @code{foo}. The n-th
419argument of the last command beginning with @code{foo} is accessible
420by @code{!foo:n}.
421
422@item su
423@findex su
424@itemx sudo
425@findex sudo
426@code{su} and @code{sudo} work as expected: they apply the following
427commands (@code{su}), or the command being an argument (@code{sudo})
428under the permissions of somebody else.
429
430This does not work only on
431the local host, but even on a remote one, when
432@code{default-directory} is a remote file name. The necessary
433proxy configuration of Tramp is performed
434@ifinfo
435automatically, @ref{Multi-hops, , , tramp}.
436@end ifinfo
437@ifnotinfo
438automatically.
439@end ifnotinfo
440Example:
441
442@example
443~ $ cd /ssh:otherhost:/etc
444/ssh:user@@otherhost:/etc $ sudo find-file shadow
445@end example
446
4009494e
GM
447@end table
448
449
450@node Arguments
451@chapter Arguments
452
453@menu
454* The Parser::
455* Variables::
456* Substitution::
457* Globbing::
458* Predicates::
459@end menu
460
461@node The Parser
462@section The Parser
463
464@node Variables
465@section Variables
466
467@node Substitution
468@section Substitution
469
470@node Globbing
471@section Globbing
472
473@node Predicates
474@section Predicates
475
476
477@node Input/Output
478@chapter Input/Output
479
480@node Process control
481@chapter Process control
482
483
484@node Extension modules
485@chapter Extension modules
486
487@menu
488* Writing a module::
489* Module testing::
490* Directory handling::
491* Key rebinding::
492* Smart scrolling::
493* Terminal emulation::
494* Built-in UNIX commands::
495@end menu
496
497@node Writing a module
498@section Writing a module
499
500@node Module testing
501@section Module testing
502
503@node Directory handling
504@section Directory handling
505
506@node Key rebinding
507@section Key rebinding
508
509@node Smart scrolling
510@section Smart scrolling
511
512@node Terminal emulation
513@section Terminal emulation
514
515@node Built-in UNIX commands
516@section Built-in UNIX commands
517
518
519@node Extras and Goodies
520@chapter Extras and Goodies
521
522@node Bugs and ideas
523@chapter Bugs and ideas
524@cindex reporting bugs and ideas
525@cindex bugs, how to report them
526@cindex author, how to reach
527@cindex email to the author
528@cindex FAQ
529@cindex problems, list of common
530
531If you find a bug or misfeature, don't hesitate to let me know! Send
532email to @email{johnw@@gnu.org}. Feature requests should also be sent
533there. I prefer discussing one thing at a time. If you find several
534unrelated bugs, please report them separately.
535
536If you have ideas for improvements, or if you have written some
537extensions to this package, I would like to hear from you. I hope you
538find this package useful!
539
540@menu
541* Known problems::
542@end menu
543
544@node Known problems
545@section Known problems
546@cindex known bugs
547@cindex bugs, known
548
549Below is complete list of known problems with Eshell version 2.4.2,
550which is the version included with Emacs 22.
551
552@table @asis
553@item Documentation incomplete
554
555@item Differentiate between aliases and functions
556
557Allow for a bash-compatible syntax, such as:
558
559@example
560alias arg=blah
561function arg () @{ blah $* @}
562@end example
563
564@item @samp{for i in 1 2 3 @{ grep -q a b && *echo has it @} | wc -l} outputs result after prompt
565
566In fact, piping to a process from a looping construct doesn't work in
567general. If I change the call to @code{eshell-copy-handles} in
568@code{eshell-rewrite-for-command} to use @code{eshell-protect}, it seems
569to work, but the output occurs after the prompt is displayed. The whole
570structured command thing is too complicated at present.
571
572@item Error with @command{bc} in @code{eshell-test}
573
574On some XEmacs system, the subprocess interaction test fails
575inexplicably, although @command{bc} works fine at the command prompt.
576
577@item Eshell does not delete @file{*Help*} buffers in XEmacs 21.1.8+
578
579In XEmacs 21.1.8, the @file{*Help*} buffer has been renamed such that
580multiple instances of the @file{*Help*} buffer can exist.
581
582@item Pcomplete sometimes gets stuck
583
584You press @key{TAB}, but no completions appear, even though the
585directory has matching files. This behavior is rare.
586
587@item @samp{grep python $<rpm -qa>} doesn't work, but using @samp{*grep} does
588
589This happens because the @code{grep} Lisp function returns immediately,
590and then the asynchronous @command{grep} process expects to examine the
591temporary file, which has since been deleted.
592
593@item Problem with C-r repeating text
594
595If the text @emph{before point} reads "./run", and you type @kbd{C-r r u
596n}, it will repeat the line for every character typed.
597
598@item Backspace doesn't scroll back after continuing (in smart mode)
599
600Hitting space during a process invocation, such as @command{make}, will
601cause it to track the bottom of the output; but backspace no longer
602scrolls back.
603
604@item It's not possible to fully @code{unload-feature} Eshell
605
606@item Menu support was removed, but never put back
607
608@item Using C-p and C-n with rebind gets into a locked state
609
fa463103 610This happened a few times in Emacs 21, but has been irreproducible
4009494e
GM
611since.
612
613@item If an interactive process is currently running, @kbd{M-!} doesn't work
614
615@item Use a timer instead of @code{sleep-for} when killing child processes
616
617@item Piping to a Lisp function is not supported
618
619Make it so that the Lisp command on the right of the pipe is repeatedly
620called with the input strings as arguments. This will require changing
621@code{eshell-do-pipeline} to handle non-process targets.
622
623@item Input redirection is not supported
624
625See the above entry.
626
627@item Problem running @command{less} without arguments on Windows
628
629The result in the Eshell buffer is:
630
631@example
632Spawning child process: invalid argument
633@end example
634
635Also a new @command{less} buffer was created with nothing in it@dots{}
636(presumably this holds the output of @command{less}).
637
638If @command{less.exe} is invoked from the Eshell command line, the
639expected output is written to the buffer.
640
641Note that this happens on NT-Emacs 20.6.1 on Windows 2000. The term.el
642package and the supplied shell both use the @command{cmdproxy} program
643for running shells.
644
645@item Implement @samp{-r}, @samp{-n} and @samp{-s} switches for @command{cp}
646
647@item Make @kbd{M-5 M-x eshell} switch to ``*eshell<5>*'', creating if need be
648
649@item @samp{mv @var{dir} @var{file}.tar} does not remove directories
650
651This is because the tar option --remove-files doesn't do so. Should it
652be Eshell's job?
653
654@item Bind @code{standard-output} and @code{standard-error}
655
656This would be so that if a Lisp function calls @code{print}, everything
657will happen as it should (albeit slowly).
658
659@item When an extension module fails to load, @samp{cd /} gives a Lisp error
660
661@item If a globbing pattern returns one match, should it be a list?
662
663@item Make sure syntax table is correct in Eshell mode
664
665So that @kbd{M-DEL} acts in a predictable manner, etc.
666
667@item Allow all Eshell buffers to share the same history and list-dir
668
669@item There is a problem with script commands that output to @file{/dev/null}
670
671If a script file, somewhere in the middle, uses @samp{> /dev/null},
672output from all subsequent commands is swallowed.
673
674@item Split up parsing of text after @samp{$} in @file{esh-var.el}
675
676Make it similar to the way that @file{esh-arg.el} is structured.
677Then add parsing of @samp{$[?\n]}.
678
679@item After pressing @kbd{M-RET}, redisplay before running the next command
680
681@item Argument predicates and modifiers should work anywhere in a path
682
683@example
684/usr/local/src/editors/vim $ vi **/CVS(/)/Root(.)
685Invalid regexp: "Unmatched ( or \\("
686@end example
687
688With @command{zsh}, the glob above expands to all files named
689@file{Root} in directories named @file{CVS}.
690
691@item Typing @samp{echo $@{locate locate@}/bin<TAB>} results in a Lisp error
692
693Perhaps it should interpolate all permutations, and make that the
694globbing result, since otherwise hitting return here will result in
695``(list of filenames)/bin'', which is never valuable. Thus, one could
696@command{cat} only C backup files by using @samp{ls $@{identity *.c@}~}.
697In that case, having an alias command name @command{glob} for
698@command{identity} would be useful.
699
700@item Once symbolic mode is supported for @command{umask}, implement @command{chmod} in Lisp
701
702@item Create @code{eshell-expand-file-name}
703
704This would use a data table to transform things such as @samp{~+},
705@samp{...}, etc.
706
707@item Abstract @file{em-smart.el} into @file{smart-scroll.el}
708
709It only really needs: to be hooked onto the output filter and the
710pre-command hook, and to have the input-end and input-start markers.
711And to know whether the last output group was ``successful.''
712
713@item Allow for fully persisting the state of Eshell
714
715This would include: variables, history, buffer, input, dir stack, etc.
716
717@item Implement D as an argument predicate
718
719It means that files beginning with a dot should be included in the
720glob match.
721
722@item A comma in a predicate list should mean OR
723
724At the moment, this is not supported.
725
726@item Error if a glob doesn't expand due to a predicate
727
728An error should be generated only if @code{eshell-error-if-no-glob} is
729non-@code{nil}.
730
731@item @samp{(+ RET SPC TAB} does not cause @code{indent-according-to-mode} to occur
732
733@item Create @code{eshell-auto-accumulate-list}
734
735This is a list of commands for which, if the user presses @kbd{RET}, the
736text is staged as the next Eshell command, rather than being sent to the
737current interactive process.
738
739@item Display file and line number if an error occurs in a script
740
741@item @command{wait} doesn't work with process ids at the moment
742
743@item Enable the direct-to-process input code in @file{em-term.el}
744
745@item Problem with repeating @samp{echo $@{find /tmp@}}
746
747With smart display active, if @kbd{RET} is held down, after a while it
748can't keep up anymore and starts outputting blank lines. It only
749happens if an asynchronous process is involved@dots{}
750
751I think the problem is that @code{eshell-send-input} is resetting the
752input target location, so that if the asynchronous process is not done
753by the time the next @kbd{RET} is received, the input processor thinks
754that the input is meant for the process; which, when smart display is
755enabled, will be the text of the last command line! That is a bug in
756itself.
757
758In holding down @kbd{RET} while an asynchronous process is running,
759there will be a point in between termination of the process, and the
760running of @code{eshell-post-command-hook}, which would cause
761@code{eshell-send-input} to call @code{eshell-copy-old-input}, and then
762process that text as a command to be run after the process. Perhaps
763there should be a way of killing pending input between the death of the
764process, and the @code{post-command-hook}.
765
766@item Allow for a more aggressive smart display mode
767
768Perhaps toggled by a command, that makes each output block a smart
769display block.
770
771@item Create more meta variables
772
773@table @samp
774@item $!
775The reason for the failure of the last disk command, or the text of the
776last Lisp error.
777
778@item $=
779A special associate array, which can take references of the form
780@samp{$=[REGEXP]}. It indexes into the directory ring.
781@end table
782
783@item Eshell scripts can't execute in the background
784
1df7defd 785@item Support zsh's ``Parameter Expansion'' syntax, i.e., @samp{$@{@var{name}:-@var{val}@}}
4009494e
GM
786
787@item Write an @command{info} alias that can take arguments
788
789So that the user can enter @samp{info chmod}, for example.
790
791@item Create a mode @code{eshell-browse}
792
793It would treat the Eshell buffer as a outline. Collapsing the outline
794hides all of the output text. Collapsing again would show only the
795first command run in each directory
796
797@item Allow other revisions of a file to be referenced using @samp{file@{rev@}}
798
799This would be expanded by @code{eshell-expand-file-name} (see above).
800
801@item Print ``You have new mail'' when the ``Mail'' icon is turned on
802
803@item Implement @kbd{M-|} for Eshell
804
805@item Implement input redirection
806
807If it's a Lisp function, input redirection implies @command{xargs} (in a
808way@dots{}). If input redirection is added, also update the
809@code{file-name-quote-list}, and the delimiter list.
810
811@item Allow @samp{#<@var{word} @var{arg}>} as a generic syntax
812
813With the handling of @emph{word} specified by an
814@code{eshell-special-alist}.
815
0c7efc08 816@item In @code{eshell-eval-using-options}, allow a @code{:complete} tag
4009494e
GM
817
818It would be used to provide completion rules for that command. Then the
819macro will automagically define the completion function.
820
821@item For @code{eshell-command-on-region}, apply redirections to the result
822
823So that @samp{+ > 'blah} would cause the result of the @code{+} (using
824input from the current region) to be inserting into the symbol
825@code{blah}.
826
827If an external command is being invoked, the input is sent as standard
828input, as if a @samp{cat <region> |} had been invoked.
829
830If a Lisp command, or an alias, is invoked, then if the line has no
831newline characters, it is divided by whitespace and passed as arguments
832to the Lisp function. Otherwise, it is divided at the newline
833characters. Thus, invoking @code{+} on a series of numbers will add
834them; @code{min} would display the smallest figure, etc.
835
836@item Write @code{eshell-script-mode} as a minor mode
837
838It would provide syntax, abbrev, highlighting and indenting support like
839@code{emacs-lisp-mode} and @code{shell-mode}.
840
841@item In the history mechanism, finish the @command{bash}-style support
842
843This means @samp{!n}, @samp{!#}, @samp{!:%}, and @samp{!:1-} as separate
844from @samp{!:1*}.
845
846@item Support the -n command line option for @command{history}
847
848@item Implement @command{fc} in Lisp
849
850@item Specifying a frame as a redirection target should imply the currently active window's buffer
851
852@item Implement @samp{>@var{func-or-func-list}}
853
854This would allow for an ``output translators'', that take a function to
855modify output with, and a target. Devise a syntax that works well with
856pipes, and can accommodate multiple functions (i.e., @samp{>'(upcase
857regexp-quote)} or @samp{>'upcase}).
858
859@item Allow Eshell to read/write to/from standard input and output
860
861This would be optional, rather than always using the Eshell buffer.
862This would allow it to be run from the command line (perhaps).
863
864@item Write a @command{help} command
865
866It would call subcommands with @option{--help}, or @option{-h} or
867@option{/?}, as appropriate.
868
869@item Implement @command{stty} in Lisp
870
1df7defd 871@item Support @command{rc}'s matching operator, e.g., @samp{~ (@var{list}) @var{regexp}}
4009494e
GM
872
873@item Implement @command{bg} and @command{fg} as editors of @code{eshell-process-list}
874
875Using @command{bg} on a process that is already in the background does
876nothing. Specifying redirection targets replaces (or adds) to the list
877current being used.
878
879@item Have @command{jobs} print only the processes for the current shell
880
881@item How can Eshell learn if a background process has requested input?
882
883@item Support @samp{2>&1} and @samp{>&} and @samp{2>} and @samp{|&}
884
885The syntax table for parsing these should be customizable, such that the
886user could change it to use rc syntax: @samp{>[2=1]}.
887
888@item Allow @samp{$_[-1]}, which would indicate the last element of the array
889
890@item Make @samp{$x[*]} equal to listing out the full contents of @samp{x}
891
892Return them as a list, so that @samp{$_[*]} is all the arguments of the
893last command.
894
895@item Copy ANSI code handling from @file{term.el} into @file{em-term.el}
896
897Make it possible for the user to send char-by-char to the underlying
898process. Ultimately, I should be able to move away from using term.el
899altogether, since everything but the ANSI code handling is already part
900of Eshell. Then, things would work correctly on MS-Windows as well
901(which doesn't have @file{/bin/sh}, although @file{term.el} tries to use
902it).
903
904@item Make the shell spawning commands be visual
905
906That is, make (@command{su}, @command{bash}, @command{telnet},
907@command{rlogin}, @command{rsh}, etc.) be part of
908@code{eshell-visual-commands}. The only exception is if the shell is
909being used to invoke a single command. Then, the behavior should be
910based on what that command is.
911
912@item Create a smart viewing command named @command{open}
913
914This would search for some way to open its argument (similar to opening
915a file in the Windows Explorer).
916
917@item Alias @command{read} to be the same as @command{open}, only read-only
918
919@item Write a @command{tail} command which uses @code{view-file}
920
921It would move point to the end of the buffer, and then turns on
922auto-revert mode in that buffer at frequent intervals---and a
923@command{head} alias which assumes an upper limit of
924@code{eshell-maximum-line-length} characters per line.
925
926@item Make @command{dgrep} load @code{dired}, mark everything, then invoke @code{dired-do-search}
927
928@item Write mesh.c
929
930This would run Emacs with the appropriate arguments to invoke Eshell
931only. That way, it could be listed as a login shell.
932
933@item Use an intangible @code{PS2} string for multi-line input prompts
934
935@item Auto-detect when a command is visual, by checking @code{TERMCAP} usage
936
937@item The first keypress after @kbd{M-x watson} triggers `eshell-send-input'
938
939@item Make @kbd{/} electric
940
941So that it automatically expands and corrects pathnames. Or make
942pathname completion for Pcomplete auto-expand @samp{/u/i/std<TAB>} to
943@samp{/usr/include/std<TAB>}.
944
945@item Write the @command{pushd} stack to disk along with @code{last-dir-ring}
946
947@item Add options to @code{eshell/cat} which would allow it to sort and uniq
948
949@item Implement @command{wc} in Lisp
950
951Add support for counting sentences, paragraphs, pages, etc.
952
953@item Once piping is added, implement @command{sort} and @command{uniq} in Lisp
954
955@item Implement @command{touch} in Lisp
956
957@item Implement @command{comm} in Lisp
958
959@item Implement an @command{epatch} command in Lisp
960
961This would call @code{ediff-patch-file}, or @code{ediff-patch-buffer},
962depending on its argument.
963
964@item Have an option such that @samp{ls -l} generates a dired buffer
965
966@item Write a version of @command{xargs} based on command rewriting
967
968That is, @samp{find X | xargs Y} would be indicated using @samp{Y
969$@{find X@}}. Maybe @code{eshell-do-pipelines} could be changed to
970perform this on-thy-fly rewriting.
971
972@item Write an alias for @command{less} that brings up a @code{view-mode} buffer
973
974Such that the user can press @key{SPC} and @key{DEL}, and then @key{q}
975to return to Eshell. It would be equivalent to:
976@samp{X > #<buffer Y>; view-buffer #<buffer Y>}.
977
978@item Make @code{eshell-mode} as much a full citizen as @code{shell-mode}
979
980Everywhere in Emacs where @code{shell-mode} is specially noticed, add
981@code{eshell-mode} there.
982
983@item Permit the umask to be selectively set on a @command{cp} target
984
985@item Problem using @kbd{M-x eshell} after using @code{eshell-command}
986
987If the first thing that I do after entering Emacs is to run
988@code{eshell-command} and invoke @command{ls}, and then use @kbd{M-x
989eshell}, it doesn't display anything.
990
991@item @kbd{M-RET} during a long command (using smart display) doesn't work
992
993Since it keeps the cursor up where the command was invoked.
994
995@end table
996
997@node GNU Free Documentation License
998@appendix GNU Free Documentation License
999@include doclicense.texi
1000
1001@node Concept Index
1002@unnumbered Concept Index
1003
1004@printindex cp
1005
1006@node Function and Variable Index
1007@unnumbered Function and Variable Index
1008
1009@printindex fn
1010
1011@node Key Index
1012@unnumbered Key Index
1013
1014@printindex ky
1015@bye