blob: 25df17fbfd89877d5dac3c16e18f564d1819b470 (
plain) (
blame)
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
|
# This is a function to dump the definitions for new-style
# completion defined by 'compinit' in the same directory. The output
# should be directed into the "compinit.dump" in the same directory as
# compinit. If you rename init, just stick .dump onto the end of whatever
# you have called it and put it in the same directory. This is handled
# automatically if you invoke compinit with the option -d.
#
# You will need to update the dump every time you add a new completion.
# To do this, simply remove the .dump file, start a new shell, and
# create the .dump file as before. Again, compinit -d handles this
# automatically.
# Print the number of files used for completion. This is used in compinit
# to see if auto-dump should re-dump the dump-file.
emulate -L zsh
setopt extendedglob noshglob
typeset _d_file _d_f _d_bks _d_line _d_als _d_files
_d_file=${_comp_dumpfile-${0:h}/compinit.dump}.$HOST.$$
[[ $_d_file = //* ]] && _d_file=${_d_file[2,-1]}
[[ -w ${_d_file:h} ]] || return 1
_d_files=( ${^~fpath:/.}/^([^_]*|*~|*.zwc)(N) )
if [[ -n "$_comp_secure" ]]; then
_d_wdirs=( ${^fpath}(Nf:g+w:,f:o+w:,^u0u${EUID}) )
_d_wfiles=( ${^~fpath:/.}/^([^_]*|*~|*.zwc)(N^u0u${EUID}) )
(( $#_d_wfiles )) && _d_files=( "${(@)_d_files:#(${(j:|:)_d_wfiles})}" )
(( $#_d_wdirs )) && _d_files=( "${(@)_d_files:#(${(j:|:)_d_wdirs})/*}" )
fi
print "#files: $#_d_files" > $_d_file
# First dump the arrays _comps and _patcomps. The quoting hieroglyphyics
# ensure that a single quote inside a variable is itself correctly quoted.
print "_comps=(" >> $_d_file
for _d_f in ${(ok)_comps}; do
print -r - "${(q)_d_f}" "${(q)_comps[$_d_f]}"
done >> $_d_file
print ")" >> $_d_file
print "\n_patcomps=(" >> $_d_file
for _d_f in "${(ok@)_patcomps}"; do
print -r - "${(q)_d_f}" "${(q)_patcomps[$_d_f]}"
done >> $_d_file
print ")" >> $_d_file
print "\n_postpatcomps=(" >> $_d_file
for _d_f in "${(ok@)_postpatcomps}"; do
print -r - "${(q)_d_f}" "${(q)_postpatcomps[$_d_f]}"
done >> $_d_file
print ")" >> $_d_file
print "\n_compautos=(" >> $_d_file
for _d_f in "${(ok@)_compautos}"; do
print -r - "${(q)_d_f}" "${(q)_compautos[$_d_f]}"
done >> $_d_file
print ")" >> $_d_file
print >> $_d_file
# Now dump the key bindings. We dump all bindings for zle widgets
# whose names start with a underscore.
# We need both the zle -C's and the bindkey's to recreate.
# We can ignore any zle -C which rebinds a standard widget (second
# argument to zle does not begin with a `_').
_d_bks=()
_d_complist=
zle -lL |
while read -rA _d_line; do
if [[ ${_d_line[3]} = _* && ${_d_line[5]} = _* ]]; then
if [[ -z "$_d_complist" && ${_d_line[4]} = .menu-select ]]; then
print 'zmodload -i zsh/complist'
d_complist=yes
fi
print -r - ${_d_line}
_d_bks=($_d_bks ${_d_line[3]})
fi
done >> $_d_file
bindkey |
while read -rA _d_line; do
if [[ ${_d_line[2]} = (${(j.|.)~_d_bks}) ]]; then
print -r "bindkey '${_d_line[1][2,-2]}' ${_d_line[2]}"
fi
done >> $_d_file
print >> $_d_file
# Autoloads: whence -w produces "_d_foo: function", so look for
# all functions beginning with `_'.
_d_als=($(whence -wm '_*' | sort |
while read -rA _d_line; do
[[ ${_d_line[2]} = function ]] && print -r - ${_d_line[1]%:}
done))
# print them out: about five to a line looks neat
_i=5
print -n autoload -U >> $_d_file
while (( $#_d_als )); do
if (( ! $+_compautos[$_d_als[1]] )); then
print -n " $_d_als[1]"
if (( ! _i-- && $#_d_als > 1 )); then
_i=5
print -n ' \\\n '
fi
fi
shift _d_als
done >> $_d_file
print >> $_d_file
for _i in "${(ok@)_compautos}"; do
print "autoload -U $_compautos[$_i] $_i" >> $_d_file
done
mv $_d_file ${_d_file%.$HOST.$$}
unfunction compdump
autoload -U compdump
|
