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