/
contrib.yo
2322 lines (2034 loc) · 97.3 KB
/
contrib.yo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
texinode(User Contributions)()(Zftp Function System)(Top)
chapter(User Contributions)
cindex(user contributions)
sect(Description)
The Zsh source distribution includes a number of items contributed by the
user community. These are not inherently a part of the shell, and some
may not be available in every zsh installation. The most significant of
these are documented here. For documentation on other contributed items
such as shell functions, look for comments in the function source files.
startmenu()
menu(Utilities)
menu(Prompt Themes)
menu(ZLE Functions)
menu(Exception Handling)
menu(MIME Functions)
menu(Mathematical Functions)
menu(User Configuration Functions)
menu(Other Functions)
endmenu()
texinode(Utilities)(Prompt Themes)()(User Contributions)
sect(Utilities)
subsect(Accessing On-Line Help)
cindex(helpfiles utility)
The key sequence tt(ESC h) is normally bound by ZLE to execute the
tt(run-help) widget (see
ifzman(zmanref(zshzle))\
ifnzman(noderef(Zsh Line Editor))\
). This invokes the tt(run-help) command with the command word from the
current input line as its argument. By default, tt(run-help) is an alias
for the tt(man) command, so this often fails when the command word is a
shell builtin or a user-defined function. By redefining the tt(run-help)
alias, one can improve the on-line help provided by the shell.
The tt(helpfiles) utility, found in the tt(Util) directory of the
distribution, is a Perl program that can be used to process the zsh manual
to produce a separate help file for each shell builtin and for many other
shell features as well. The autoloadable tt(run-help) function, found in
tt(Functions/Misc), searches for these helpfiles and performs several
other tests to produce the most complete help possible for the command.
There may already be a directory of help files on your system; look in
tt(/usr/share/zsh) or tt(/usr/local/share/zsh) and subdirectories below
those, or ask your system administrator.
To create your own help files with tt(helpfiles), choose or create a
directory where the individual command help files will reside. For
example, you might choose tt(~/zsh_help). If you unpacked the zsh
distribution in your home directory, you would use the commands:
example(mkdir ~/zsh_help
cd ~/zsh_help
man zshall | colcrt - | \
perl ~/zsh-version()/Util/helpfiles)
findex(run-help, use of)
Next, to use the tt(run-help) function, you need to add lines something
like the following to your tt(.zshrc) or equivalent startup file:
example(unalias run-help
autoload run-help
HELPDIR=~/zsh_help)
vindex(HELPDIR)
The tt(HELPDIR) parameter tells tt(run-help) where to look for the help
files. If your system already has a help file directory installed, set
tt(HELPDIR) to the path of that directory instead.
Note that in order for `tt(autoload run-help)' to work, the tt(run-help)
file must be in one of the directories named in your tt(fpath) array (see
ifzman(zmanref(zshparam))\
ifnzman(noderef(Parameters Used By The Shell))\
). This should already be the case if you have a standard zsh
installation; if it is not, copy tt(Functions/Misc/run-help) to an
appropriate directory.
subsect(Recompiling Functions)
cindex(functions, recompiling)
cindex(zrecompile utility)
If you frequently edit your zsh functions, or periodically update your zsh
installation to track the latest developments, you may find that function
digests compiled with the tt(zcompile) builtin are frequently out of date
with respect to the function source files. This is not usually a problem,
because zsh always looks for the newest file when loading a function, but
it may cause slower shell startup and function loading. Also, if a digest
file is explicitly used as an element of tt(fpath), zsh won't check whether
any of its source files has changed.
The tt(zrecompile) autoloadable function, found in tt(Functions/Misc), can
be used to keep function digests up to date.
startitem()
findex(zrecompile)
xitem(tt(zrecompile) [ tt(-qt) ] [ var(name) ... ])
item(tt(zrecompile) [ tt(-qt) ] tt(-p) var(args) [ tt(-)tt(-) var(args) ... ])(
This tries to find tt(*.zwc) files and automatically re-compile them if at
least one of the original files is newer than the compiled file. This
works only if the names stored in the compiled files are full paths or are
relative to the directory that contains the tt(.zwc) file.
In the first form, each var(name) is the name of a compiled file or a
directory containing tt(*.zwc) files that should be checked. If no
arguments are given, the directories and tt(*.zwc) files in tt(fpath) are
used.
When tt(-t) is given, no compilation is performed, but a return status of
zero (true) is set if there are files that need to be re-compiled and
non-zero (false) otherwise. The tt(-q) option quiets the chatty output
that describes what tt(zrecompile) is doing.
Without the tt(-t) option, the return status is zero if all files that
needed re-compilation could be compiled and non-zero if compilation for at
least one of the files failed.
If the tt(-p) option is given, the var(args) are interpreted as one
or more sets of arguments for tt(zcompile), separated by `tt(-)tt(-)'.
For example:
example(zrecompile -p \
-R ~/.zshrc -- \
-M ~/.zcompdump -- \
~/zsh/comp.zwc ~/zsh/Completion/*/_*)
This compiles tt(~/.zshrc) into tt(~/.zshrc.zwc) if that doesn't exist or
if it is older than tt(~/.zshrc). The compiled file will be marked for
reading instead of mapping. The same is done for tt(~/.zcompdump) and
tt(~/.zcompdump.zwc), but this compiled file is marked for mapping. The
last line re-creates the file tt(~/zsh/comp.zwc) if any of the files
matching the given pattern is newer than it.
Without the tt(-p) option, tt(zrecompile) does not create function digests
that do not already exist, nor does it add new functions to the digest.
)
enditem()
The following shell loop is an example of a method for creating function
digests for all functions in your tt(fpath), assuming that you have write
permission to the directories:
example(for ((i=1; i <= $#fpath; ++i)); do
dir=$fpath[i]
zwc=${dir:t}.zwc
if [[ $dir == (.|..) || $dir == (.|..)/* ]]; then
continue
fi
files=($dir/*(N-.))
if [[ -w $dir:h && -n $files ]]; then
files=(${${(M)files%/*/*}#/})
if ( cd $dir:h &&
zrecompile -p -U -z $zwc $files ); then
fpath[i]=$fpath[i].zwc
fi
fi
done)
The tt(-U) and tt(-z) options are appropriate for functions in the default
zsh installation tt(fpath); you may need to use different options for your
personal function directories.
Once the digests have been created and your tt(fpath) modified to refer to
them, you can keep them up to date by running tt(zrecompile) with no
arguments.
subsect(Keyboard Definition)
cindex(keyboard definition)
findex(zkbd)
The large number of possible combinations of keyboards, workstations,
terminals, emulators, and window systems makes it impossible for zsh to
have built-in key bindings for every situation. The tt(zkbd) utility,
found in Functions/Misc, can help you quickly create key bindings for your
configuration.
Run tt(zkbd) either as an autoloaded function, or as a shell script:
example(zsh -f ~/zsh-version()/Functions/Misc/zkbd)
When you run tt(zkbd), it first asks you to enter your terminal type; if
the default it offers is correct, just press return. It then asks you to
press a number of different keys to determine characteristics of your
keyboard and terminal; tt(zkbd) warns you if it finds anything out of the
ordinary, such as a Delete key that sends neither tt(^H) nor tt(^?).
The keystrokes read by tt(zkbd) are recorded as a definition for an
associative array named tt(key), written to a file in the subdirectory
tt(.zkbd) within either your tt(HOME) or tt(ZDOTDIR) directory. The name
of the file is composed from the tt(TERM), tt(VENDOR) and tt(OSTYPE)
parameters, joined by hyphens.
You may read this file into your tt(.zshrc) or another startup file with
the `tt(source)' or `tt(.)' commands, then reference the tt(key) parameter
in bindkey commands, like this:
example(source ${ZDOTDIR:-$HOME}/.zkbd/$TERM-$VENDOR-$OSTYPE
[[ -n ${key[Left]} ]] && bindkey "${key[Left]}" backward-char
[[ -n ${key[Right]} ]] && bindkey "${key[Right]}" forward-char
# etc.)
Note that in order for `tt(autoload zkbd)' to work, the tt(zkdb) file must
be in one of the directories named in your tt(fpath) array (see
ifzman(zmanref(zshparam))\
ifnzman(noderef(Parameters Used By The Shell))\
). This should already be the case if you have a standard zsh
installation; if it is not, copy tt(Functions/Misc/zkbd) to an
appropriate directory.
subsect(Dumping Shell State)
cindex(reporter utility)
Occasionally you may encounter what appears to be a bug in the shell,
particularly if you are using a beta version of zsh or a development
release. Usually it is sufficient to send a description of the
problem to one of the zsh mailing lists (see
ifzman(zmanref(zsh))\
ifnzman(noderef(Mailing Lists))\
), but sometimes one of the zsh developers will need to recreate your
environment in order to track the problem down.
The script named tt(reporter), found in the tt(Util) directory of the
distribution, is provided for this purpose. (It is also possible to
tt(autoload reporter), but tt(reporter) is not installed in tt(fpath)
by default.) This script outputs a detailed dump of the shell state,
in the form of another script that can be read with `tt(zsh -f)' to
recreate that state.
To use tt(reporter), read the script into your shell with the `tt(.)'
command and redirect the output into a file:
example(. ~/zsh-version()/Util/reporter > zsh.report)
You should check the tt(zsh.report) file for any sensitive information
such as passwords and delete them by hand before sending the script to the
developers. Also, as the output can be voluminous, it's best to wait for
the developers to ask for this information before sending it.
You can also use tt(reporter) to dump only a subset of the shell state.
This is sometimes useful for creating startup files for the first time.
Most of the output from reporter is far more detailed than usually is
necessary for a startup file, but the tt(aliases), tt(options), and
tt(zstyles) states may be useful because they include only changes from
the defaults. The tt(bindings) state may be useful if you have created
any of your own keymaps, because tt(reporter) arranges to dump the keymap
creation commands as well as the bindings for every keymap.
As is usual with automated tools, if you create a startup file with
tt(reporter), you should edit the results to remove unnecessary commands.
Note that if you're using the new completion system, you should em(not)
dump the tt(functions) state to your startup files with tt(reporter); use
the tt(compdump) function instead (see
ifzman(zmanref(zshcompsys))\
ifnzman(noderef(Completion System))\
).
startitem()
item(tt(reporter) [ var(state) ... ])(
findex(reporter)
Print to standard output the indicated subset of the current shell state.
The var(state) arguments may be one or more of:
startsitem()
sitem(tt(all))(Output everything listed below.)
sitem(tt(aliases))(Output alias definitions.)
sitem(tt(bindings))(Output ZLE key maps and bindings.)
sitem(tt(completion))(Output old-style tt(compctl) commands.
New completion is covered by tt(functions) and tt(zstyles).)
sitem(tt(functions))(Output autoloads and function definitions.)
sitem(tt(limits))(Output tt(limit) commands.)
sitem(tt(options))(Output tt(setopt) commands.)
sitem(tt(styles))(Same as tt(zstyles).)
sitem(tt(variables))(Output shell parameter assignments, plus tt(export)
commands for any environment variables.)
sitem(tt(zstyles))(Output tt(zstyle) commands.)
endsitem()
If the var(state) is omitted, tt(all) is assumed.
)
With the exception of `tt(all)', every var(state) can be abbreviated by
any prefix, even a single letter; thus tt(a) is the same as tt(aliases),
tt(z) is the same as tt(zstyles), etc.
enditem()
texinode(Prompt Themes)(ZLE Functions)(Utilities)(User Contributions)
sect(Prompt Themes)
subsect(Installation)
You should make sure all the functions from the tt(Functions/Prompts)
directory of the source distribution are available; they all begin with
the string `tt(prompt_)' except for the special function`tt(promptinit)'.
You also need the `tt(colors)' function from tt(Functions/Misc). All of
these functions may already have been installed on your system; if not,
you will need to find them and copy them. The directory should appear as
one of the elements of the tt(fpath) array (this should already be the
case if they were installed), and at least the function tt(promptinit)
should be autoloaded; it will autoload the rest. Finally, to initialize
the use of the system you need to call the tt(promptinit) function. The
following code in your tt(.zshrc) will arrange for this; assume the
functions are stored in the directory tt(~/myfns):
example(fpath=(~/myfns $fpath)
autoload -U promptinit
promptinit)
subsect(Theme Selection)
Use the tt(prompt) command to select your preferred theme. This command
may be added to your tt(.zshrc) following the call to tt(promptinit) in
order to start zsh with a theme already selected.
startitem()
xitem(tt(prompt) [ tt(-c) | tt(-l) ])
xitem(tt(prompt) [ tt(-p) | tt(-h) ] [ var(theme) ... ])
item(tt(prompt) [ tt(-s) ] var(theme) [ var(arg) ... ])(
Set or examine the prompt theme. With no options and a var(theme)
argument, the theme with that name is set as the current theme. The
available themes are determined at run time; use the tt(-l) option to see
a list. The special var(theme) `tt(random)' selects at random one of the
available themes and sets your prompt to that.
In some cases the var(theme) may be modified by one or more arguments,
which should be given after the theme name. See the help for each theme
for descriptions of these arguments.
Options are:
startsitem()
sitem(tt(-c))(Show the currently selected theme and its parameters, if any.)
sitem(tt(-l))(List all available prompt themes.)
sitem(tt(-p))(Preview the theme named by var(theme), or all themes if no
var(theme) is given.)
sitem(tt(-h))(Show help for the theme named by var(theme), or for the
tt(prompt) function if no var(theme) is given.)
sitem(tt(-s))(Set var(theme) as the current theme and save state.)
endsitem()
)
item(tt(prompt_)var(theme)tt(_setup))(
Each available var(theme) has a setup function which is called by the
tt(prompt) function to install that theme. This function may define
other functions as necessary to maintain the prompt, including functions
used to preview the prompt or provide help for its use. You should not
normally call a theme's setup function directly.
)
enditem()
texinode(ZLE Functions)(Exception Handling)(Prompt Themes)(User Contributions)
sect(ZLE Functions)
subsect(Widgets)
These functions all implement user-defined ZLE widgets (see
ifzman(zmanref(zshzle))\
ifnzman(noderef(Zsh Line Editor))\
) which can be bound to keystrokes in interactive shells. To use them,
your tt(.zshrc) should contain lines of the form
example(autoload var(function)
zle -N var(function))
followed by an appropriate tt(bindkey) command to associate the function
with a key sequence. Suggested bindings are described below.
startitem()
item(bash-style word functions)(
If you are looking for functions to implement moving over and editing
words in the manner of bash, where only alphanumeric characters are
considered word characters, you can use the functions described in
the next section. The following is sufficient:
example(autoload -U select-word-style
select-word-style bash)
)
tindex(forward-word-match)
tindex(backward-word-match)
tindex(kill-word-match)
tindex(backward-kill-word-match)
tindex(transpose-words-match)
tindex(capitalize-word-match)
tindex(up-case-word-match)
tindex(down-case-word-match)
tindex(select-word-style)
tindex(match-word-context)
tindex(match-words-by-style)
xitem(tt(forward-word-match), tt(backward-word-match))
xitem(tt(kill-word-match), tt(backward-kill-word-match))
xitem(tt(transpose-words-match), tt(capitalize-word-match))
xitem(tt(up-case-word-match), tt(down-case-word-match))
item(tt(select-word-style), tt(match-word-context), tt(match-words-by-style))(
The eight `tt(-match)' functions are drop-in replacements for the
builtin widgets without the suffix. By default they behave in a similar
way. However, by the use of styles and the function tt(select-word-style),
the way words are matched can be altered.
The simplest way of configuring the functions is to use
tt(select-word-style), which can either be called as a normal function with
the appropriate argument, or invoked as a user-defined widget that will
prompt for the first character of the word style to be used. The first
time it is invoked, the eight tt(-match) functions will automatically
replace the builtin versions, so they do not need to be loaded explicitly.
The word styles available are as follows. Only the first character
is examined.
startitem()
item(tt(bash))(
Word characters are alphanumeric characters only.
)
item(tt(normal))(
As in normal shell operation: word characters are alphanumeric characters
plus any characters present in the string given by the parameter
tt($WORDCHARS).
)
item(tt(shell))(
Words are complete shell command arguments, possibly including complete
quoted strings, or any tokens special to the shell.
)
item(tt(whitespace))(
Words are any set of characters delimited by whitespace.
)
item(tt(default))(
Restore the default settings; this is usually the same as `tt(normal)'.
)
enditem()
More control can be obtained using the tt(zstyle) command, as described in
ifzman(zmanref(zshmodules))\
ifnzman(noderef(The zsh/zutil Module)). Each style is looked up in the
context tt(:zle:)var(widget) where var(widget) is the name of the
user-defined widget, not the name of the function implementing it, so in
the case of the definitions supplied by tt(select-word-style) the
appropriate contexts are tt(:zle:forward-word), and so on. The function
tt(select-word-style) itself always defines styles for the context
`tt(:zle:*)' which can be overridden by more specific (longer) patterns as
well as explicit contexts.
The style tt(word-style) specifies the rules to use. This may have the
following values.
startitem()
item(tt(normal))(
Use the standard shell rules, i.e. alphanumerics and tt($WORDCHARS), unless
overridden by the styles tt(word-chars) or tt(word-class).
)
item(tt(specified))(
Similar to tt(normal), but em(only) the specified characters, and not also
alphanumerics, are considered word characters.
)
item(tt(unspecified))(
The negation of specified. The given characters are those which will
em(not) be considered part of a word.
)
item(tt(shell))(
Words are obtained by using the syntactic rules for generating shell
command arguments. In addition, special tokens which are never command
arguments such as `tt(())' are also treated as words.
)
item(tt(whitespace))(
Words are whitespace-delimited strings of characters.
)
enditem()
The first three of those rules usually use tt($WORDCHARS), but the value
in the parameter can be overridden by the style tt(word-chars), which works
in exactly the same way as tt($WORDCHARS). In addition, the style
tt(word-class) uses character class syntax to group characters and takes
precedence over tt(word-chars) if both are set. The tt(word-class) style
does not include the surrounding brackets of the character class; for
example, `tt(-:[:alnum:])' is a valid tt(word-class) to include all
alphanumerics plus the characters `tt(-)' and `tt(:)'. Be careful
including `tt(])', `tt(^)' and `tt(-)' as these are special inside
character classes.
The style tt(skip-chars) is mostly useful for
tt(transpose-words) and similar functions. If set, it gives a count of
characters starting at the cursor position which will not be considered
part of the word and are treated as space, regardless of what they actually
are. For example, if
example(zstyle ':zle:transpose-words' skip-chars 1)
has been set, and tt(transpose-words-match) is called with the cursor on
the var(X) of tt(foo)var(X)tt(bar), where var(X) can be any character, then
the resulting expression is tt(bar)var(X)tt(foo).
Finer grained control can be obtained by setting the style tt(word-context)
to an array of pairs of entries. Each pair of entries consists of a
var(pattern) and a var(subcontext). The shell argument the cursor is on is
matched against each var(pattern) in turn until one matches; if it does,
the context is extended by a colon and the corresponding var(subcontext).
Note that the test is made against the original word on the line, with no
stripping of quotes. If the cursor is at the end of the line the test is
performed against an empty string; if it is on whitespace between words the
test is made against a single space. Some examples are given below.
Here are some examples of use of the styles, actually taken from the
simplified interface in tt(select-word-style):
example(zstyle ':zle:*' word-style standard
zstyle ':zle:*' word-chars '')
Implements bash-style word handling for all widgets, i.e. only
alphanumerics are word characters; equivalent to setting
the parameter tt(WORDCHARS) empty for the given context.
example(style ':zle:*kill*' word-style space)
Uses space-delimited words for widgets with the word `kill' in the name.
Neither of the styles tt(word-chars) nor tt(word-class) is used in this case.
Here are some examples of use of the tt(word-context) style to extend
the context.
example(zstyle ':zle:*' word-context "*/*" file "[[:space:]]" whitespace
zstyle ':zle:transpose-words:whitespace' word-style shell
zstyle ':zle:transpose-words:filename' word-style normal
zstyle ':zle:transpose-words:filename' word-chars '')
This provides two different ways of using tt(transpose-words) depending on
whether the cursor is on whitespace between words or on a filename, here
any word containing a tt(/). On whitespace, complete arguments as defined
by standard shell rules will be transposed. In a filename, only
alphanumerics will be transposed. Elsewhere, words will be transposed
using the default style for tt(:zle:transpose-words).
The word matching and all the handling of tt(zstyle) settings is actually
implemented by the function tt(match-words-by-style). This can be used to
create new user-defined widgets. The calling function should set the local
parameter tt(curcontext) to tt(:zle:)var(widget), create the local
parameter tt(matched_words) and call tt(match-words-by-style) with no
arguments. On return, tt(matched_words) will be set to an array with the
elements: (1) the start of the line (2) the word before the cursor (3) any
non-word characters between that word and the cursor (4) any non-word
character at the cursor position plus any remaining non-word characters
before the next word, including all characters specified by the
tt(skip-chars) style, (5) the word at or following the cursor (6) any
non-word characters following that word (7) the remainder of the line. Any
of the elements may be an empty string; the calling function should test
for this to decide whether it can perform its function.
It is possible to pass options with arguments to tt(match-words-by-style)
to override the use of styles. The options are:
startsitem()
sitem(tt(-w))(var(word-style))
sitem(tt(-s))(var(skip-chars))
sitem(tt(-c))(var(word-class))
sitem(tt(-C))(var(word-chars))
endsitem()
For example, tt(match-words-by-style -w shell -c 0) may be used to
extract the command argument around the cursor.
The tt(word-context) style is implemented by the function
tt(match-word-context). This should not usually need to be called
directly.
)
tindex(delete-whole-word-match)
item(tt(delete-whole-word-match))(
This is another function which works like the tt(-match) functions
described immediately above, i.e. using styles to decide the word
boundaries. However, it is not a replacement for any existing function.
The basic behaviour is to delete the word around the cursor. There is no
numeric prefix handling; only the single word around the cursor is
considered. If the widget contains the string tt(kill), the removed text
will be placed in the cutbuffer for future yanking. This can be obtained
by defining tt(kill-whole-word-match) as follows:
example(zle -N kill-whole-word-match delete-whole-word-match)
and then binding the widget tt(kill-whole-word-match).
)
tindex(copy-earlier-word)
item(tt(copy-earlier-word))(
This widget works like a combination of tt(insert-last-word) and
tt(copy-prev-shell-word). Repeated invocations of the widget retrieve
earlier words on the relevant history line. With a numeric argument
var(N), insert the var(N)th word from the history line; var(N) may be
negative to count from the end of the line.
If tt(insert-last-word) has been used to retrieve the last word on a
previous history line, repeated invocations will replace that word with
earlier words from the same line.
Otherwise, the widget applies to words on the line currently being edited.
The tt(widget) style can be set to the name of another widget that should
be called to retrieve words. This widget must accept the same three
arguments as tt(insert-last-word).
)
tindex(cycle-completion-positions)
item(tt(cycle-completion-positions))(
After inserting an unambiguous string into the command line, the new
function based completion system may know about multiple places in
this string where characters are missing or differ from at least one
of the possible matches. It will then place the cursor on the
position it considers to be the most interesting one, i.e. the one
where one can disambiguate between as many matches as possible with as
little typing as possible.
This widget allows the cursor to be easily moved to the other interesting
spots. It can be invoked repeatedly to cycle between all positions
reported by the completion system.
)
tindex(edit-command-line)
item(tt(edit-command-line))(
Edit the command line using your visual editor, as in tt(ksh).
example(bindkey -M vicmd v edit-command-line)
)
tindex(history-beginning-search-backward-end)
tindex(history-beginning-search-forward-end)
item(tt(history-search-end))(
This function implements the widgets
tt(history-beginning-search-backward-end) and
tt(history-beginning-search-forward-end). These commands work by first
calling the corresponding builtin widget (see
ifzman(`History Control' in zmanref(zshzle))\
ifnzman(noderef(History Control))\
) and then moving the cursor to the end of the line. The original cursor
position is remembered and restored before calling the builtin widget a
second time, so that the same search is repeated to look farther through
the history.
Although you tt(autoload) only one function, the commands to use it are
slightly different because it implements two widgets.
example(zle -N history-beginning-search-backward-end \
history-search-end
zle -N history-beginning-search-forward-end \
history-search-end
bindkey '\e^P' history-beginning-search-backward-end
bindkey '\e^N' history-beginning-search-forward-end)
)
tindex(history-beginning-search-menu)
item(tt(history-beginning-search-menu))(
This function implements yet another form of history searching. The
text before the cursor is used to select lines from the history,
as for tt(history-beginning-search-backward) except that all matches are
shown in a numbered menu. Typing the appropriate digits inserts the
full history line. Note that leading zeroes must be typed (they are only
shown when necessary for removing ambiguity). The entire history is
searched; there is no distinction between forwards and backwards.
With a prefix argument, the search is not anchored to the start of
the line; the string typed by the use may appear anywhere in the line
in the history.
If the widget name contains `tt(-end)' the cursor is moved to the end of
the line inserted. If the widget name contains `tt(-space)' any space
in the text typed is treated as a wildcard and can match anything (hence
a leading space is equivalent to giving a prefix argument). Both
forms can be combined, for example:
example(zle -N history-beginning-search-menu-space-end \
history-beginning-search-menu)
)
tindex(history-pattern-search)
tindex(history-pattern-search-backward)
tindex(history-pattern-search-forward)
item(tt(history-pattern-search))(
The function tt(history-pattern-search) implements widgets which prompt
for a pattern with which to search the history backwards or forwards. The
pattern is in the usual zsh format, however the first character may be
tt(^) to anchor the search to the start of the line, and the last character
may be tt($) to anchor the search to the end of the line. If the
search was not anchored to the end of the line the cursor is positioned
just after the pattern found.
The commands to create bindable widgets are similar to those in the
example immediately above:
example(autoload -U history-pattern-search
zle -N history-pattern-search-backward history-pattern-search
zle -N history-pattern-search-forward history-pattern-search)
)
tindex(up-line-or-beginning-search)
tindex(down-line-or-beginning-search)
item(tt(up-line-or-beginning-search), tt(down-line-or-beginning-search))(
These widgets are similar to the builtin functions tt(up-line-or-search)
and tt(down-line-or-search): if in a multiline buffer they move up or
down within the buffer, otherwise they search for a history line matching
the start of the current line. In this case, however, they search for
a line which matches the current line up to the current cursor position, in
the manner of tt(history-beginning-search-backward) and tt(-forward), rather
than the first word on the line.
)
tindex(incarg)
vindex(incarg, use of)
item(tt(incarg))(
Typing the keystrokes for this widget with the cursor placed on or to the
left of an integer causes that integer to be incremented by one. With a
numeric prefix argument, the number is incremented by the amount of the
argument (decremented if the prefix argument is negative). The shell
parameter tt(incarg) may be set to change the default increment to
something other than one.
example(bindkey '^X+' incarg)
)
tindex(incremental-complete-word)
item(tt(incremental-complete-word))(
This allows incremental completion of a word. After starting this
command, a list of completion choices can be shown after every character
you type, which you can delete with tt(^H) or tt(DEL). Pressing return
accepts the completion so far and returns you to normal editing (that is,
the command line is em(not) immediately executed). You can hit tt(TAB) to
do normal completion, tt(^G) to abort back to the state when you started,
and tt(^D) to list the matches.
This works only with the new function based completion system.
example(bindkey '^Xi' incremental-complete-word)
)
tindex(insert-composed-char)
item(tt(insert-composed-char))(
This function allows you to compose characters that don't appear on the
keyboard to be inserted into the command line. The command is followed by
two keys corresponding to ASCII characters (there is no prompt). For
accented characters, the two keys are a base character followed by a code
for the accent, while for other special characters the two characters
together form a mnemonic for the character to be inserted. The
two-character codes are a subset of those given by RFC 1345 (see for
example tt(http://www.faqs.org/rfcs/rfc1345.html)).
The function may optionally be followed by up to two characters which
replace one or both of the characters read from the keyboard; if both
characters are supplied, no input is read. For example,
tt(insert-composed-char a:) can be used within a widget to insert an a with
umlaut into the command line. This has the advantages over use of a
literal character that it is more portable.
For best results zsh should have been built with support for multibyte
characters (configured with tt(--enable-multibyte)); however, the function
works for the limited range of characters available in single-byte
character sets such as ISO-8859-1.
The character is converted into the local representation and
inserted into the command line at the cursor position.
(The conversion is done within the shell, using whatever facilities
the C library provides.) With a numeric argument, the character and its
code are previewed in the status line
The function may be run outside zle in which case it prints the character
(together with a newline) to standard output. Input is still read from
keystrokes.
See tt(insert-unicode-char) for an alternative way of inserting Unicode
characters using their hexadecimal character number.
The set of accented characters is reasonably complete up to Unicode
character U+0180, the set of special characters less so. However, it it
is very sporadic from that point. Adding new characters is easy,
however; see the function tt(define-composed-chars). Please send any
additions to tt(zsh-workers@sunsite.dk).
The codes for the second character when used to accent the first are as
follows. Note that not every character can take every accent.
startsitem()
sitem(tt(!))(Grave.)
sitem(tt(RQUOTE()))(Acute.)
sitem(tt(>))(Circumflex.)
sitem(tt(?))(Tilde. (This is not tt(~) as RFC 1345 does not assume that
character is present on the keyboard.))
sitem(tt(-))(Macron. (A horizonal bar over the base character.))
sitem(tt(LPAR()))(Breve. (A shallow dish shape over the base character.))
sitem(tt(.))(Dot above the base character, or in the case of tt(i) no dot,
or in the case of tt(L) and tt(l) a centered dot.)
sitem(tt(:))(Diaeresis (Umlaut).)
sitem(tt(c))(Cedilla.)
sitem(tt(_))(Underline, however there are currently no underlined characters.)
sitem(tt(/))(Stroke through the base character.)
sitem(tt("))(Double acute (only supported on a few letters).)
sitem(tt(;))(Ogonek. (A little forward facing hook at the bottom right
of the character.))
sitem(tt(<))(Caron. (A little v over the letter.))
sitem(tt(0))(Circle over the base character.)
sitem(tt(2))(Hook over the base character.)
sitem(tt(9))(Horn over the base character.)
endsitem()
The most common characters from the Arabic, Cyrillic, Greek and Hebrew
alphabets are available; consult RFC 1345 for the appropriate sequences.
In addition, a set of two letter codes not in RFC 1345 are available for
the double-width characters corresponding to ASCII characters from tt(!)
to tt(~) (0x21 to 0x7e) by preceeding the character with tt(^), for
example tt(^A) for a double-width tt(A).
The following other two-character sequences are understood.
startitem()
item(ASCII characters)(
These are already present on most keyboards:
startsitem()
sitem(tt(<LPAR()))(Left square bracket)
sitem(tt(//))(Backslash (solidus))
sitem(tt(RPAR()>))(Right square bracket)
sitem(tt(LPAR()!))(Left brace (curly bracket))
sitem(tt(!!))(Vertical bar (pipe symbol))
sitem(tt(!RPAR()))(Right brace (curly bracket))
sitem(tt(RQUOTE()?))(Tilde)
endsitem()
)
item(Special letters)(
Characters found in various variants of the Latin alphabet:
startsitem()
sitem(tt(ss))(Eszett (scafes S))
sitem(tt(D-), tt(d-))(Eth)
sitem(tt(TH), tt(th))(Thorn)
sitem(tt(kk))(Kra)
sitem(tt(RQUOTE()n))(RQUOTE()n)
sitem(tt(NG), tt(ng))(Ng)
sitem(tt(OI), tt(oi))(Oi)
sitem(tt(yr))(yr)
sitem(tt(ED))(ezh)
endsitem()
)
item(Currency symbols)(
startsitem()
sitem(tt(Ct))(Cent)
sitem(tt(Pd))(Pound sterling (also lira and others))
sitem(tt(Cu))(Currency)
sitem(tt(Ye))(Yen)
sitem(tt(Eu))(Euro (N.B. not in RFC 1345))
endsitem()
)
item(Punctuation characters)(
References to "right" quotes indicate the shape (like a 9 rather than 6)
rather than their grammatical use. (For example, a "right" low double
quote is used to open quotations in German.)
startsitem()
sitem(tt(!I))(Inverted exclamation mark)
sitem(tt(BB))(Broken vertical bar)
sitem(tt(SE))(Section)
sitem(tt(Co))(Copyright)
sitem(tt(-a))(Spanish feminine ordinal indicator)
sitem(tt(<<))(Left guillemet)
sitem(tt(--))(Soft hyphen)
sitem(tt(Rg))(Registered trade mark)
sitem(tt(PI))(Pilcrow (paragraph))
sitem(tt(-o))(Spanish masculine ordinal indicator)
sitem(tt(>>))(Right guillemet)
sitem(tt(?I))(Inverted question mark)
sitem(tt(-1))(Hyphen)
sitem(tt(-N))(En dash)
sitem(tt(-M))(Em dash)
sitem(tt(-3))(Horizontal bar)
sitem(tt(:3))(Vertical ellipsis)
sitem(tt(.3))(Horizontal midline ellipsis)
sitem(tt(!2))(Double vertical line)
sitem(tt(=2))(Double low line)
sitem(tt(RQUOTE()6))(Left single quote)
sitem(tt(RQUOTE()9))(Right single quote)
sitem(tt(.9))("Right" low quote)
sitem(tt(9+RQUOTE()))(Reversed "right" quote)
sitem(tt("6))(Left double quote)
sitem(tt("9))(Right double quote)
sitem(tt(:9))("Right" low double quote)
sitem(tt(9"))(Reversed "right" double quote)
sitem(tt(/-))(Dagger)
sitem(tt(/=))(Double dagger)
endsitem()
)
item(Mathematical symbols)(
startsitem()
sitem(tt(DG))(Degree)
sitem(tt(-2), tt(+-), tt(-+))(- sign, +/- sign, -/+ sign)
sitem(tt(2S))(Superscript 2)
sitem(tt(3S))(Superscript 3)
sitem(tt(1S))(Superscript 1)
sitem(tt(My))(Micro)
sitem(tt(.M))(Middle dot)
sitem(tt(14))(Quarter)
sitem(tt(12))(Half)
sitem(tt(34))(Three quarters)
sitem(tt(*X))(Multiplication)
sitem(tt(-:))(Division)
sitem(tt(%0))(Per mille)
sitem(tt(FA), tt(TE), tt(/0))(For all, there exists, empty set)
sitem(tt(dP), tt(DE), tt(NB))(Partial derivative, delta (increment), del
(nabla))
sitem(tt(LPAR()-), tt(-RPAR()))(Element of, contains)
sitem(tt(*P), tt(+Z))(Product, sum)
sitem(tt(*-), tt(Ob), tt(Sb))(Asterisk, ring, bullet)
sitem(tt(RT), tt(0+LPAR()), tt(00))(Root sign, proportional to, infinity)
endsitem()
)
item(Other symbols)(
startsitem()
sitem(tt(cS), tt(cH), tt(cD), tt(cC))(Card suits: spades, hearts, diamonds,
clubs)
sitem(tt(Md), tt(M8), tt(M2), tt(Mb), tt(Mx), tt(MX))(Musical notation:
crotchet (quarter note), quaver (eighth note), semiquavers (sixteenth
notes), flag sign, natural signa, sharp sign)
sitem(tt(Fm), tt(Ml))(Female, male)
endsitem()
)
item(Accents on their own)(
startsitem()
sitem(tt(RQUOTE()>))(Circumflex (same as caret, tt(^)))
sitem(tt(RQUOTE()!))(Grave (same as backtick, tt(`)))
sitem(tt(RQUOTE(),))(Cedilla)
sitem(tt(RQUOTE():))(Diaeresis (Umlaut))
sitem(tt(RQUOTE()m))(Macron)
sitem(tt(RQUOTE()RQUOTE()))(Acute)
endsitem()
)
enditem()
)
tindex(insert-files)
item(tt(insert-files))(
This function allows you type a file pattern, and see the results of the
expansion at each step. When you hit return, all expansions are inserted
into the command line.
example(bindkey '^Xf' insert-files)
)
tindex(narrow-to-region)
tindex(narrow-to-region-invisible)
xitem(tt(narrow-to-region [ -p) var(pre) tt(] [ -P) var(post) tt(]))
xitem( tt([ -S) var(statepm) tt(| -R) var(statepm) tt(] [ -n ] [) var(start) var(end) tt(])))
item(tt(narrow-to-region-invisible))(
Narrow the editable portion of the buffer to the region between the cursor
and the mark, which may be in either order. The region may not be empty.
tt(narrow-to-region) may be used as a widget or called as a function from a
user-defined widget; by default, the text outside the editable area remains
visible. A tt(recursive-edit) is performed and the original widening
status is then restored. Various options and arguments are available when
it is called as a function.
The options tt(-p) var(pretext) and tt(-P) var(posttext) may be
used to replace the text before and after the display for the duration of
the function; either or both may be an empty string.
If the option tt(-n) is also given, var(pretext) or var(posttext) will only
be inserted if there is text before or after the region respectively which
will be made invisible.
Two numeric arguments may be given which will be used instead of the cursor
and mark positions.
The option tt(-S) var(statepm) is used to narrow according to the other
options while saving the original state in the parameter with name
var(statepm), while the option tt(-R) var(statepm) is used to restore the
state from the parameter; note in both cases the em(name) of the parameter
is required. In the second case, other options and arguments are
irrelevant. When this method is used, no tt(recursive-edit) is performed;
the calling widget should call this function with the option tt(-S),
perform its own editing on the command line or pass control to the user
via `tt(zle recursive-edit)', then call this function with the option
tt(-R). The argument var(statepm) must be a suitable name for an ordinary
parameter, except that parameters beginning with the prefix tt(_ntr_) are
reserved for use within tt(narrow-to-region). Typically the parameter will
be local to the calling function.
tt(narrow-to-region-invisible) is a simple widget which calls
tt(narrow-to-region) with arguments which replace any text outside the
region with `tt(...)'.
The display is restored (and the widget returns) upon any zle command
which would usually cause the line to be accepted or aborted. Hence an
additional such command is required to accept or abort the current line.
The return status of both widgets is zero if the line was accepted, else
non-zero.
Here is a trivial example of a widget using this feature.
example(local state
narrow-to-region -p $'Editing restricted region\n' \
-P '' -S state
zle recursive-edit
narrow-to-region -R state)
)
tindex(insert-unicode-char)
item(tt(insert-unicode-char))(
When first executed, the user inputs a set of hexadecimal digits.
This is terminated with another call to tt(insert-unicode-char).
The digits are then turned into the corresponding Unicode character.
For example, if the widget is bound to tt(^XU), the character sequence
`tt(^XU 4 c ^XU)' inserts tt(L) (Unicode U+004c).
See tt(insert-composed-char) for a way of inserting characters
using a two-character mnemonic.
)
tindex(predict-on)
tindex(predict-off)
item(tt(predict-on))(
This set of functions implements predictive typing using history search.
After tt(predict-on), typing characters causes the editor to look backward
in the history for the first line beginning with what you have typed so
far. After tt(predict-off), editing returns to normal for the line found.
In fact, you often don't even need to use tt(predict-off), because if the
line doesn't match something in the history, adding a key performs
standard completion, and then inserts itself if no completions were found.
However, editing in the middle of a line is liable to confuse prediction;
see the tt(toggle) style below.