zshrc: avoid "no matches found: abk[V]" on grml-small systems, fixup
[grml-etc-core.git] / etc / zsh / zshrc
1 # Filename:      /etc/zsh/zshrc
2 # Purpose:       config file for zsh (z shell)
3 # Authors:       grml-team (grml.org), (c) Michael Prokop <mika@grml.org>
4 # Bug-Reports:   see http://grml.org/bugs/
5 # License:       This file is licensed under the GPL v2.
6 ################################################################################
7 # This file is sourced only for interactive shells. It
8 # should contain commands to set up aliases, functions,
9 # options, key bindings, etc.
10 #
11 # Global Order: zshenv, zprofile, zshrc, zlogin
12 ################################################################################
13
14 # USAGE
15 # If you are using this file as your ~/.zshrc file, please use ~/.zshrc.pre
16 # and ~/.zshrc.local for your own customisations. The former file is read
17 # before ~/.zshrc, the latter is read after it. Also, consider reading the
18 # refcard and the reference manual for this setup, both available from:
19 #     <http://grml.org/zsh/>
20
21 # Contributing:
22 # If you want to help to improve grml's zsh setup, clone the grml-etc-core
23 # repository from git.grml.org:
24 #   git clone git://git.grml.org/grml-etc-core.git
25 #
26 # Make your changes, commit them; use 'git format-patch' to create a series
27 # of patches and send those to the following address via 'git send-email':
28 #   grml-etc-core@grml.org
29 #
30 # Doing so makes sure the right people get your patches for review and
31 # possibly inclusion.
32
33 # zsh-refcard-tag documentation:
34 #   You may notice strange looking comments in this file.
35 #   These are there for a purpose. grml's zsh-refcard can now be
36 #   automatically generated from the contents of the actual configuration
37 #   file. However, we need a little extra information on which comments
38 #   and what lines of code to take into account (and for what purpose).
39 #
40 # Here is what they mean:
41 #
42 # List of tags (comment types) used:
43 #   #a#     Next line contains an important alias, that should
44 #           be included in the grml-zsh-refcard.
45 #           (placement tag: @@INSERT-aliases@@)
46 #   #f#     Next line contains the beginning of an important function.
47 #           (placement tag: @@INSERT-functions@@)
48 #   #v#     Next line contains an important variable.
49 #           (placement tag: @@INSERT-variables@@)
50 #   #k#     Next line contains an important keybinding.
51 #           (placement tag: @@INSERT-keybindings@@)
52 #   #d#     Hashed directories list generation:
53 #               start   denotes the start of a list of 'hash -d'
54 #                       definitions.
55 #               end     denotes its end.
56 #           (placement tag: @@INSERT-hasheddirs@@)
57 #   #A#     Abbreviation expansion list generation:
58 #               start   denotes the beginning of abbreviations.
59 #               end     denotes their end.
60 #           Lines within this section that end in '#d .*' provide
61 #           extra documentation to be included in the refcard.
62 #           (placement tag: @@INSERT-abbrev@@)
63 #   #m#     This tag allows you to manually generate refcard entries
64 #           for code lines that are hard/impossible to parse.
65 #               Example:
66 #                   #m# k ESC-h Call the run-help function
67 #               That would add a refcard entry in the keybindings table
68 #               for 'ESC-h' with the given comment.
69 #           So the syntax is: #m# <section> <argument> <comment>
70 #   #o#     This tag lets you insert entries to the 'other' hash.
71 #           Generally, this should not be used. It is there for
72 #           things that cannot be done easily in another way.
73 #           (placement tag: @@INSERT-other-foobar@@)
74 #
75 #   All of these tags (except for m and o) take two arguments, the first
76 #   within the tag, the other after the tag:
77 #
78 #   #<tag><section># <comment>
79 #
80 #   Where <section> is really just a number, which are defined by the
81 #   @secmap array on top of 'genrefcard.pl'. The reason for numbers
82 #   instead of names is, that for the reader, the tag should not differ
83 #   much from a regular comment. For zsh, it is a regular comment indeed.
84 #   The numbers have got the following meanings:
85 #         0 -> "default"
86 #         1 -> "system"
87 #         2 -> "user"
88 #         3 -> "debian"
89 #         4 -> "search"
90 #         5 -> "shortcuts"
91 #         6 -> "services"
92 #
93 #   So, the following will add an entry to the 'functions' table in the
94 #   'system' section, with a (hopefully) descriptive comment:
95 #       #f1# Edit an alias via zle
96 #       edalias() {
97 #
98 #   It will then show up in the @@INSERT-aliases-system@@ replacement tag
99 #   that can be found in 'grml-zsh-refcard.tex.in'.
100 #   If the section number is omitted, the 'default' section is assumed.
101 #   Furthermore, in 'grml-zsh-refcard.tex.in' @@INSERT-aliases@@ is
102 #   exactly the same as @@INSERT-aliases-default@@. If you want a list of
103 #   *all* aliases, for example, use @@INSERT-aliases-all@@.
104
105 # zsh profiling
106 # just execute 'ZSH_PROFILE_RC=1 zsh' and run 'zprof' to get the details
107 if [[ $ZSH_PROFILE_RC -gt 0 ]] ; then
108     zmodload zsh/zprof
109 fi
110
111 # load .zshrc.pre to give the user the chance to overwrite the defaults
112 [[ -r ${ZDOTDIR:-${HOME}}/.zshrc.pre ]] && source ${ZDOTDIR:-${HOME}}/.zshrc.pre
113
114 # check for version/system
115 # check for versions (compatibility reasons)
116 function is4 () {
117     [[ $ZSH_VERSION == <4->* ]] && return 0
118     return 1
119 }
120
121 function is41 () {
122     [[ $ZSH_VERSION == 4.<1->* || $ZSH_VERSION == <5->* ]] && return 0
123     return 1
124 }
125
126 function is42 () {
127     [[ $ZSH_VERSION == 4.<2->* || $ZSH_VERSION == <5->* ]] && return 0
128     return 1
129 }
130
131 function is425 () {
132     [[ $ZSH_VERSION == 4.2.<5->* || $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
133     return 1
134 }
135
136 function is43 () {
137     [[ $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
138     return 1
139 }
140
141 function is433 () {
142     [[ $ZSH_VERSION == 4.3.<3->* || $ZSH_VERSION == 4.<4->* \
143                                  || $ZSH_VERSION == <5->* ]] && return 0
144     return 1
145 }
146
147 function is437 () {
148     [[ $ZSH_VERSION == 4.3.<7->* || $ZSH_VERSION == 4.<4->* \
149                                  || $ZSH_VERSION == <5->* ]] && return 0
150     return 1
151 }
152
153 function is439 () {
154     [[ $ZSH_VERSION == 4.3.<9->* || $ZSH_VERSION == 4.<4->* \
155                                  || $ZSH_VERSION == <5->* ]] && return 0
156     return 1
157 }
158
159 #f1# Checks whether or not you're running grml
160 function isgrml () {
161     [[ -f /etc/grml_version ]] && return 0
162     return 1
163 }
164
165 #f1# Checks whether or not you're running a grml cd
166 function isgrmlcd () {
167     [[ -f /etc/grml_cd ]] && return 0
168     return 1
169 }
170
171 if isgrml ; then
172 #f1# Checks whether or not you're running grml-small
173     function isgrmlsmall () {
174         if [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]]; then
175             return 0
176         fi
177         return 1
178     }
179 else
180     function isgrmlsmall () { return 1 }
181 fi
182
183 GRML_OSTYPE=$(uname -s)
184
185 function islinux () {
186     [[ $GRML_OSTYPE == "Linux" ]]
187 }
188
189 function isdarwin () {
190     [[ $GRML_OSTYPE == "Darwin" ]]
191 }
192
193 function isfreebsd () {
194     [[ $GRML_OSTYPE == "FreeBSD" ]]
195 }
196
197 function isopenbsd () {
198     [[ $GRML_OSTYPE == "OpenBSD" ]]
199 }
200
201 function issolaris () {
202     [[ $GRML_OSTYPE == "SunOS" ]]
203 }
204
205 #f1# are we running within an utf environment?
206 function isutfenv () {
207     case "$LANG $CHARSET $LANGUAGE" in
208         *utf*) return 0 ;;
209         *UTF*) return 0 ;;
210         *)     return 1 ;;
211     esac
212 }
213
214 # check for user, if not running as root set $SUDO to sudo
215 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
216
217 # change directory to home on first invocation of zsh
218 # important for rungetty -> autologin
219 # Thanks go to Bart Schaefer!
220 isgrml && function checkhome () {
221     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
222         export ALREADY_DID_CD_HOME=$HOME
223         cd
224     fi
225 }
226
227 # check for zsh v3.1.7+
228
229 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
230      || ${ZSH_VERSION} == 3.<2->.<->*    \
231      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
232
233     printf '-!-\n'
234     printf '-!- In this configuration we try to make use of features, that only\n'
235     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
236     printf '-!- used with a wide range of zsh versions, while using fairly\n'
237     printf '-!- advanced features in all supported versions.\n'
238     printf '-!-\n'
239     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
240     printf '-!-\n'
241     printf '-!- While this *may* work, it might as well fail.\n'
242     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
243     printf '-!-\n'
244     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
245     printf '-!- If it does today, you'\''ve been lucky.\n'
246     printf '-!-\n'
247     printf '-!- Ye been warned!\n'
248     printf '-!-\n'
249
250     function zstyle () { : }
251 fi
252
253 # autoload wrapper - use this one instead of autoload directly
254 # We need to define this function as early as this, because autoloading
255 # 'is-at-least()' needs it.
256 function zrcautoload () {
257     emulate -L zsh
258     setopt extended_glob
259     local fdir ffile
260     local -i ffound
261
262     ffile=$1
263     (( ffound = 0 ))
264     for fdir in ${fpath} ; do
265         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
266     done
267
268     (( ffound == 0 )) && return 1
269     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
270         autoload -U ${ffile} || return 1
271     else
272         autoload ${ffile} || return 1
273     fi
274     return 0
275 }
276
277 # The following is the ‘add-zsh-hook’ function from zsh upstream. It is
278 # included here to make the setup work with older versions of zsh (prior to
279 # 4.3.7) in which this function had a bug that triggers annoying errors during
280 # shell startup. This is exactly upstreams code from f0068edb4888a4d8fe94def,
281 # with just a few adjustments in coding style to make the function look more
282 # compact. This definition can be removed as soon as we raise the minimum
283 # version requirement to 4.3.7 or newer.
284 function add-zsh-hook () {
285     # Add to HOOK the given FUNCTION.
286     # HOOK is one of chpwd, precmd, preexec, periodic, zshaddhistory,
287     # zshexit, zsh_directory_name (the _functions subscript is not required).
288     #
289     # With -d, remove the function from the hook instead; delete the hook
290     # variable if it is empty.
291     #
292     # -D behaves like -d, but pattern characters are active in the function
293     # name, so any matching function will be deleted from the hook.
294     #
295     # Without -d, the FUNCTION is marked for autoload; -U is passed down to
296     # autoload if that is given, as are -z and -k. (This is harmless if the
297     # function is actually defined inline.)
298     emulate -L zsh
299     local -a hooktypes
300     hooktypes=(
301         chpwd precmd preexec periodic zshaddhistory zshexit
302         zsh_directory_name
303     )
304     local usage="Usage: $0 hook function\nValid hooks are:\n  $hooktypes"
305     local opt
306     local -a autoopts
307     integer del list help
308     while getopts "dDhLUzk" opt; do
309         case $opt in
310         (d) del=1 ;;
311         (D) del=2 ;;
312         (h) help=1 ;;
313         (L) list=1 ;;
314         ([Uzk]) autoopts+=(-$opt) ;;
315         (*) return 1 ;;
316         esac
317     done
318     shift $(( OPTIND - 1 ))
319     if (( list )); then
320         typeset -mp "(${1:-${(@j:|:)hooktypes}})_functions"
321         return $?
322     elif (( help || $# != 2 || ${hooktypes[(I)$1]} == 0 )); then
323         print -u$(( 2 - help )) $usage
324         return $(( 1 - help ))
325     fi
326     local hook="${1}_functions"
327     local fn="$2"
328     if (( del )); then
329         # delete, if hook is set
330         if (( ${(P)+hook} )); then
331             if (( del == 2 )); then
332                 set -A $hook ${(P)hook:#${~fn}}
333             else
334                 set -A $hook ${(P)hook:#$fn}
335             fi
336             # unset if no remaining entries --- this can give better
337             # performance in some cases
338             if (( ! ${(P)#hook} )); then
339                 unset $hook
340             fi
341         fi
342     else
343         if (( ${(P)+hook} )); then
344             if (( ${${(P)hook}[(I)$fn]} == 0 )); then
345                 set -A $hook ${(P)hook} $fn
346             fi
347         else
348             set -A $hook $fn
349         fi
350         autoload $autoopts -- $fn
351     fi
352 }
353
354 # Load is-at-least() for more precise version checks Note that this test will
355 # *always* fail, if the is-at-least function could not be marked for
356 # autoloading.
357 zrcautoload is-at-least || function is-at-least () { return 1 }
358
359 # set some important options (as early as possible)
360
361 # append history list to the history file; this is the default but we make sure
362 # because it's required for share_history.
363 setopt append_history
364
365 # import new commands from the history file also in other zsh-session
366 is4 && setopt share_history
367
368 # save each command's beginning timestamp and the duration to the history file
369 setopt extended_history
370
371 # If a new command line being added to the history list duplicates an older
372 # one, the older command is removed from the list
373 is4 && setopt histignorealldups
374
375 # remove command lines from the history list when the first character on the
376 # line is a space
377 setopt histignorespace
378
379 # if a command is issued that can't be executed as a normal command, and the
380 # command is the name of a directory, perform the cd command to that directory.
381 setopt auto_cd
382
383 # in order to use #, ~ and ^ for filename generation grep word
384 # *~(*.gz|*.bz|*.bz2|*.zip|*.Z) -> searches for word not in compressed files
385 # don't forget to quote '^', '~' and '#'!
386 setopt extended_glob
387
388 # display PID when suspending processes as well
389 setopt longlistjobs
390
391 # report the status of backgrounds jobs immediately
392 setopt notify
393
394 # whenever a command completion is attempted, make sure the entire command path
395 # is hashed first.
396 setopt hash_list_all
397
398 # not just at the end
399 setopt completeinword
400
401 # Don't send SIGHUP to background processes when the shell exits.
402 setopt nohup
403
404 # make cd push the old directory onto the directory stack.
405 setopt auto_pushd
406
407 # avoid "beep"ing
408 setopt nobeep
409
410 # don't push the same dir twice.
411 setopt pushd_ignore_dups
412
413 # * shouldn't match dotfiles. ever.
414 setopt noglobdots
415
416 # use zsh style word splitting
417 setopt noshwordsplit
418
419 # don't error out when unset parameters are used
420 setopt unset
421
422 # setting some default values
423 NOCOR=${NOCOR:-0}
424 NOMENU=${NOMENU:-0}
425 NOPRECMD=${NOPRECMD:-0}
426 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
427 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
428 GRML_DISPLAY_BATTERY=${GRML_DISPLAY_BATTERY:-${BATTERY:-0}}
429 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
430 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
431
432 typeset -ga ls_options
433 typeset -ga grep_options
434 if ls --color=auto / >/dev/null 2>&1; then
435     ls_options+=( --color=auto )
436 elif ls -G / >/dev/null 2>&1; then
437     ls_options+=( -G )
438 fi
439 if grep --color=auto -q "a" <<< "a" >/dev/null 2>&1; then
440     grep_options+=( --color=auto )
441 fi
442
443 # utility functions
444 # this function checks if a command exists and returns either true
445 # or false. This avoids using 'which' and 'whence', which will
446 # avoid problems with aliases for which on certain weird systems. :-)
447 # Usage: check_com [-c|-g] word
448 #   -c  only checks for external commands
449 #   -g  does the usual tests and also checks for global aliases
450 function check_com () {
451     emulate -L zsh
452     local -i comonly gatoo
453     comonly=0
454     gatoo=0
455
456     if [[ $1 == '-c' ]] ; then
457         comonly=1
458         shift 1
459     elif [[ $1 == '-g' ]] ; then
460         gatoo=1
461         shift 1
462     fi
463
464     if (( ${#argv} != 1 )) ; then
465         printf 'usage: check_com [-c|-g] <command>\n' >&2
466         return 1
467     fi
468
469     if (( comonly > 0 )) ; then
470         (( ${+commands[$1]}  )) && return 0
471         return 1
472     fi
473
474     if     (( ${+commands[$1]}    )) \
475         || (( ${+functions[$1]}   )) \
476         || (( ${+aliases[$1]}     )) \
477         || (( ${+reswords[(r)$1]} )) ; then
478         return 0
479     fi
480
481     if (( gatoo > 0 )) && (( ${+galiases[$1]} )) ; then
482         return 0
483     fi
484
485     return 1
486 }
487
488 # creates an alias and precedes the command with
489 # sudo if $EUID is not zero.
490 function salias () {
491     emulate -L zsh
492     local only=0 ; local multi=0
493     local key val
494     while getopts ":hao" opt; do
495         case $opt in
496             o) only=1 ;;
497             a) multi=1 ;;
498             h)
499                 printf 'usage: salias [-hoa] <alias-expression>\n'
500                 printf '  -h      shows this help text.\n'
501                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
502                 printf '          be careful using this option.\n'
503                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
504                 return 0
505                 ;;
506             *) salias -h >&2; return 1 ;;
507         esac
508     done
509     shift "$((OPTIND-1))"
510
511     if (( ${#argv} > 1 )) ; then
512         printf 'Too many arguments %s\n' "${#argv}"
513         return 1
514     fi
515
516     key="${1%%\=*}" ;  val="${1#*\=}"
517     if (( EUID == 0 )) && (( only == 0 )); then
518         alias -- "${key}=${val}"
519     elif (( EUID > 0 )) ; then
520         (( multi > 0 )) && val="${val// ; / ; sudo }"
521         alias -- "${key}=sudo ${val}"
522     fi
523
524     return 0
525 }
526
527 # Check if we can read given files and source those we can.
528 function xsource () {
529     if (( ${#argv} < 1 )) ; then
530         printf 'usage: xsource FILE(s)...\n' >&2
531         return 1
532     fi
533
534     while (( ${#argv} > 0 )) ; do
535         [[ -r "$1" ]] && source "$1"
536         shift
537     done
538     return 0
539 }
540
541 # Check if we can read a given file and 'cat(1)' it.
542 function xcat () {
543     emulate -L zsh
544     if (( ${#argv} != 1 )) ; then
545         printf 'usage: xcat FILE\n' >&2
546         return 1
547     fi
548
549     [[ -r $1 ]] && cat $1
550     return 0
551 }
552
553 # Remove these functions again, they are of use only in these
554 # setup files. This should be called at the end of .zshrc.
555 function xunfunction () {
556     emulate -L zsh
557     local -a funcs
558     local func
559     funcs=(salias xcat xsource xunfunction zrcautoload zrcautozle)
560     for func in $funcs ; do
561         [[ -n ${functions[$func]} ]] \
562             && unfunction $func
563     done
564     return 0
565 }
566
567 # this allows us to stay in sync with grml's zshrc and put own
568 # modifications in ~/.zshrc.local
569 function zrclocal () {
570     xsource "/etc/zsh/zshrc.local"
571     xsource "${ZDOTDIR:-${HOME}}/.zshrc.local"
572     return 0
573 }
574
575 # locale setup
576 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
577     xsource "/etc/default/locale"
578 fi
579
580 for var in LANG LC_ALL LC_MESSAGES ; do
581     [[ -n ${(P)var} ]] && export $var
582 done
583 builtin unset -v var
584
585 # set some variables
586 if check_com -c vim ; then
587 #v#
588     export EDITOR=${EDITOR:-vim}
589 else
590     export EDITOR=${EDITOR:-vi}
591 fi
592
593 #v#
594 export PAGER=${PAGER:-less}
595
596 #v#
597 export MAIL=${MAIL:-/var/mail/$USER}
598
599 # color setup for ls:
600 check_com -c dircolors && eval $(dircolors -b)
601 # color setup for ls on OS X / FreeBSD:
602 isdarwin && export CLICOLOR=1
603 isfreebsd && export CLICOLOR=1
604
605 # do MacPorts setup on darwin
606 if isdarwin && [[ -d /opt/local ]]; then
607     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
608     # zshenv.
609     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
610     MANPATH="/opt/local/share/man:$MANPATH"
611 fi
612 # do Fink setup on darwin
613 isdarwin && xsource /sw/bin/init.sh
614
615 # load our function and completion directories
616 for fdir in /usr/share/grml/zsh/completion /usr/share/grml/zsh/functions; do
617     fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
618 done
619 typeset -aU ffiles
620 ffiles=(/usr/share/grml/zsh/functions/**/[^_]*[^~](N.:t))
621 (( ${#ffiles} > 0 )) && autoload -U "${ffiles[@]}"
622 unset -v fdir ffiles
623
624 # support colors in less
625 export LESS_TERMCAP_mb=$'\E[01;31m'
626 export LESS_TERMCAP_md=$'\E[01;31m'
627 export LESS_TERMCAP_me=$'\E[0m'
628 export LESS_TERMCAP_se=$'\E[0m'
629 export LESS_TERMCAP_so=$'\E[01;44;33m'
630 export LESS_TERMCAP_ue=$'\E[0m'
631 export LESS_TERMCAP_us=$'\E[01;32m'
632
633 # mailchecks
634 MAILCHECK=30
635
636 # report about cpu-/system-/user-time of command if running longer than
637 # 5 seconds
638 REPORTTIME=5
639
640 # watch for everyone but me and root
641 watch=(notme root)
642
643 # automatically remove duplicates from these arrays
644 typeset -U path PATH cdpath CDPATH fpath FPATH manpath MANPATH
645
646 # Load a few modules
647 is4 && \
648 for mod in parameter complist deltochar mathfunc ; do
649     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
650 done && builtin unset -v mod
651
652 # autoload zsh modules when they are referenced
653 if is4 ; then
654     zmodload -a  zsh/stat    zstat
655     zmodload -a  zsh/zpty    zpty
656     zmodload -ap zsh/mapfile mapfile
657 fi
658
659 # completion system
660 COMPDUMPFILE=${COMPDUMPFILE:-${ZDOTDIR:-${HOME}}/.zcompdump}
661 if zrcautoload compinit ; then
662     compinit -d ${COMPDUMPFILE} || print 'Notice: no compinit available :('
663 else
664     print 'Notice: no compinit available :('
665     function compdef { }
666 fi
667
668 # completion system
669
670 # called later (via is4 && grmlcomp)
671 # note: use 'zstyle' for getting current settings
672 #         press ^xh (control-x h) for getting tags in context; ^x? (control-x ?) to run complete_debug with trace output
673 function grmlcomp () {
674     # TODO: This could use some additional information
675
676     # Make sure the completion system is initialised
677     (( ${+_comps} )) || return 1
678
679     # allow one error for every three characters typed in approximate completer
680     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
681
682     # don't complete backup files as executables
683     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
684
685     # start menu completion only if it could find no unambiguous initial string
686     zstyle ':completion:*:correct:*'       insert-unambiguous true
687     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
688     zstyle ':completion:*:correct:*'       original true
689
690     # activate color-completion
691     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
692
693     # format on completion
694     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
695
696     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
697     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
698
699     # insert all expansions for expand completer
700     zstyle ':completion:*:expand:*'        tag-order all-expansions
701     zstyle ':completion:*:history-words'   list false
702
703     # activate menu
704     zstyle ':completion:*:history-words'   menu yes
705
706     # ignore duplicate entries
707     zstyle ':completion:*:history-words'   remove-all-dups yes
708     zstyle ':completion:*:history-words'   stop yes
709
710     # match uppercase from lowercase
711     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
712
713     # separate matches into groups
714     zstyle ':completion:*:matches'         group 'yes'
715     zstyle ':completion:*'                 group-name ''
716
717     if [[ "$NOMENU" -eq 0 ]] ; then
718         # if there are more than 5 options allow selecting from a menu
719         zstyle ':completion:*'               menu select=5
720     else
721         # don't use any menus at all
722         setopt no_auto_menu
723     fi
724
725     zstyle ':completion:*:messages'        format '%d'
726     zstyle ':completion:*:options'         auto-description '%d'
727
728     # describe options in full
729     zstyle ':completion:*:options'         description 'yes'
730
731     # on processes completion complete all user processes
732     zstyle ':completion:*:processes'       command 'ps -au$USER'
733
734     # offer indexes before parameters in subscripts
735     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
736
737     # provide verbose completion information
738     zstyle ':completion:*'                 verbose true
739
740     # recent (as of Dec 2007) zsh versions are able to provide descriptions
741     # for commands (read: 1st word in the line) that it will list for the user
742     # to choose from. The following disables that, because it's not exactly fast.
743     zstyle ':completion:*:-command-:*:'    verbose false
744
745     # set format for warnings
746     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
747
748     # define files to ignore for zcompile
749     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
750     zstyle ':completion:correct:'          prompt 'correct to: %e'
751
752     # Ignore completion functions for commands you don't have:
753     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
754
755     # Provide more processes in completion of programs like killall:
756     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
757
758     # complete manual by their section
759     zstyle ':completion:*:manuals'    separate-sections true
760     zstyle ':completion:*:manuals.*'  insert-sections   true
761     zstyle ':completion:*:man:*'      menu yes select
762
763     # Search path for sudo completion
764     zstyle ':completion:*:sudo:*' command-path /usr/local/sbin \
765                                                /usr/local/bin  \
766                                                /usr/sbin       \
767                                                /usr/bin        \
768                                                /sbin           \
769                                                /bin            \
770                                                /usr/X11R6/bin
771
772     # provide .. as a completion
773     zstyle ':completion:*' special-dirs ..
774
775     # run rehash on completion so new installed program are found automatically:
776     function _force_rehash () {
777         (( CURRENT == 1 )) && rehash
778         return 1
779     }
780
781     ## correction
782     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
783     if [[ "$NOCOR" -gt 0 ]] ; then
784         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
785         setopt nocorrect
786     else
787         # try to be smart about when to use what completer...
788         setopt correct
789         zstyle -e ':completion:*' completer '
790             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
791                 _last_try="$HISTNO$BUFFER$CURSOR"
792                 reply=(_complete _match _ignored _prefix _files)
793             else
794                 if [[ $words[1] == (rm|mv) ]] ; then
795                     reply=(_complete _files)
796                 else
797                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
798                 fi
799             fi'
800     fi
801
802     # command for process lists, the local web server details and host completion
803     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
804
805     # Some functions, like _apt and _dpkg, are very slow. We can use a cache in
806     # order to speed things up
807     if [[ ${GRML_COMP_CACHING:-yes} == yes ]]; then
808         GRML_COMP_CACHE_DIR=${GRML_COMP_CACHE_DIR:-${ZDOTDIR:-$HOME}/.cache}
809         if [[ ! -d ${GRML_COMP_CACHE_DIR} ]]; then
810             command mkdir -p "${GRML_COMP_CACHE_DIR}"
811         fi
812         zstyle ':completion:*' use-cache  yes
813         zstyle ':completion:*:complete:*' cache-path "${GRML_COMP_CACHE_DIR}"
814     fi
815
816     # host completion
817     if is42 ; then
818         [[ -r ~/.ssh/config ]] && _ssh_config_hosts=(${${(s: :)${(ps:\t:)${${(@M)${(f)"$(<$HOME/.ssh/config)"}:#Host *}#Host }}}:#*[*?]*}) || _ssh_config_hosts=()
819         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
820         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
821     else
822         _ssh_config_hosts=()
823         _ssh_hosts=()
824         _etc_hosts=()
825     fi
826     hosts=(
827         $(hostname)
828         "$_ssh_config_hosts[@]"
829         "$_ssh_hosts[@]"
830         "$_etc_hosts[@]"
831         localhost
832     )
833     zstyle ':completion:*:hosts' hosts $hosts
834     # TODO: so, why is this here?
835     #  zstyle '*' hosts $hosts
836
837     # use generic completion system for programs not yet defined; (_gnu_generic works
838     # with commands that provide a --help option with "standard" gnu-like output.)
839     for compcom in cp deborphan df feh fetchipac gpasswd head hnb ipacsum mv \
840                    pal stow uname ; do
841         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
842     done; unset compcom
843
844     # see upgrade function in this file
845     compdef _hosts upgrade
846 }
847
848 # Keyboard setup: The following is based on the same code, we wrote for
849 # debian's setup. It ensures the terminal is in the right mode, when zle is
850 # active, so the values from $terminfo are valid. Therefore, this setup should
851 # work on all systems, that have support for `terminfo'. It also requires the
852 # zsh in use to have the `zsh/terminfo' module built.
853 #
854 # If you are customising your `zle-line-init()' or `zle-line-finish()'
855 # functions, make sure you call the following utility functions in there:
856 #
857 #     - zle-line-init():      zle-smkx
858 #     - zle-line-finish():    zle-rmkx
859
860 # Use emacs-like key bindings by default:
861 bindkey -e
862
863 # Custom widgets:
864
865 ## beginning-of-line OR beginning-of-buffer OR beginning of history
866 ## by: Bart Schaefer <schaefer@brasslantern.com>, Bernhard Tittelbach
867 function beginning-or-end-of-somewhere () {
868     local hno=$HISTNO
869     if [[ ( "${LBUFFER[-1]}" == $'\n' && "${WIDGET}" == beginning-of* ) || \
870       ( "${RBUFFER[1]}" == $'\n' && "${WIDGET}" == end-of* ) ]]; then
871         zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
872     else
873         zle .${WIDGET:s/somewhere/line-hist/} "$@"
874         if (( HISTNO != hno )); then
875             zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
876         fi
877     fi
878 }
879 zle -N beginning-of-somewhere beginning-or-end-of-somewhere
880 zle -N end-of-somewhere beginning-or-end-of-somewhere
881
882 # add a command line to the shells history without executing it
883 function commit-to-history () {
884     print -s ${(z)BUFFER}
885     zle send-break
886 }
887 zle -N commit-to-history
888
889 # only slash should be considered as a word separator:
890 function slash-backward-kill-word () {
891     local WORDCHARS="${WORDCHARS:s@/@}"
892     # zle backward-word
893     zle backward-kill-word
894 }
895 zle -N slash-backward-kill-word
896
897 # a generic accept-line wrapper
898
899 # This widget can prevent unwanted autocorrections from command-name
900 # to _command-name, rehash automatically on enter and call any number
901 # of builtin and user-defined widgets in different contexts.
902 #
903 # For a broader description, see:
904 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
905 #
906 # The code is imported from the file 'zsh/functions/accept-line' from
907 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
908 # distributed under the same terms as zsh itself.
909
910 # A newly added command will may not be found or will cause false
911 # correction attempts, if you got auto-correction set. By setting the
912 # following style, we force accept-line() to rehash, if it cannot
913 # find the first word on the command line in the $command[] hash.
914 zstyle ':acceptline:*' rehash true
915
916 function Accept-Line () {
917     setopt localoptions noksharrays
918     local -a subs
919     local -xi aldone
920     local sub
921     local alcontext=${1:-$alcontext}
922
923     zstyle -a ":acceptline:${alcontext}" actions subs
924
925     (( ${#subs} < 1 )) && return 0
926
927     (( aldone = 0 ))
928     for sub in ${subs} ; do
929         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
930         zle ${sub}
931
932         (( aldone > 0 )) && break
933     done
934 }
935
936 function Accept-Line-getdefault () {
937     emulate -L zsh
938     local default_action
939
940     zstyle -s ":acceptline:${alcontext}" default_action default_action
941     case ${default_action} in
942         ((accept-line|))
943             printf ".accept-line"
944             ;;
945         (*)
946             printf ${default_action}
947             ;;
948     esac
949 }
950
951 function Accept-Line-HandleContext () {
952     zle Accept-Line
953
954     default_action=$(Accept-Line-getdefault)
955     zstyle -T ":acceptline:${alcontext}" call_default \
956         && zle ${default_action}
957 }
958
959 function accept-line () {
960     setopt localoptions noksharrays
961     local -a cmdline
962     local -x alcontext
963     local buf com fname format msg default_action
964
965     alcontext='default'
966     buf="${BUFFER}"
967     cmdline=(${(z)BUFFER})
968     com="${cmdline[1]}"
969     fname="_${com}"
970
971     Accept-Line 'preprocess'
972
973     zstyle -t ":acceptline:${alcontext}" rehash \
974         && [[ -z ${commands[$com]} ]]           \
975         && rehash
976
977     if    [[ -n ${com}               ]] \
978        && [[ -n ${reswords[(r)$com]} ]] \
979        || [[ -n ${aliases[$com]}     ]] \
980        || [[ -n ${functions[$com]}   ]] \
981        || [[ -n ${builtins[$com]}    ]] \
982        || [[ -n ${commands[$com]}    ]] ; then
983
984         # there is something sensible to execute, just do it.
985         alcontext='normal'
986         Accept-Line-HandleContext
987
988         return
989     fi
990
991     if    [[ -o correct              ]] \
992        || [[ -o correctall           ]] \
993        && [[ -n ${functions[$fname]} ]] ; then
994
995         # nothing there to execute but there is a function called
996         # _command_name; a completion widget. Makes no sense to
997         # call it on the commandline, but the correct{,all} options
998         # will ask for it nevertheless, so warn the user.
999         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
1000             # Okay, we warned the user before, he called us again,
1001             # so have it his way.
1002             alcontext='force'
1003             Accept-Line-HandleContext
1004
1005             return
1006         fi
1007
1008         if zstyle -t ":acceptline:${alcontext}" nocompwarn ; then
1009             alcontext='normal'
1010             Accept-Line-HandleContext
1011         else
1012             # prepare warning message for the user, configurable via zstyle.
1013             zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
1014
1015             if [[ -z ${msg} ]] ; then
1016                 msg="%c will not execute and completion %f exists."
1017             fi
1018
1019             zformat -f msg "${msg}" "c:${com}" "f:${fname}"
1020
1021             zle -M -- "${msg}"
1022         fi
1023         return
1024     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
1025         # If we are here, the commandline contains something that is not
1026         # executable, which is neither subject to _command_name correction
1027         # and is not empty. might be a variable assignment
1028         alcontext='misc'
1029         Accept-Line-HandleContext
1030
1031         return
1032     fi
1033
1034     # If we got this far, the commandline only contains whitespace, or is empty.
1035     alcontext='empty'
1036     Accept-Line-HandleContext
1037 }
1038
1039 zle -N accept-line
1040 zle -N Accept-Line
1041 zle -N Accept-Line-HandleContext
1042
1043 # power completion / abbreviation expansion / buffer expansion
1044 # see http://zshwiki.org/home/examples/zleiab for details
1045 # less risky than the global aliases but powerful as well
1046 # just type the abbreviation key and afterwards 'ctrl-x .' to expand it
1047 declare -A abk
1048 setopt extendedglob
1049 setopt interactivecomments
1050 abk=(
1051 #   key   # value                  (#d additional doc string)
1052 #A# start
1053     '...'  '../..'
1054     '....' '../../..'
1055     'BG'   '& exit'
1056     'C'    '| wc -l'
1057     'G'    '|& grep '${grep_options:+"${grep_options[*]}"}
1058     'H'    '| head'
1059     'Hl'   ' --help |& less -r'    #d (Display help in pager)
1060     'L'    '| less'
1061     'LL'   '|& less -r'
1062     'M'    '| most'
1063     'N'    '&>/dev/null'           #d (No Output)
1064     'R'    '| tr A-z N-za-m'       #d (ROT13)
1065     'SL'   '| sort | less'
1066     'S'    '| sort -u'
1067     'T'    '| tail'
1068     'V'    '|& vim -'
1069 #A# end
1070     'co'   './configure && make && sudo make install'
1071 )
1072
1073 function zleiab () {
1074     emulate -L zsh
1075     setopt extendedglob
1076     local MATCH
1077
1078     LBUFFER=${LBUFFER%%(#m)[.\-+:|_a-zA-Z0-9]#}
1079     LBUFFER+=${abk[$MATCH]:-$MATCH}
1080 }
1081
1082 zle -N zleiab
1083
1084 function help-show-abk () {
1085   zle -M "$(print "Available abbreviations for expansion:"; print -a -C 2 ${(kv)abk})"
1086 }
1087
1088 zle -N help-show-abk
1089
1090 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
1091 function insert-datestamp () { LBUFFER+=${(%):-'%D{%Y-%m-%d}'}; }
1092 zle -N insert-datestamp
1093
1094 # press esc-m for inserting last typed word again (thanks to caphuso!)
1095 function insert-last-typed-word () { zle insert-last-word -- 0 -1 };
1096 zle -N insert-last-typed-word;
1097
1098 function grml-zsh-fg () {
1099   if (( ${#jobstates} )); then
1100     zle .push-input
1101     [[ -o hist_ignore_space ]] && BUFFER=' ' || BUFFER=''
1102     BUFFER="${BUFFER}fg"
1103     zle .accept-line
1104   else
1105     zle -M 'No background jobs. Doing nothing.'
1106   fi
1107 }
1108 zle -N grml-zsh-fg
1109
1110 # run command line as user root via sudo:
1111 function sudo-command-line () {
1112     [[ -z $BUFFER ]] && zle up-history
1113     if [[ $BUFFER != sudo\ * ]]; then
1114         BUFFER="sudo $BUFFER"
1115         CURSOR=$(( CURSOR+5 ))
1116     fi
1117 }
1118 zle -N sudo-command-line
1119
1120 ### jump behind the first word on the cmdline.
1121 ### useful to add options.
1122 function jump_after_first_word () {
1123     local words
1124     words=(${(z)BUFFER})
1125
1126     if (( ${#words} <= 1 )) ; then
1127         CURSOR=${#BUFFER}
1128     else
1129         CURSOR=${#${words[1]}}
1130     fi
1131 }
1132 zle -N jump_after_first_word
1133
1134 #f5# Create directory under cursor or the selected area
1135 function inplaceMkDirs () {
1136     # Press ctrl-xM to create the directory under the cursor or the selected area.
1137     # To select an area press ctrl-@ or ctrl-space and use the cursor.
1138     # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
1139     # directory does not exist yet -> press ctrl-XM and problem solved
1140     local PATHTOMKDIR
1141     if ((REGION_ACTIVE==1)); then
1142         local F=$MARK T=$CURSOR
1143         if [[ $F -gt $T ]]; then
1144             F=${CURSOR}
1145             T=${MARK}
1146         fi
1147         # get marked area from buffer and eliminate whitespace
1148         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
1149         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
1150     else
1151         local bufwords iword
1152         bufwords=(${(z)LBUFFER})
1153         iword=${#bufwords}
1154         bufwords=(${(z)BUFFER})
1155         PATHTOMKDIR="${(Q)bufwords[iword]}"
1156     fi
1157     [[ -z "${PATHTOMKDIR}" ]] && return 1
1158     PATHTOMKDIR=${~PATHTOMKDIR}
1159     if [[ -e "${PATHTOMKDIR}" ]]; then
1160         zle -M " path already exists, doing nothing"
1161     else
1162         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
1163         zle end-of-line
1164     fi
1165 }
1166
1167 zle -N inplaceMkDirs
1168
1169 #v1# set number of lines to display per page
1170 HELP_LINES_PER_PAGE=20
1171 #v1# set location of help-zle cache file
1172 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
1173 # helper function for help-zle, actually generates the help text
1174 function help_zle_parse_keybindings () {
1175     emulate -L zsh
1176     setopt extendedglob
1177     unsetopt ksharrays  #indexing starts at 1
1178
1179     #v1# choose files that help-zle will parse for keybindings
1180     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
1181
1182     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
1183         local load_cache=0
1184         local f
1185         for f ($HELPZLE_KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
1186         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
1187     fi
1188
1189     #fill with default keybindings, possibly to be overwriten in a file later
1190     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
1191     local -A help_zle_keybindings
1192     help_zle_keybindings['<Ctrl>@']="set MARK"
1193     help_zle_keybindings['<Ctrl>x<Ctrl>j']="vi-join lines"
1194     help_zle_keybindings['<Ctrl>x<Ctrl>b']="jump to matching brace"
1195     help_zle_keybindings['<Ctrl>x<Ctrl>u']="undo"
1196     help_zle_keybindings['<Ctrl>_']="undo"
1197     help_zle_keybindings['<Ctrl>x<Ctrl>f<c>']="find <c> in cmdline"
1198     help_zle_keybindings['<Ctrl>a']="goto beginning of line"
1199     help_zle_keybindings['<Ctrl>e']="goto end of line"
1200     help_zle_keybindings['<Ctrl>t']="transpose charaters"
1201     help_zle_keybindings['<Alt>t']="transpose words"
1202     help_zle_keybindings['<Alt>s']="spellcheck word"
1203     help_zle_keybindings['<Ctrl>k']="backward kill buffer"
1204     help_zle_keybindings['<Ctrl>u']="forward kill buffer"
1205     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
1206     help_zle_keybindings["<Alt>'"]="quote line"
1207     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
1208     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
1209     help_zle_keybindings['<Alt>u']="make next word Uppercase"
1210     help_zle_keybindings['<Alt>l']="make next word lowercase"
1211     help_zle_keybindings['<Ctrl>xd']="preview expansion under cursor"
1212     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
1213     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
1214     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
1215     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
1216     help_zle_keybindings['<Ctrl>v']="insert next keypress symbol literally (e.g. for bindkey)"
1217     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
1218     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
1219     help_zle_keybindings['<Alt>h']="show help/manpage for current command"
1220
1221     #init global variables
1222     unset help_zle_lines help_zle_sln
1223     typeset -g -a help_zle_lines
1224     typeset -g help_zle_sln=1
1225
1226     local k v f cline
1227     local lastkeybind_desc contents     #last description starting with #k# that we found
1228     local num_lines_elapsed=0            #number of lines between last description and keybinding
1229     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
1230     for f in $HELPZLE_KEYBINDING_FILES; do
1231         [[ -r "$f" ]] || continue   #not readable ? skip it
1232         contents="$(<$f)"
1233         for cline in "${(f)contents}"; do
1234             #zsh pattern: matches lines like: #k# ..............
1235             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
1236                 lastkeybind_desc="$match[*]"
1237                 num_lines_elapsed=0
1238             #zsh pattern: matches lines that set a keybinding using bind2map, bindkey or compdef -k
1239             #             ignores lines that are commentend out
1240             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
1241             elif [[ "$cline" == [^#]#(bind2maps[[:space:]](*)-s|bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
1242                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
1243                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
1244                     #substitute keybinding string with something readable
1245                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
1246                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
1247                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
1248                     help_zle_keybindings[${k}]=$lastkeybind_desc
1249                 fi
1250                 lastkeybind_desc=""
1251             else
1252               ((num_lines_elapsed++))
1253             fi
1254         done
1255     done
1256     unset contents
1257     #calculate length of keybinding column
1258     local kstrlen=0
1259     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
1260     #convert the assoc array into preformated lines, which we are able to sort
1261     for k v in ${(kv)help_zle_keybindings[@]}; do
1262         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
1263         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
1264     done
1265     #sort lines alphabetically
1266     help_zle_lines=("${(i)help_zle_lines[@]}")
1267     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
1268     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
1269     zcompile $HELP_ZLE_CACHE_FILE
1270 }
1271 typeset -g help_zle_sln
1272 typeset -g -a help_zle_lines
1273
1274 # Provides (partially autogenerated) help on keybindings and the zsh line editor
1275 function help-zle () {
1276     emulate -L zsh
1277     unsetopt ksharrays  #indexing starts at 1
1278     #help lines already generated ? no ? then do it
1279     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
1280     #already displayed all lines ? go back to the start
1281     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
1282     local sln=$help_zle_sln
1283     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
1284     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
1285     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
1286 }
1287 zle -N help-zle
1288
1289 ## complete word from currently visible Screen or Tmux buffer.
1290 if check_com -c screen || check_com -c tmux; then
1291     function _complete_screen_display () {
1292         [[ "$TERM" != "screen" ]] && return 1
1293
1294         local TMPFILE=$(mktemp)
1295         local -U -a _screen_display_wordlist
1296         trap "rm -f $TMPFILE" EXIT
1297
1298         # fill array with contents from screen hardcopy
1299         if ((${+TMUX})); then
1300             #works, but crashes tmux below version 1.4
1301             #luckily tmux -V option to ask for version, was also added in 1.4
1302             tmux -V &>/dev/null || return
1303             tmux -q capture-pane \; save-buffer -b 0 $TMPFILE \; delete-buffer -b 0
1304         else
1305             screen -X hardcopy $TMPFILE
1306             # screen sucks, it dumps in latin1, apparently always. so recode it
1307             # to system charset
1308             check_com recode && recode latin1 $TMPFILE
1309         fi
1310         _screen_display_wordlist=( ${(QQ)$(<$TMPFILE)} )
1311         # remove PREFIX to be completed from that array
1312         _screen_display_wordlist[${_screen_display_wordlist[(i)$PREFIX]}]=""
1313         compadd -a _screen_display_wordlist
1314     }
1315     #m# k CTRL-x\,\,\,S Complete word from GNU screen buffer
1316     bindkey -r "^xS"
1317     compdef -k _complete_screen_display complete-word '^xS'
1318 fi
1319
1320 # Load a few more functions and tie them to widgets, so they can be bound:
1321
1322 function zrcautozle () {
1323     emulate -L zsh
1324     local fnc=$1
1325     zrcautoload $fnc && zle -N $fnc
1326 }
1327
1328 function zrcgotwidget () {
1329     (( ${+widgets[$1]} ))
1330 }
1331
1332 function zrcgotkeymap () {
1333     [[ -n ${(M)keymaps:#$1} ]]
1334 }
1335
1336 zrcautozle insert-files
1337 zrcautozle edit-command-line
1338 zrcautozle insert-unicode-char
1339 if zrcautoload history-search-end; then
1340     zle -N history-beginning-search-backward-end history-search-end
1341     zle -N history-beginning-search-forward-end  history-search-end
1342 fi
1343 zle -C hist-complete complete-word _generic
1344 zstyle ':completion:hist-complete:*' completer _history
1345
1346 # The actual terminal setup hooks and bindkey-calls:
1347
1348 # An array to note missing features to ease diagnosis in case of problems.
1349 typeset -ga grml_missing_features
1350
1351 function zrcbindkey () {
1352     if (( ARGC )) && zrcgotwidget ${argv[-1]}; then
1353         bindkey "$@"
1354     fi
1355 }
1356
1357 function bind2maps () {
1358     local i sequence widget
1359     local -a maps
1360
1361     while [[ "$1" != "--" ]]; do
1362         maps+=( "$1" )
1363         shift
1364     done
1365     shift
1366
1367     if [[ "$1" == "-s" ]]; then
1368         shift
1369         sequence="$1"
1370     else
1371         sequence="${key[$1]}"
1372     fi
1373     widget="$2"
1374
1375     [[ -z "$sequence" ]] && return 1
1376
1377     for i in "${maps[@]}"; do
1378         zrcbindkey -M "$i" "$sequence" "$widget"
1379     done
1380 }
1381
1382 if (( ${+terminfo[smkx]} )) && (( ${+terminfo[rmkx]} )); then
1383     function zle-smkx () {
1384         emulate -L zsh
1385         printf '%s' ${terminfo[smkx]}
1386     }
1387     function zle-rmkx () {
1388         emulate -L zsh
1389         printf '%s' ${terminfo[rmkx]}
1390     }
1391     function zle-line-init () {
1392         zle-smkx
1393     }
1394     function zle-line-finish () {
1395         zle-rmkx
1396     }
1397     zle -N zle-line-init
1398     zle -N zle-line-finish
1399 else
1400     for i in {s,r}mkx; do
1401         (( ${+terminfo[$i]} )) || grml_missing_features+=($i)
1402     done
1403     unset i
1404 fi
1405
1406 typeset -A key
1407 key=(
1408     Home     "${terminfo[khome]}"
1409     End      "${terminfo[kend]}"
1410     Insert   "${terminfo[kich1]}"
1411     Delete   "${terminfo[kdch1]}"
1412     Up       "${terminfo[kcuu1]}"
1413     Down     "${terminfo[kcud1]}"
1414     Left     "${terminfo[kcub1]}"
1415     Right    "${terminfo[kcuf1]}"
1416     PageUp   "${terminfo[kpp]}"
1417     PageDown "${terminfo[knp]}"
1418     BackTab  "${terminfo[kcbt]}"
1419 )
1420
1421 # Guidelines for adding key bindings:
1422 #
1423 #   - Do not add hardcoded escape sequences, to enable non standard key
1424 #     combinations such as Ctrl-Meta-Left-Cursor. They are not easily portable.
1425 #
1426 #   - Adding Ctrl characters, such as '^b' is okay; note that '^b' and '^B' are
1427 #     the same key.
1428 #
1429 #   - All keys from the $key[] mapping are obviously okay.
1430 #
1431 #   - Most terminals send "ESC x" when Meta-x is pressed. Thus, sequences like
1432 #     '\ex' are allowed in here as well.
1433
1434 bind2maps emacs             -- Home   beginning-of-somewhere
1435 bind2maps       viins vicmd -- Home   vi-beginning-of-line
1436 bind2maps emacs             -- End    end-of-somewhere
1437 bind2maps       viins vicmd -- End    vi-end-of-line
1438 bind2maps emacs viins       -- Insert overwrite-mode
1439 bind2maps             vicmd -- Insert vi-insert
1440 bind2maps emacs             -- Delete delete-char
1441 bind2maps       viins vicmd -- Delete vi-delete-char
1442 bind2maps emacs viins vicmd -- Up     up-line-or-search
1443 bind2maps emacs viins vicmd -- Down   down-line-or-search
1444 bind2maps emacs             -- Left   backward-char
1445 bind2maps       viins vicmd -- Left   vi-backward-char
1446 bind2maps emacs             -- Right  forward-char
1447 bind2maps       viins vicmd -- Right  vi-forward-char
1448 #k# Perform abbreviation expansion
1449 bind2maps emacs viins       -- -s '^x.' zleiab
1450 #k# Display list of abbreviations that would expand
1451 bind2maps emacs viins       -- -s '^xb' help-show-abk
1452 #k# mkdir -p <dir> from string under cursor or marked area
1453 bind2maps emacs viins       -- -s '^xM' inplaceMkDirs
1454 #k# display help for keybindings and ZLE
1455 bind2maps emacs viins       -- -s '^xz' help-zle
1456 #k# Insert files and test globbing
1457 bind2maps emacs viins       -- -s "^xf" insert-files
1458 #k# Edit the current line in \kbd{\$EDITOR}
1459 bind2maps emacs viins       -- -s '\ee' edit-command-line
1460 #k# search history backward for entry beginning with typed text
1461 bind2maps emacs viins       -- -s '^xp' history-beginning-search-backward-end
1462 #k# search history forward for entry beginning with typed text
1463 bind2maps emacs viins       -- -s '^xP' history-beginning-search-forward-end
1464 #k# search history backward for entry beginning with typed text
1465 bind2maps emacs viins       -- PageUp history-beginning-search-backward-end
1466 #k# search history forward for entry beginning with typed text
1467 bind2maps emacs viins       -- PageDown history-beginning-search-forward-end
1468 bind2maps emacs viins       -- -s "^x^h" commit-to-history
1469 #k# Kill left-side word or everything up to next slash
1470 bind2maps emacs viins       -- -s '\ev' slash-backward-kill-word
1471 #k# Kill left-side word or everything up to next slash
1472 bind2maps emacs viins       -- -s '\e^h' slash-backward-kill-word
1473 #k# Kill left-side word or everything up to next slash
1474 bind2maps emacs viins       -- -s '\e^?' slash-backward-kill-word
1475 # Do history expansion on space:
1476 bind2maps emacs viins       -- -s ' ' magic-space
1477 #k# Trigger menu-complete
1478 bind2maps emacs viins       -- -s '\ei' menu-complete  # menu completion via esc-i
1479 #k# Insert a timestamp on the command line (yyyy-mm-dd)
1480 bind2maps emacs viins       -- -s '^ed' insert-datestamp
1481 #k# Insert last typed word
1482 bind2maps emacs viins       -- -s "\em" insert-last-typed-word
1483 #k# A smart shortcut for \kbd{fg<enter>}
1484 bind2maps emacs viins       -- -s '^z' grml-zsh-fg
1485 #k# prepend the current command with "sudo"
1486 bind2maps emacs viins       -- -s "^os" sudo-command-line
1487 #k# jump to after first word (for adding options)
1488 bind2maps emacs viins       -- -s '^x1' jump_after_first_word
1489 #k# complete word from history with menu
1490 bind2maps emacs viins       -- -s "^x^x" hist-complete
1491
1492 # insert unicode character
1493 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
1494 # See for example http://unicode.org/charts/ for unicode characters code
1495 #k# Insert Unicode character
1496 bind2maps emacs viins       -- -s '^xi' insert-unicode-char
1497
1498 # use the new *-pattern-* widgets for incremental history search
1499 if zrcgotwidget history-incremental-pattern-search-backward; then
1500     for seq wid in '^r' history-incremental-pattern-search-backward \
1501                    '^s' history-incremental-pattern-search-forward
1502     do
1503         bind2maps emacs viins vicmd -- -s $seq $wid
1504     done
1505     builtin unset -v seq wid
1506 fi
1507
1508 if zrcgotkeymap menuselect; then
1509     #m# k Shift-tab Perform backwards menu completion
1510     bind2maps menuselect -- BackTab reverse-menu-complete
1511
1512     #k# menu selection: pick item but stay in the menu
1513     bind2maps menuselect -- -s '\e^M' accept-and-menu-complete
1514     # also use + and INSERT since it's easier to press repeatedly
1515     bind2maps menuselect -- -s '+' accept-and-menu-complete
1516     bind2maps menuselect -- Insert accept-and-menu-complete
1517
1518     # accept a completion and try to complete again by using menu
1519     # completion; very useful with completing directories
1520     # by using 'undo' one's got a simple file browser
1521     bind2maps menuselect -- -s '^o' accept-and-infer-next-history
1522 fi
1523
1524 # Finally, here are still a few hardcoded escape sequences; Special sequences
1525 # like Ctrl-<Cursor-key> etc do suck a fair bit, because they are not
1526 # standardised and most of the time are not available in a terminals terminfo
1527 # entry.
1528 #
1529 # While we do not encourage adding bindings like these, we will keep these for
1530 # backward compatibility.
1531
1532 ## use Ctrl-left-arrow and Ctrl-right-arrow for jumping to word-beginnings on
1533 ## the command line.
1534 # URxvt sequences:
1535 bind2maps emacs viins vicmd -- -s '\eOc' forward-word
1536 bind2maps emacs viins vicmd -- -s '\eOd' backward-word
1537 # These are for xterm:
1538 bind2maps emacs viins vicmd -- -s '\e[1;5C' forward-word
1539 bind2maps emacs viins vicmd -- -s '\e[1;5D' backward-word
1540 ## the same for alt-left-arrow and alt-right-arrow
1541 # URxvt again:
1542 bind2maps emacs viins vicmd -- -s '\e\e[C' forward-word
1543 bind2maps emacs viins vicmd -- -s '\e\e[D' backward-word
1544 # Xterm again:
1545 bind2maps emacs viins vicmd -- -s '^[[1;3C' forward-word
1546 bind2maps emacs viins vicmd -- -s '^[[1;3D' backward-word
1547 # Also try ESC Left/Right:
1548 bind2maps emacs viins vicmd -- -s '\e'${key[Right]} forward-word
1549 bind2maps emacs viins vicmd -- -s '\e'${key[Left]}  backward-word
1550
1551 # autoloading
1552
1553 zrcautoload zmv
1554 zrcautoload zed
1555
1556 # we don't want to quote/espace URLs on our own...
1557 # if autoload -U url-quote-magic ; then
1558 #    zle -N self-insert url-quote-magic
1559 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
1560 # else
1561 #    print 'Notice: no url-quote-magic available :('
1562 # fi
1563 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
1564
1565 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
1566 alias run-help >&/dev/null && unalias run-help
1567 for rh in run-help{,-git,-ip,-openssl,-p4,-sudo,-svk,-svn}; do
1568     zrcautoload $rh
1569 done; unset rh
1570
1571 # command not found handling
1572
1573 (( ${COMMAND_NOT_FOUND} == 1 )) &&
1574 function command_not_found_handler () {
1575     emulate -L zsh
1576     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
1577         ${GRML_ZSH_CNF_HANDLER} $1
1578     fi
1579     return 1
1580 }
1581
1582 # history
1583
1584 #v#
1585 HISTFILE=${ZDOTDIR:-${HOME}}/.zsh_history
1586 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
1587 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
1588
1589 # dirstack handling
1590
1591 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
1592 DIRSTACKFILE=${DIRSTACKFILE:-${ZDOTDIR:-${HOME}}/.zdirs}
1593
1594 if zstyle -T ':grml:chpwd:dirstack' enable; then
1595     typeset -gaU GRML_PERSISTENT_DIRSTACK
1596     function grml_dirstack_filter () {
1597         local -a exclude
1598         local filter entry
1599         if zstyle -s ':grml:chpwd:dirstack' filter filter; then
1600             $filter $1 && return 0
1601         fi
1602         if zstyle -a ':grml:chpwd:dirstack' exclude exclude; then
1603             for entry in "${exclude[@]}"; do
1604                 [[ $1 == ${~entry} ]] && return 0
1605             done
1606         fi
1607         return 1
1608     }
1609
1610     function chpwd () {
1611         (( ZSH_SUBSHELL )) && return
1612         (( $DIRSTACKSIZE <= 0 )) && return
1613         [[ -z $DIRSTACKFILE ]] && return
1614         grml_dirstack_filter $PWD && return
1615         GRML_PERSISTENT_DIRSTACK=(
1616             $PWD "${(@)GRML_PERSISTENT_DIRSTACK[1,$DIRSTACKSIZE]}"
1617         )
1618         builtin print -l ${GRML_PERSISTENT_DIRSTACK} >! ${DIRSTACKFILE}
1619     }
1620
1621     if [[ -f ${DIRSTACKFILE} ]]; then
1622         # Enabling NULL_GLOB via (N) weeds out any non-existing
1623         # directories from the saved dir-stack file.
1624         dirstack=( ${(f)"$(< $DIRSTACKFILE)"}(N) )
1625         # "cd -" won't work after login by just setting $OLDPWD, so
1626         [[ -d $dirstack[1] ]] && cd -q $dirstack[1] && cd -q $OLDPWD
1627     fi
1628
1629     if zstyle -t ':grml:chpwd:dirstack' filter-on-load; then
1630         for i in "${dirstack[@]}"; do
1631             if ! grml_dirstack_filter "$i"; then
1632                 GRML_PERSISTENT_DIRSTACK=(
1633                     "${GRML_PERSISTENT_DIRSTACK[@]}"
1634                     $i
1635                 )
1636             fi
1637         done
1638     else
1639         GRML_PERSISTENT_DIRSTACK=( "${dirstack[@]}" )
1640     fi
1641 fi
1642
1643 # directory based profiles
1644
1645 if is433 ; then
1646
1647 # chpwd_profiles(): Directory Profiles, Quickstart:
1648 #
1649 # In .zshrc.local:
1650 #
1651 #   zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1652 #   zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1653 #   chpwd_profiles
1654 #
1655 # For details see the `grmlzshrc.5' manual page.
1656 function chpwd_profiles () {
1657     local profile context
1658     local -i reexecute
1659
1660     context=":chpwd:profiles:$PWD"
1661     zstyle -s "$context" profile profile || profile='default'
1662     zstyle -T "$context" re-execute && reexecute=1 || reexecute=0
1663
1664     if (( ${+parameters[CHPWD_PROFILE]} == 0 )); then
1665         typeset -g CHPWD_PROFILE
1666         local CHPWD_PROFILES_INIT=1
1667         (( ${+functions[chpwd_profiles_init]} )) && chpwd_profiles_init
1668     elif [[ $profile != $CHPWD_PROFILE ]]; then
1669         (( ${+functions[chpwd_leave_profile_$CHPWD_PROFILE]} )) \
1670             && chpwd_leave_profile_${CHPWD_PROFILE}
1671     fi
1672     if (( reexecute )) || [[ $profile != $CHPWD_PROFILE ]]; then
1673         (( ${+functions[chpwd_profile_$profile]} )) && chpwd_profile_${profile}
1674     fi
1675
1676     CHPWD_PROFILE="${profile}"
1677     return 0
1678 }
1679
1680 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1681
1682 fi # is433
1683
1684 # Prompt setup for grml:
1685
1686 # set colors for use in prompts (modern zshs allow for the use of %F{red}foo%f
1687 # in prompts to get a red "foo" embedded, but it's good to keep these for
1688 # backwards compatibility).
1689 if is437; then
1690     BLUE="%F{blue}"
1691     RED="%F{red}"
1692     GREEN="%F{green}"
1693     CYAN="%F{cyan}"
1694     MAGENTA="%F{magenta}"
1695     YELLOW="%F{yellow}"
1696     WHITE="%F{white}"
1697     NO_COLOR="%f"
1698 elif zrcautoload colors && colors 2>/dev/null ; then
1699     BLUE="%{${fg[blue]}%}"
1700     RED="%{${fg_bold[red]}%}"
1701     GREEN="%{${fg[green]}%}"
1702     CYAN="%{${fg[cyan]}%}"
1703     MAGENTA="%{${fg[magenta]}%}"
1704     YELLOW="%{${fg[yellow]}%}"
1705     WHITE="%{${fg[white]}%}"
1706     NO_COLOR="%{${reset_color}%}"
1707 else
1708     BLUE=$'%{\e[1;34m%}'
1709     RED=$'%{\e[1;31m%}'
1710     GREEN=$'%{\e[1;32m%}'
1711     CYAN=$'%{\e[1;36m%}'
1712     WHITE=$'%{\e[1;37m%}'
1713     MAGENTA=$'%{\e[1;35m%}'
1714     YELLOW=$'%{\e[1;33m%}'
1715     NO_COLOR=$'%{\e[0m%}'
1716 fi
1717
1718 # First, the easy ones: PS2..4:
1719
1720 # secondary prompt, printed when the shell needs more information to complete a
1721 # command.
1722 PS2='\`%_> '
1723 # selection prompt used within a select loop.
1724 PS3='?# '
1725 # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
1726 PS4='+%N:%i:%_> '
1727
1728 # Some additional features to use with our prompt:
1729 #
1730 #    - battery status
1731 #    - debian_chroot
1732 #    - vcs_info setup and version specific fixes
1733
1734 # display battery status on right side of prompt using 'GRML_DISPLAY_BATTERY=1' in .zshrc.pre
1735
1736 function battery () {
1737 if [[ $GRML_DISPLAY_BATTERY -gt 0 ]] ; then
1738     if islinux ; then
1739         batterylinux
1740     elif isopenbsd ; then
1741         batteryopenbsd
1742     elif isfreebsd ; then
1743         batteryfreebsd
1744     elif isdarwin ; then
1745         batterydarwin
1746     else
1747         #not yet supported
1748         GRML_DISPLAY_BATTERY=0
1749     fi
1750 fi
1751 }
1752
1753 function batterylinux () {
1754 GRML_BATTERY_LEVEL=''
1755 local batteries bat capacity
1756 batteries=( /sys/class/power_supply/BAT*(N) )
1757 if (( $#batteries > 0 )) ; then
1758     for bat in $batteries ; do
1759         if [[ -e $bat/capacity ]]; then
1760             capacity=$(< $bat/capacity)
1761         else
1762             typeset -F energy_full=$(< $bat/energy_full)
1763             typeset -F energy_now=$(< $bat/energy_now)
1764             typeset -i capacity=$(( 100 * $energy_now / $energy_full))
1765         fi
1766         case $(< $bat/status) in
1767         Charging)
1768             GRML_BATTERY_LEVEL+=" ^"
1769             ;;
1770         Discharging)
1771             if (( capacity < 20 )) ; then
1772                 GRML_BATTERY_LEVEL+=" !v"
1773             else
1774                 GRML_BATTERY_LEVEL+=" v"
1775             fi
1776             ;;
1777         *) # Full, Unknown
1778             GRML_BATTERY_LEVEL+=" ="
1779             ;;
1780         esac
1781         GRML_BATTERY_LEVEL+="${capacity}%%"
1782     done
1783 fi
1784 }
1785
1786 function batteryopenbsd () {
1787 GRML_BATTERY_LEVEL=''
1788 local bat batfull batwarn batnow num
1789 for num in 0 1 ; do
1790     bat=$(sysctl -n hw.sensors.acpibat${num} 2>/dev/null)
1791     if [[ -n $bat ]]; then
1792         batfull=${"$(sysctl -n hw.sensors.acpibat${num}.amphour0)"%% *}
1793         batwarn=${"$(sysctl -n hw.sensors.acpibat${num}.amphour1)"%% *}
1794         batnow=${"$(sysctl -n hw.sensors.acpibat${num}.amphour3)"%% *}
1795         case "$(sysctl -n hw.sensors.acpibat${num}.raw0)" in
1796             *" discharging"*)
1797                 if (( batnow < batwarn )) ; then
1798                     GRML_BATTERY_LEVEL+=" !v"
1799                 else
1800                     GRML_BATTERY_LEVEL+=" v"
1801                 fi
1802                 ;;
1803             *" charging"*)
1804                 GRML_BATTERY_LEVEL+=" ^"
1805                 ;;
1806             *)
1807                 GRML_BATTERY_LEVEL+=" ="
1808                 ;;
1809         esac
1810         GRML_BATTERY_LEVEL+="${$(( 100 * batnow / batfull ))%%.*}%%"
1811     fi
1812 done
1813 }
1814
1815 function batteryfreebsd () {
1816 GRML_BATTERY_LEVEL=''
1817 local num
1818 local -A table
1819 for num in 0 1 ; do
1820     table=( ${=${${${${${(M)${(f)"$(acpiconf -i $num 2>&1)"}:#(State|Remaining capacity):*}%%( ##|%)}//:[ $'\t']##/@}// /-}//@/ }} )
1821     if [[ -n $table ]] && [[ $table[State] != "not-present" ]] ; then
1822         case $table[State] in
1823             *discharging*)
1824                 if (( $table[Remaining-capacity] < 20 )) ; then
1825                     GRML_BATTERY_LEVEL+=" !v"
1826                 else
1827                     GRML_BATTERY_LEVEL+=" v"
1828                 fi
1829                 ;;
1830             *charging*)
1831                 GRML_BATTERY_LEVEL+=" ^"
1832                 ;;
1833             *)
1834                 GRML_BATTERY_LEVEL+=" ="
1835                 ;;
1836         esac
1837         GRML_BATTERY_LEVEL+="$table[Remaining-capacity]%%"
1838     fi
1839 done
1840 }
1841
1842 function batterydarwin () {
1843 GRML_BATTERY_LEVEL=''
1844 local -a table
1845 table=( ${$(pmset -g ps)[(w)7,8]%%(\%|);} )
1846 if [[ -n $table[2] ]] ; then
1847     case $table[2] in
1848         charging)
1849             GRML_BATTERY_LEVEL+=" ^"
1850             ;;
1851         discharging)
1852             if (( $table[1] < 20 )) ; then
1853                 GRML_BATTERY_LEVEL+=" !v"
1854             else
1855                 GRML_BATTERY_LEVEL+=" v"
1856             fi
1857             ;;
1858         *)
1859             GRML_BATTERY_LEVEL+=" ="
1860             ;;
1861     esac
1862     GRML_BATTERY_LEVEL+="$table[1]%%"
1863 fi
1864 }
1865
1866 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
1867 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
1868     debian_chroot=$(</etc/debian_chroot)
1869 fi
1870
1871 # gather version control information for inclusion in a prompt
1872
1873 if zrcautoload vcs_info; then
1874     # `vcs_info' in zsh versions 4.3.10 and below have a broken `_realpath'
1875     # function, which can cause a lot of trouble with our directory-based
1876     # profiles. So:
1877     if [[ ${ZSH_VERSION} == 4.3.<-10> ]] ; then
1878         function VCS_INFO_realpath () {
1879             setopt localoptions NO_shwordsplit chaselinks
1880             ( builtin cd -q $1 2> /dev/null && pwd; )
1881         }
1882     fi
1883
1884     zstyle ':vcs_info:*' max-exports 2
1885
1886     if [[ -o restricted ]]; then
1887         zstyle ':vcs_info:*' enable NONE
1888     fi
1889 fi
1890
1891 typeset -A grml_vcs_coloured_formats
1892 typeset -A grml_vcs_plain_formats
1893
1894 grml_vcs_plain_formats=(
1895     format "(%s%)-[%b] "    "zsh: %r"
1896     actionformat "(%s%)-[%b|%a] " "zsh: %r"
1897     rev-branchformat "%b:%r"
1898 )
1899
1900 grml_vcs_coloured_formats=(
1901     format "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOR} "
1902     actionformat "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOR} "
1903     rev-branchformat "%b${RED}:${YELLOW}%r"
1904 )
1905
1906 typeset GRML_VCS_COLOUR_MODE=xxx
1907
1908 function grml_vcs_info_toggle_colour () {
1909     emulate -L zsh
1910     if [[ $GRML_VCS_COLOUR_MODE == plain ]]; then
1911         grml_vcs_info_set_formats coloured
1912     else
1913         grml_vcs_info_set_formats plain
1914     fi
1915     return 0
1916 }
1917
1918 function grml_vcs_info_set_formats () {
1919     emulate -L zsh
1920     #setopt localoptions xtrace
1921     local mode=$1 AF F BF
1922     if [[ $mode == coloured ]]; then
1923         AF=${grml_vcs_coloured_formats[actionformat]}
1924         F=${grml_vcs_coloured_formats[format]}
1925         BF=${grml_vcs_coloured_formats[rev-branchformat]}
1926         GRML_VCS_COLOUR_MODE=coloured
1927     else
1928         AF=${grml_vcs_plain_formats[actionformat]}
1929         F=${grml_vcs_plain_formats[format]}
1930         BF=${grml_vcs_plain_formats[rev-branchformat]}
1931         GRML_VCS_COLOUR_MODE=plain
1932     fi
1933
1934     zstyle ':vcs_info:*'              actionformats "$AF" "zsh: %r"
1935     zstyle ':vcs_info:*'              formats       "$F"  "zsh: %r"
1936     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat  "$BF"
1937     return 0
1938 }
1939
1940 # Change vcs_info formats for the grml prompt. The 2nd format sets up
1941 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
1942 if [[ "$TERM" == dumb ]] ; then
1943     grml_vcs_info_set_formats plain
1944 else
1945     grml_vcs_info_set_formats coloured
1946 fi
1947
1948 # Now for the fun part: The grml prompt themes in `promptsys' mode of operation
1949
1950 # This actually defines three prompts:
1951 #
1952 #    - grml
1953 #    - grml-large
1954 #    - grml-chroot
1955 #
1956 # They all share the same code and only differ with respect to which items they
1957 # contain. The main source of documentation is the `prompt_grml_help' function
1958 # below, which gets called when the user does this: prompt -h grml
1959
1960 function prompt_grml_help () {
1961     <<__EOF0__
1962   prompt grml
1963
1964     This is the prompt as used by the grml-live system <http://grml.org>. It is
1965     a rather simple one-line prompt, that by default looks something like this:
1966
1967         <user>@<host> <current-working-directory>[ <vcs_info-data>]%
1968
1969     The prompt itself integrates with zsh's prompt themes system (as you are
1970     witnessing right now) and is configurable to a certain degree. In
1971     particular, these aspects are customisable:
1972
1973         - The items used in the prompt (e.g. you can remove \`user' from
1974           the list of activated items, which will cause the user name to
1975           be omitted from the prompt string).
1976
1977         - The attributes used with the items are customisable via strings
1978           used before and after the actual item.
1979
1980     The available items are: at, battery, change-root, date, grml-chroot,
1981     history, host, jobs, newline, path, percent, rc, rc-always, sad-smiley,
1982     shell-level, time, user, vcs
1983
1984     The actual configuration is done via zsh's \`zstyle' mechanism. The
1985     context, that is used while looking up styles is:
1986
1987         ':prompt:grml:<left-or-right>:<subcontext>'
1988
1989     Here <left-or-right> is either \`left' or \`right', signifying whether the
1990     style should affect the left or the right prompt. <subcontext> is either
1991     \`setup' or 'items:<item>', where \`<item>' is one of the available items.
1992
1993     The styles:
1994
1995         - use-rprompt (boolean): If \`true' (the default), print a sad smiley
1996           in $RPROMPT if the last command a returned non-successful error code.
1997           (This in only valid if <left-or-right> is "right"; ignored otherwise)
1998
1999         - items (list): The list of items used in the prompt. If \`vcs' is
2000           present in the list, the theme's code invokes \`vcs_info'
2001           accordingly. Default (left): rc change-root user at host path vcs
2002           percent; Default (right): sad-smiley
2003
2004         - strip-sensitive-characters (boolean): If the \`prompt_subst' option
2005           is active in zsh, the shell performs lots of expansions on prompt
2006           variable strings, including command substitution. So if you don't
2007           control where some of your prompt strings is coming from, this is
2008           an exploitable weakness. Grml's zsh setup does not set this option
2009           and it is off in the shell in zsh-mode by default. If it *is* turned
2010           on however, this style becomes active, and there are two flavours of
2011           it: On per default is a global variant in the '*:setup' context. This
2012           strips characters after the whole prompt string was constructed. There
2013           is a second variant in the '*:items:<item>', that is off by default.
2014           It allows fine grained control over which items' data is stripped.
2015           The characters that are stripped are: \$ and \`.
2016
2017     Available styles in 'items:<item>' are: pre, post. These are strings that
2018     are inserted before (pre) and after (post) the item in question. Thus, the
2019     following would cause the user name to be printed in red instead of the
2020     default blue:
2021
2022         zstyle ':prompt:grml:*:items:user' pre '%F{red}'
2023
2024     Note, that the \`post' style may remain at its default value, because its
2025     default value is '%f', which turns the foreground text attribute off (which
2026     is exactly, what is still required with the new \`pre' value).
2027 __EOF0__
2028 }
2029
2030 function prompt_grml-chroot_help () {
2031     <<__EOF0__
2032   prompt grml-chroot
2033
2034     This is a variation of the grml prompt, see: prompt -h grml
2035
2036     The main difference is the default value of the \`items' style. The rest
2037     behaves exactly the same. Here are the defaults for \`grml-chroot':
2038
2039         - left: grml-chroot user at host path percent
2040         - right: (empty list)
2041 __EOF0__
2042 }
2043
2044 function prompt_grml-large_help () {
2045     <<__EOF0__
2046   prompt grml-large
2047
2048     This is a variation of the grml prompt, see: prompt -h grml
2049
2050     The main difference is the default value of the \`items' style. In
2051     particular, this theme uses _two_ lines instead of one with the plain
2052     \`grml' theme. The rest behaves exactly the same. Here are the defaults
2053     for \`grml-large':
2054
2055         - left: rc jobs history shell-level change-root time date newline user
2056                 at host path vcs percent
2057         - right: sad-smiley
2058 __EOF0__
2059 }
2060
2061 function grml_prompt_setup () {
2062     emulate -L zsh
2063     autoload -Uz vcs_info
2064     # The following autoload is disabled for now, since this setup includes a
2065     # static version of the ‘add-zsh-hook’ function above. It needs to be
2066     # reenabled as soon as that static definition is removed again.
2067     #autoload -Uz add-zsh-hook
2068     add-zsh-hook precmd prompt_$1_precmd
2069 }
2070
2071 function prompt_grml_setup () {
2072     grml_prompt_setup grml
2073 }
2074
2075 function prompt_grml-chroot_setup () {
2076     grml_prompt_setup grml-chroot
2077 }
2078
2079 function prompt_grml-large_setup () {
2080     grml_prompt_setup grml-large
2081 }
2082
2083 # These maps define default tokens and pre-/post-decoration for items to be
2084 # used within the themes. All defaults may be customised in a context sensitive
2085 # matter by using zsh's `zstyle' mechanism.
2086 typeset -gA grml_prompt_pre_default \
2087             grml_prompt_post_default \
2088             grml_prompt_token_default \
2089             grml_prompt_token_function
2090
2091 grml_prompt_pre_default=(
2092     at                ''
2093     battery           ' '
2094     change-root       ''
2095     date              '%F{blue}'
2096     grml-chroot       '%F{red}'
2097     history           '%F{green}'
2098     host              ''
2099     jobs              '%F{cyan}'
2100     newline           ''
2101     path              '%B'
2102     percent           ''
2103     rc                '%B%F{red}'
2104     rc-always         ''
2105     sad-smiley        ''
2106     shell-level       '%F{red}'
2107     time              '%F{blue}'
2108     user              '%B%F{blue}'
2109     vcs               ''
2110 )
2111
2112 grml_prompt_post_default=(
2113     at                ''
2114     battery           ''
2115     change-root       ''
2116     date              '%f'
2117     grml-chroot       '%f '
2118     history           '%f'
2119     host              ''
2120     jobs              '%f'
2121     newline           ''
2122     path              '%b'
2123     percent           ''
2124     rc                '%f%b'
2125     rc-always         ''
2126     sad-smiley        ''
2127     shell-level       '%f'
2128     time              '%f'
2129     user              '%f%b'
2130     vcs               ''
2131 )
2132
2133 grml_prompt_token_default=(
2134     at                '@'
2135     battery           'GRML_BATTERY_LEVEL'
2136     change-root       'debian_chroot'
2137     date              '%D{%Y-%m-%d}'
2138     grml-chroot       'GRML_CHROOT'
2139     history           '{history#%!} '
2140     host              '%m '
2141     jobs              '[%j running job(s)] '
2142     newline           $'\n'
2143     path              '%40<..<%~%<< '
2144     percent           '%# '
2145     rc                '%(?..%? )'
2146     rc-always         '%?'
2147     sad-smiley        '%(?..:()'
2148     shell-level       '%(3L.+ .)'
2149     time              '%D{%H:%M:%S} '
2150     user              '%n'
2151     vcs               '0'
2152 )
2153
2154 function grml_theme_has_token () {
2155     if (( ARGC != 1 )); then
2156         printf 'usage: grml_theme_has_token <name>\n'
2157         return 1
2158     fi
2159     (( ${+grml_prompt_token_default[$1]} ))
2160 }
2161
2162 function GRML_theme_add_token_usage () {
2163     <<__EOF0__
2164   Usage: grml_theme_add_token <name> [-f|-i] <token/function> [<pre> <post>]
2165
2166     <name> is the name for the newly added token. If the \`-f' or \`-i' options
2167     are used, <token/function> is the name of the function (see below for
2168     details). Otherwise it is the literal token string to be used. <pre> and
2169     <post> are optional.
2170
2171   Options:
2172
2173     -f <function>   Use a function named \`<function>' each time the token
2174                     is to be expanded.
2175
2176     -i <function>   Use a function named \`<function>' to initialise the
2177                     value of the token _once_ at runtime.
2178
2179     The functions are called with one argument: the token's new name. The
2180     return value is expected in the \$REPLY parameter. The use of these
2181     options is mutually exclusive.
2182
2183     There is a utility function \`grml_theme_has_token', which you can use
2184     to test if a token exists before trying to add it. This can be a guard
2185     for situations in which a \`grml_theme_add_token' call may happen more
2186     than once.
2187
2188   Example:
2189
2190     To add a new token \`day' that expands to the current weekday in the
2191     current locale in green foreground colour, use this:
2192
2193       grml_theme_add_token day '%D{%A}' '%F{green}' '%f'
2194
2195     Another example would be support for \$VIRTUAL_ENV:
2196
2197       function virtual_env_prompt () {
2198         REPLY=\${VIRTUAL_ENV+\${VIRTUAL_ENV:t} }
2199       }
2200       grml_theme_add_token virtual-env -f virtual_env_prompt
2201
2202     After that, you will be able to use a changed \`items' style to
2203     assemble your prompt.
2204 __EOF0__
2205 }
2206
2207 function grml_theme_add_token () {
2208     emulate -L zsh
2209     local name token pre post
2210     local -i init funcall
2211
2212     if (( ARGC == 0 )); then
2213         GRML_theme_add_token_usage
2214         return 0
2215     fi
2216
2217     init=0
2218     funcall=0
2219     pre=''
2220     post=''
2221     name=$1
2222     shift
2223     if [[ $1 == '-f' ]]; then
2224         funcall=1
2225         shift
2226     elif [[ $1 == '-i' ]]; then
2227         init=1
2228         shift
2229     fi
2230
2231     if (( ARGC == 0 )); then
2232         printf '
2233 grml_theme_add_token: No token-string/function-name provided!\n\n'
2234         GRML_theme_add_token_usage
2235         return 1
2236     fi
2237     token=$1
2238     shift
2239     if (( ARGC != 0 && ARGC != 2 )); then
2240         printf '
2241 grml_theme_add_token: <pre> and <post> need to by specified _both_!\n\n'
2242         GRML_theme_add_token_usage
2243         return 1
2244     fi
2245     if (( ARGC )); then
2246         pre=$1
2247         post=$2
2248         shift 2
2249     fi
2250
2251     if grml_theme_has_token $name; then
2252         printf '
2253 grml_theme_add_token: Token `%s'\'' exists! Giving up!\n\n' $name
2254         GRML_theme_add_token_usage
2255         return 2
2256     fi
2257     if (( init )); then
2258         $token $name
2259         token=$REPLY
2260     fi
2261     grml_prompt_pre_default[$name]=$pre
2262     grml_prompt_post_default[$name]=$post
2263     if (( funcall )); then
2264         grml_prompt_token_function[$name]=$token
2265         grml_prompt_token_default[$name]=23
2266     else
2267         grml_prompt_token_default[$name]=$token
2268     fi
2269 }
2270
2271 function grml_wrap_reply () {
2272     emulate -L zsh
2273     local target="$1"
2274     local new="$2"
2275     local left="$3"
2276     local right="$4"
2277
2278     if (( ${+parameters[$new]} )); then
2279         REPLY="${left}${(P)new}${right}"
2280     else
2281         REPLY=''
2282     fi
2283 }
2284
2285 function grml_prompt_addto () {
2286     emulate -L zsh
2287     local target="$1"
2288     local lr it apre apost new v REPLY
2289     local -a items
2290     shift
2291
2292     [[ $target == PS1 ]] && lr=left || lr=right
2293     zstyle -a ":prompt:${grmltheme}:${lr}:setup" items items || items=( "$@" )
2294     typeset -g "${target}="
2295     for it in "${items[@]}"; do
2296         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" pre apre \
2297             || apre=${grml_prompt_pre_default[$it]}
2298         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" post apost \
2299             || apost=${grml_prompt_post_default[$it]}
2300         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" token new \
2301             || new=${grml_prompt_token_default[$it]}
2302         if (( ${+grml_prompt_token_function[$it]} )); then
2303             ${grml_prompt_token_function[$it]} $it
2304         else
2305             case $it in
2306             battery)
2307                 grml_wrap_reply $target $new '' ''
2308                 ;;
2309             change-root)
2310                 grml_wrap_reply $target $new '(' ')'
2311                 ;;
2312             grml-chroot)
2313                 if [[ -n ${(P)new} ]]; then
2314                     REPLY="$CHROOT"
2315                 else
2316                     REPLY=''
2317                 fi
2318                 ;;
2319             vcs)
2320                 v="vcs_info_msg_${new}_"
2321                 if (( ! vcscalled )); then
2322                     vcs_info
2323                     vcscalled=1
2324                 fi
2325                 if (( ${+parameters[$v]} )) && [[ -n "${(P)v}" ]]; then
2326                     REPLY="${(P)v}"
2327                 else
2328                     REPLY=''
2329                 fi
2330                 ;;
2331             *) REPLY="$new" ;;
2332             esac
2333         fi
2334         # Strip volatile characters per item. This is off by default. See the
2335         # global stripping code a few lines below for details.
2336         if [[ -o prompt_subst ]] && zstyle -t ":prompt:${grmltheme}:${lr}:items:$it" \
2337                                            strip-sensitive-characters
2338         then
2339             REPLY="${REPLY//[$\`]/}"
2340         fi
2341         typeset -g "${target}=${(P)target}${apre}${REPLY}${apost}"
2342     done
2343
2344     # Per default, strip volatile characters (in the prompt_subst case)
2345     # globally. If the option is off, the style has no effect. For more
2346     # control, this can be turned off and stripping can be configured on a
2347     # per-item basis (see above).
2348     if [[ -o prompt_subst ]] && zstyle -T ":prompt:${grmltheme}:${lr}:setup" \
2349                                        strip-sensitive-characters
2350     then
2351         typeset -g "${target}=${${(P)target}//[$\`]/}"
2352     fi
2353 }
2354
2355 function prompt_grml_precmd () {
2356     emulate -L zsh
2357     local grmltheme=grml
2358     local -a left_items right_items
2359     left_items=(rc change-root user at host path vcs percent)
2360     right_items=(sad-smiley)
2361
2362     prompt_grml_precmd_worker
2363 }
2364
2365 function prompt_grml-chroot_precmd () {
2366     emulate -L zsh
2367     local grmltheme=grml-chroot
2368     local -a left_items right_items
2369     left_items=(grml-chroot user at host path percent)
2370     right_items=()
2371
2372     prompt_grml_precmd_worker
2373 }
2374
2375 function prompt_grml-large_precmd () {
2376     emulate -L zsh
2377     local grmltheme=grml-large
2378     local -a left_items right_items
2379     left_items=(rc jobs history shell-level change-root time date newline
2380                 user at host path vcs percent)
2381     right_items=(sad-smiley)
2382
2383     prompt_grml_precmd_worker
2384 }
2385
2386 function prompt_grml_precmd_worker () {
2387     emulate -L zsh
2388     local -i vcscalled=0
2389
2390     grml_prompt_addto PS1 "${left_items[@]}"
2391     if zstyle -T ":prompt:${grmltheme}:right:setup" use-rprompt; then
2392         grml_prompt_addto RPS1 "${right_items[@]}"
2393     fi
2394 }
2395
2396 function grml_prompt_fallback () {
2397     setopt prompt_subst
2398     local p0 p1
2399
2400     p0="${RED}%(?..%? )${WHITE}${debian_chroot:+($debian_chroot)}"
2401     p1="${BLUE}%n${NO_COLOR}@%m %40<...<%B%~%b%<< "'${vcs_info_msg_0_}'"%# "
2402     if (( EUID == 0 )); then
2403         PROMPT="${BLUE}${p0}${RED}${p1}"
2404     else
2405         PROMPT="${RED}${p0}${BLUE}${p1}"
2406     fi
2407 }
2408
2409 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2410     # Since we define the required functions in here and not in files in
2411     # $fpath, we need to stick the theme's name into `$prompt_themes'
2412     # ourselves, since promptinit does not pick them up otherwise.
2413     prompt_themes+=( grml grml-chroot grml-large )
2414     # Also, keep the array sorted...
2415     prompt_themes=( "${(@on)prompt_themes}" )
2416 else
2417     print 'Notice: no promptinit available :('
2418     grml_prompt_fallback
2419     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2420 fi
2421
2422 if is437; then
2423     # The prompt themes use modern features of zsh, that require at least
2424     # version 4.3.7 of the shell. Use the fallback otherwise.
2425     if [[ $GRML_DISPLAY_BATTERY -gt 0 ]]; then
2426         zstyle ':prompt:grml:right:setup' items sad-smiley battery
2427         add-zsh-hook precmd battery
2428     fi
2429     if [[ "$TERM" == dumb ]] ; then
2430         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" pre ''
2431         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" post ' '
2432         for i in rc user path jobs history date time shell-level; do
2433             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" pre ''
2434             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" post ''
2435         done
2436         unset i
2437         zstyle ':prompt:grml(|-large|-chroot):right:setup' use-rprompt false
2438     elif (( EUID == 0 )); then
2439         zstyle ':prompt:grml(|-large|-chroot):*:items:user' pre '%B%F{red}'
2440     fi
2441
2442     # Finally enable one of the prompts.
2443     if [[ -n $GRML_CHROOT ]]; then
2444         prompt grml-chroot
2445     elif [[ $GRMLPROMPT -gt 0 ]]; then
2446         prompt grml-large
2447     else
2448         prompt grml
2449     fi
2450 else
2451     grml_prompt_fallback
2452     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2453 fi
2454
2455 # Terminal-title wizardry
2456
2457 function ESC_print () {
2458     info_print $'\ek' $'\e\\' "$@"
2459 }
2460 function set_title () {
2461     info_print  $'\e]0;' $'\a' "$@"
2462 }
2463
2464 function info_print () {
2465     local esc_begin esc_end
2466     esc_begin="$1"
2467     esc_end="$2"
2468     shift 2
2469     printf '%s' ${esc_begin}
2470     printf '%s' "$*"
2471     printf '%s' "${esc_end}"
2472 }
2473
2474 function grml_reset_screen_title () {
2475     # adjust title of xterm
2476     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2477     [[ ${NOTITLE:-} -gt 0 ]] && return 0
2478     case $TERM in
2479         (xterm*|rxvt*)
2480             set_title ${(%):-"%n@%m: %~"}
2481             ;;
2482     esac
2483 }
2484
2485 function grml_vcs_to_screen_title () {
2486     if [[ $TERM == screen* ]] ; then
2487         if [[ -n ${vcs_info_msg_1_} ]] ; then
2488             ESC_print ${vcs_info_msg_1_}
2489         else
2490             ESC_print "zsh"
2491         fi
2492     fi
2493 }
2494
2495 function grml_maintain_name () {
2496     # set hostname if not running on host with name 'grml'
2497     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2498        NAME="@$HOSTNAME"
2499     fi
2500 }
2501
2502 function grml_cmd_to_screen_title () {
2503     # get the name of the program currently running and hostname of local
2504     # machine set screen window title if running in a screen
2505     if [[ "$TERM" == screen* ]] ; then
2506         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME"
2507         ESC_print ${CMD}
2508     fi
2509 }
2510
2511 function grml_control_xterm_title () {
2512     case $TERM in
2513         (xterm*|rxvt*)
2514             set_title "${(%):-"%n@%m:"}" "$1"
2515             ;;
2516     esac
2517 }
2518
2519 # The following autoload is disabled for now, since this setup includes a
2520 # static version of the ‘add-zsh-hook’ function above. It needs to be
2521 # reenabled as soon as that static definition is removed again.
2522 #zrcautoload add-zsh-hook || add-zsh-hook () { :; }
2523 if [[ $NOPRECMD -eq 0 ]]; then
2524     add-zsh-hook precmd grml_reset_screen_title
2525     add-zsh-hook precmd grml_vcs_to_screen_title
2526     add-zsh-hook preexec grml_maintain_name
2527     add-zsh-hook preexec grml_cmd_to_screen_title
2528     if [[ $NOTITLE -eq 0 ]]; then
2529         add-zsh-hook preexec grml_control_xterm_title
2530     fi
2531 fi
2532
2533 # 'hash' some often used directories
2534 #d# start
2535 hash -d deb=/var/cache/apt/archives
2536 hash -d doc=/usr/share/doc
2537 hash -d linux=/lib/modules/$(command uname -r)/build/
2538 hash -d log=/var/log
2539 hash -d slog=/var/log/syslog
2540 hash -d src=/usr/src
2541 hash -d www=/var/www
2542 #d# end
2543
2544 # some aliases
2545 if check_com -c screen ; then
2546     if [[ $UID -eq 0 ]] ; then
2547         if [[ -r /etc/grml/screenrc ]]; then
2548             alias screen='screen -c /etc/grml/screenrc'
2549         fi
2550     elif [[ ! -r $HOME/.screenrc ]] ; then
2551         if [[ -r /etc/grml/screenrc_grml ]]; then
2552             alias screen='screen -c /etc/grml/screenrc_grml'
2553         else
2554             if [[ -r /etc/grml/screenrc ]]; then
2555                 alias screen='screen -c /etc/grml/screenrc'
2556             fi
2557         fi
2558     fi
2559 fi
2560
2561 # do we have GNU ls with color-support?
2562 if [[ "$TERM" != dumb ]]; then
2563     #a1# List files with colors (\kbd{ls \ldots})
2564     alias ls="command ls ${ls_options:+${ls_options[*]}}"
2565     #a1# List all files, with colors (\kbd{ls -la \ldots})
2566     alias la="command ls -la ${ls_options:+${ls_options[*]}}"
2567     #a1# List files with long colored list, without dotfiles (\kbd{ls -l \ldots})
2568     alias ll="command ls -l ${ls_options:+${ls_options[*]}}"
2569     #a1# List files with long colored list, human readable sizes (\kbd{ls -hAl \ldots})
2570     alias lh="command ls -hAl ${ls_options:+${ls_options[*]}}"
2571     #a1# List files with long colored list, append qualifier to filenames (\kbd{ls -l \ldots})\\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2572     alias l="command ls -l ${ls_options:+${ls_options[*]}}"
2573 else
2574     alias la='command ls -la'
2575     alias ll='command ls -l'
2576     alias lh='command ls -hAl'
2577     alias l='command ls -l'
2578 fi
2579
2580 if [[ -r /proc/mdstat ]]; then
2581     alias mdstat='cat /proc/mdstat'
2582 fi
2583
2584 alias ...='cd ../../'
2585
2586 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2587 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2588     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2589 fi
2590
2591 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2592 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2593 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2594
2595 # make sure it is not assigned yet
2596 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2597 function utf2iso () {
2598     if isutfenv ; then
2599         local ENV
2600         for ENV in $(env | command grep -i '.utf') ; do
2601             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2602         done
2603     fi
2604 }
2605
2606 # make sure it is not assigned yet
2607 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2608 function iso2utf () {
2609     if ! isutfenv ; then
2610         local ENV
2611         for ENV in $(env | command grep -i '\.iso') ; do
2612             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2613         done
2614     fi
2615 }
2616
2617 # especially for roadwarriors using GNU screen and ssh:
2618 if ! check_com asc &>/dev/null ; then
2619   function asc () { autossh -t "$@" 'screen -RdU' }
2620   compdef asc=ssh
2621 fi
2622
2623 #f1# Hints for the use of zsh on grml
2624 function zsh-help () {
2625     print "$bg[white]$fg[black]
2626 zsh-help - hints for use of zsh on grml
2627 =======================================$reset_color"
2628
2629     print '
2630 Main configuration of zsh happens in /etc/zsh/zshrc.
2631 That file is part of the package grml-etc-core, if you want to
2632 use them on a non-grml-system just get the tar.gz from
2633 http://deb.grml.org/ or (preferably) get it from the git repository:
2634
2635   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2636
2637 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2638 The file is still there, but it is empty for backwards compatibility.
2639
2640 For your own changes use these two files:
2641     $HOME/.zshrc.pre
2642     $HOME/.zshrc.local
2643
2644 The former is sourced very early in our zshrc, the latter is sourced
2645 very lately.
2646
2647 System wide configuration without touching configuration files of grml
2648 can take place in /etc/zsh/zshrc.local.
2649
2650 For information regarding zsh start at http://grml.org/zsh/
2651
2652 Take a look at grml'\''s zsh refcard:
2653 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2654
2655 Check out the main zsh refcard:
2656 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2657
2658 And of course visit the zsh-lovers:
2659 % man zsh-lovers
2660
2661 You can adjust some options through environment variables when
2662 invoking zsh without having to edit configuration files.
2663 Basically meant for bash users who are not used to the power of
2664 the zsh yet. :)
2665
2666   "NOCOR=1    zsh" => deactivate automatic correction
2667   "NOMENU=1   zsh" => do not use auto menu completion
2668                       (note: use ctrl-d for completion instead!)
2669   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2670   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2671                       preexec() and precmd() completely
2672   "GRML_DISPLAY_BATTERY=1  zsh"
2673                    => activate battery status on right side of prompt (WIP)
2674   "COMMAND_NOT_FOUND=1 zsh"
2675                    => Enable a handler if an external command was not found
2676                       The command called in the handler can be altered by setting
2677                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2678                       "/usr/share/command-not-found/command-not-found"
2679
2680 A value greater than 0 is enables a feature; a value equal to zero
2681 disables it. If you like one or the other of these settings, you can
2682 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2683 zshrc.'
2684
2685     print "
2686 $bg[white]$fg[black]
2687 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2688 Enjoy your grml system with the zsh!$reset_color"
2689 }
2690
2691 # debian stuff
2692 if [[ -r /etc/debian_version ]] ; then
2693     if [[ -z "$GRML_NO_APT_ALIASES" ]]; then
2694         #a3# Execute \kbd{apt-cache search}
2695         alias acs='apt-cache search'
2696         #a3# Execute \kbd{apt-cache show}
2697         alias acsh='apt-cache show'
2698         #a3# Execute \kbd{apt-cache policy}
2699         alias acp='apt-cache policy'
2700         if check_com -c apt ; then
2701           #a3# Execute \kbd{apt dist-upgrade}
2702           salias adg="apt dist-upgrade"
2703           #a3# Execute \kbd{apt upgrade}
2704           salias ag="apt upgrade"
2705           #a3# Execute \kbd{apt install}
2706           salias agi="apt install"
2707           #a3# Execute \kbd{apt-get update}
2708           salias au="apt update"
2709         else
2710           salias adg="apt-get dist-upgrade"
2711           salias ag="apt-get upgrade"
2712           salias agi="apt-get install"
2713           salias au="apt-get update"
2714         fi
2715         #a3# Execute \kbd{aptitude install}
2716         salias ati="aptitude install"
2717         #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2718         salias -a up="aptitude update ; aptitude safe-upgrade"
2719         #a3# Execute \kbd{dpkg-buildpackage}
2720         alias dbp='dpkg-buildpackage'
2721         #a3# Execute \kbd{grep-excuses}
2722         alias ge='grep-excuses'
2723     fi
2724
2725     # get a root shell as normal user in live-cd mode:
2726     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2727        alias su="sudo su"
2728     fi
2729
2730 fi
2731
2732 # use /var/log/syslog iff present, fallback to journalctl otherwise
2733 if [ -e /var/log/syslog ] ; then
2734   #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog || journalctl}
2735   salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2736   #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog || journalctl}
2737   salias tlog="tail -f /var/log/syslog"    # follow the syslog
2738 elif check_com -c journalctl ; then
2739   salias llog="journalctl"
2740   salias tlog="journalctl -f"
2741 fi
2742
2743 # sort installed Debian-packages by size
2744 if check_com -c dpkg-query ; then
2745     #a3# List installed Debian-packages sorted by size
2746     alias debs-by-size="dpkg-query -Wf 'x \${Installed-Size} \${Package} \${Status}\n' | sed -ne '/^x  /d' -e '/^x \(.*\) install ok installed$/s//\1/p' | sort -nr"
2747 fi
2748
2749 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2750 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2751     if check_com -c wodim; then
2752         function cdrecord () {
2753             <<__EOF0__
2754 cdrecord is not provided under its original name by Debian anymore.
2755 See #377109 in the BTS of Debian for more details.
2756
2757 Please use the wodim binary instead
2758 __EOF0__
2759             return 1
2760         }
2761     fi
2762 fi
2763
2764 if isgrmlcd; then
2765     # No core dumps: important for a live-cd-system
2766     limit -s core 0
2767 fi
2768
2769 # grmlstuff
2770 function grmlstuff () {
2771 # people should use 'grml-x'!
2772     if check_com -c 915resolution; then
2773         function 855resolution () {
2774             echo "Please use 915resolution as resolution modifying tool for Intel \
2775 graphic chipset."
2776             return -1
2777         }
2778     fi
2779
2780     #a1# Output version of running grml
2781     alias grml-version='cat /etc/grml_version'
2782
2783     if check_com -c grml-debootstrap ; then
2784         function debian2hd () {
2785             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2786             return 1
2787         }
2788     fi
2789 }
2790
2791 # now run the functions
2792 isgrml && checkhome
2793 is4    && isgrml    && grmlstuff
2794 is4    && grmlcomp
2795
2796 # keephack
2797 is4 && xsource "/etc/zsh/keephack"
2798
2799 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2800 # You use it as follows:
2801 # $ NTREF=/reference/file
2802 # $ ls -l *(e:nt:)
2803 # This lists all the files in the current directory newer than the reference file.
2804 # You can also specify the reference file inline; note quotes:
2805 # $ ls -l *(e:'nt ~/.zshenv':)
2806 is4 && function nt () {
2807     if [[ -n $1 ]] ; then
2808         local NTREF=${~1}
2809     fi
2810     [[ $REPLY -nt $NTREF ]]
2811 }
2812
2813 # shell functions
2814
2815 #f1# Reload an autoloadable function
2816 function freload () { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2817 compdef _functions freload
2818
2819 #
2820 # Usage:
2821 #
2822 #      e.g.:   a -> b -> c -> d  ....
2823 #
2824 #      sll a
2825 #
2826 #
2827 #      if parameter is given with leading '=', lookup $PATH for parameter and resolve that
2828 #
2829 #      sll =java
2830 #
2831 #      Note: limit for recursive symlinks on linux:
2832 #            http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?id=refs/heads/master#l808
2833 #            This limits recursive symlink follows to 8,
2834 #            while limiting consecutive symlinks to 40.
2835 #
2836 #      When resolving and displaying information about symlinks, no check is made
2837 #      that the displayed information does make any sense on your OS.
2838 #      We leave that decission to the user.
2839 #
2840 #      The zstat module is used to detect symlink loops. zstat is available since zsh4.
2841 #      With an older zsh you will need to abort with <C-c> in that case.
2842 #      When a symlink loop is detected, a warning ist printed and further processing is stopped.
2843 #
2844 #      Module zstat is loaded by default in grml zshrc, no extra action needed for that.
2845 #
2846 #      Known bugs:
2847 #      If you happen to come accross a symlink that points to a destination on an other partition
2848 #      with the same inode number, that will be marked as symlink loop though it is not.
2849 #      Two hints for this situation:
2850 #      I)  Play lottery the same day, as you seem to be rather lucky right now.
2851 #      II) Send patches.
2852 #
2853 #      return status:
2854 #      0 upon success
2855 #      1 file/dir not accesible
2856 #      2 symlink loop detected
2857 #
2858 #f1# List symlinks in detail (more detailed version of 'readlink -f', 'whence -s' and 'namei -l')
2859 function sll () {
2860     if [[ -z ${1} ]] ; then
2861         printf 'Usage: %s <symlink(s)>\n' "${0}"
2862         return 1
2863     fi
2864
2865     local file jumpd curdir
2866     local -i 10 RTN LINODE i
2867     local -a    SEENINODES
2868     curdir="${PWD}"
2869     RTN=0
2870
2871     for file in "${@}" ; do
2872         SEENINODES=()
2873         ls -l "${file:a}"   || RTN=1
2874
2875         while [[ -h "$file" ]] ; do
2876             if is4 ; then
2877                 LINODE=$(zstat -L +inode "${file}")
2878                 for i in ${SEENINODES} ; do
2879                     if (( ${i} == ${LINODE} )) ; then
2880                         builtin cd -q "${curdir}"
2881                         print 'link loop detected, aborting!'
2882                         return 2
2883                     fi
2884                 done
2885                 SEENINODES+=${LINODE}
2886             fi
2887             jumpd="${file:h}"
2888             file="${file:t}"
2889
2890             if [[ -d ${jumpd} ]] ; then
2891                 builtin cd -q "${jumpd}"  || RTN=1
2892             fi
2893             file=$(readlink "$file")
2894
2895             jumpd="${file:h}"
2896             file="${file:t}"
2897
2898             if [[ -d ${jumpd} ]] ; then
2899                 builtin cd -q "${jumpd}"  || RTN=1
2900             fi
2901
2902             ls -l "${PWD}/${file}"     || RTN=1
2903         done
2904         shift 1
2905         if (( ${#} >= 1 )) ; then
2906             print ""
2907         fi
2908         builtin cd -q "${curdir}"
2909     done
2910     return ${RTN}
2911 }
2912
2913 # TODO: Is it supported to use pager settings like this?
2914 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2915 # with respect to wordsplitting. (ie. ${=PAGER})
2916 if check_com -c $PAGER ; then
2917     #f3# View Debian's changelog of given package(s)
2918     function dchange () {
2919         emulate -L zsh
2920         [[ -z "$1" ]] && printf 'Usage: %s <package_name(s)>\n' "$0" && return 1
2921
2922         local package
2923         for package in "$@" ; do
2924             if [[ -r /usr/share/doc/${package}/changelog.Debian.gz ]] ; then
2925                 $PAGER /usr/share/doc/${package}/changelog.Debian.gz
2926             elif [[ -r /usr/share/doc/${package}/changelog.gz ]] ; then
2927                 $PAGER /usr/share/doc/${package}/changelog.gz
2928             elif [[ -r /usr/share/doc/${package}/changelog ]] ; then
2929                 $PAGER /usr/share/doc/${package}/changelog
2930             else
2931                 if check_com -c aptitude ; then
2932                     echo "No changelog for package $package found, using aptitude to retrieve it."
2933                     aptitude changelog "$package"
2934                 elif check_com -c apt-get ; then
2935                     echo "No changelog for package $package found, using apt-get to retrieve it."
2936                     apt-get changelog "$package"
2937                 else
2938                     echo "No changelog for package $package found, sorry."
2939                 fi
2940             fi
2941         done
2942     }
2943     function _dchange () { _files -W /usr/share/doc -/ }
2944     compdef _dchange dchange
2945
2946     #f3# View Debian's NEWS of a given package
2947     function dnews () {
2948         emulate -L zsh
2949         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2950             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2951         else
2952             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2953                 $PAGER /usr/share/doc/$1/NEWS.gz
2954             else
2955                 echo "No NEWS file for package $1 found, sorry."
2956                 return 1
2957             fi
2958         fi
2959     }
2960     function _dnews () { _files -W /usr/share/doc -/ }
2961     compdef _dnews dnews
2962
2963     #f3# View Debian's copyright of a given package
2964     function dcopyright () {
2965         emulate -L zsh
2966         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2967             $PAGER /usr/share/doc/$1/copyright
2968         else
2969             echo "No copyright file for package $1 found, sorry."
2970             return 1
2971         fi
2972     }
2973     function _dcopyright () { _files -W /usr/share/doc -/ }
2974     compdef _dcopyright dcopyright
2975
2976     #f3# View upstream's changelog of a given package
2977     function uchange () {
2978         emulate -L zsh
2979         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2980             $PAGER /usr/share/doc/$1/changelog.gz
2981         else
2982             echo "No changelog for package $1 found, sorry."
2983             return 1
2984         fi
2985     }
2986     function _uchange () { _files -W /usr/share/doc -/ }
2987     compdef _uchange uchange
2988 fi
2989
2990 # zsh profiling
2991 function profile () {
2992     ZSH_PROFILE_RC=1 zsh "$@"
2993 }
2994
2995 #f1# Edit an alias via zle
2996 function edalias () {
2997     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2998 }
2999 compdef _aliases edalias
3000
3001 #f1# Edit a function via zle
3002 function edfunc () {
3003     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
3004 }
3005 compdef _functions edfunc
3006
3007 # use it e.g. via 'Restart apache2'
3008 #m# f6 Start() \kbd{service \em{process}}\quad\kbd{start}
3009 #m# f6 Restart() \kbd{service \em{process}}\quad\kbd{restart}
3010 #m# f6 Stop() \kbd{service \em{process}}\quad\kbd{stop}
3011 #m# f6 Reload() \kbd{service \em{process}}\quad\kbd{reload}
3012 #m# f6 Force-Reload() \kbd{service \em{process}}\quad\kbd{force-reload}
3013 #m# f6 Status() \kbd{service \em{process}}\quad\kbd{status}
3014 if [[ -d /etc/init.d || -d /etc/service ]] ; then
3015     function __start_stop () {
3016         local action_="${1:l}"  # e.g Start/Stop/Restart
3017         local service_="$2"
3018         local param_="$3"
3019
3020         local service_target_="$(readlink /etc/init.d/$service_)"
3021         if [[ $service_target_ == "/usr/bin/sv" ]]; then
3022             # runit
3023             case "${action_}" in
3024                 start) if [[ ! -e /etc/service/$service_ ]]; then
3025                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
3026                        else
3027                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3028                        fi ;;
3029                 # there is no reload in runits sysv emulation
3030                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
3031                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
3032             esac
3033         else
3034             # sysv/sysvinit-utils, upstart
3035             if check_com -c service ; then
3036               $SUDO service "$service_" "${action_}" "$param_"
3037             else
3038               $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3039             fi
3040         fi
3041     }
3042
3043     function _grmlinitd () {
3044         local -a scripts
3045         scripts=( /etc/init.d/*(x:t) )
3046         _describe "service startup script" scripts
3047     }
3048
3049     for i in Start Restart Stop Force-Reload Reload Status ; do
3050         eval "function $i () { __start_stop $i \"\$1\" \"\$2\" ; }"
3051         compdef _grmlinitd $i
3052     done
3053     builtin unset -v i
3054 fi
3055
3056 #f1# Provides useful information on globbing
3057 function H-Glob () {
3058     echo -e "
3059     /      directories
3060     .      plain files
3061     @      symbolic links
3062     =      sockets
3063     p      named pipes (FIFOs)
3064     *      executable plain files (0100)
3065     %      device files (character or block special)
3066     %b     block special files
3067     %c     character special files
3068     r      owner-readable files (0400)
3069     w      owner-writable files (0200)
3070     x      owner-executable files (0100)
3071     A      group-readable files (0040)
3072     I      group-writable files (0020)
3073     E      group-executable files (0010)
3074     R      world-readable files (0004)
3075     W      world-writable files (0002)
3076     X      world-executable files (0001)
3077     s      setuid files (04000)
3078     S      setgid files (02000)
3079     t      files with the sticky bit (01000)
3080
3081   print *(m-1)          # Files modified up to a day ago
3082   print *(a1)           # Files accessed a day ago
3083   print *(@)            # Just symlinks
3084   print *(Lk+50)        # Files bigger than 50 kilobytes
3085   print *(Lk-50)        # Files smaller than 50 kilobytes
3086   print **/*.c          # All *.c files recursively starting in \$PWD
3087   print **/*.c~file.c   # Same as above, but excluding 'file.c'
3088   print (foo|bar).*     # Files starting with 'foo' or 'bar'
3089   print *~*.*           # All Files that do not contain a dot
3090   chmod 644 *(.^x)      # make all plain non-executable files publically readable
3091   print -l *(.c|.h)     # Lists *.c and *.h
3092   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
3093   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
3094 }
3095 alias help-zshglob=H-Glob
3096
3097 # grep for running process, like: 'any vim'
3098 function any () {
3099     emulate -L zsh
3100     unsetopt KSH_ARRAYS
3101     if [[ -z "$1" ]] ; then
3102         echo "any - grep for process(es) by keyword" >&2
3103         echo "Usage: any <keyword>" >&2 ; return 1
3104     else
3105         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
3106     fi
3107 }
3108
3109
3110 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
3111 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
3112 [[ -r /proc/1/maps ]] && \
3113 function deswap () {
3114     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
3115     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
3116     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
3117 }
3118
3119 # a wrapper for vim, that deals with title setting
3120 #   VIM_OPTIONS
3121 #       set this array to a set of options to vim you always want
3122 #       to have set when calling vim (in .zshrc.local), like:
3123 #           VIM_OPTIONS=( -p )
3124 #       This will cause vim to send every file given on the
3125 #       commandline to be send to it's own tab (needs vim7).
3126 if check_com vim; then
3127     function vim () {
3128         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3129     }
3130 fi
3131
3132 ssl_hashes=( sha512 sha256 sha1 md5 )
3133
3134 for sh in ${ssl_hashes}; do
3135     eval 'ssl-cert-'${sh}'() {
3136         emulate -L zsh
3137         if [[ -z $1 ]] ; then
3138             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
3139             return 1
3140         fi
3141         openssl x509 -noout -fingerprint -'${sh}' -in $1
3142     }'
3143 done; unset sh
3144
3145 function ssl-cert-fingerprints () {
3146     emulate -L zsh
3147     local i
3148     if [[ -z $1 ]] ; then
3149         printf 'usage: ssl-cert-fingerprints <file>\n'
3150         return 1
3151     fi
3152     for i in ${ssl_hashes}
3153         do ssl-cert-$i $1;
3154     done
3155 }
3156
3157 function ssl-cert-info () {
3158     emulate -L zsh
3159     if [[ -z $1 ]] ; then
3160         printf 'usage: ssl-cert-info <file>\n'
3161         return 1
3162     fi
3163     openssl x509 -noout -text -in $1
3164     ssl-cert-fingerprints $1
3165 }
3166
3167 # make sure our environment is clean regarding colors
3168 builtin unset -v BLUE RED GREEN CYAN YELLOW MAGENTA WHITE NO_COLOR
3169
3170 # "persistent history"
3171 # just write important commands you always need to $GRML_IMPORTANT_COMMANDS
3172 # defaults for backward compatibility to ~/.important_commands
3173 if [[ -r ~/.important_commands ]] ; then
3174     GRML_IMPORTANT_COMMANDS=~/.important_commands
3175 else
3176     GRML_IMPORTANT_COMMANDS=${GRML_IMPORTANT_COMMANDS:-${ZDOTDIR:-${HOME}}/.important_commands}
3177 fi
3178 [[ -r ${GRML_IMPORTANT_COMMANDS} ]] && builtin fc -R ${GRML_IMPORTANT_COMMANDS}
3179
3180 # load the lookup subsystem if it's available on the system
3181 zrcautoload lookupinit && lookupinit
3182
3183 # variables
3184
3185 # set terminal property (used e.g. by msgid-chooser)
3186 export COLORTERM="yes"
3187
3188 # aliases
3189
3190 # general
3191 #a2# Execute \kbd{du -sch}
3192 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias da='du -sch'
3193
3194 # listing stuff
3195 #a2# Execute \kbd{ls -lSrah}
3196 alias dir="command ls -lSrah"
3197 #a2# Only show dot-directories
3198 alias lad='command ls -d .*(/)'
3199 #a2# Only show dot-files
3200 alias lsa='command ls -a .*(.)'
3201 #a2# Only files with setgid/setuid/sticky flag
3202 alias lss='command ls -l *(s,S,t)'
3203 #a2# Only show symlinks
3204 alias lsl='command ls -l *(@)'
3205 #a2# Display only executables
3206 alias lsx='command ls -l *(*)'
3207 #a2# Display world-{readable,writable,executable} files
3208 alias lsw='command ls -ld *(R,W,X.^ND/)'
3209 #a2# Display the ten biggest files
3210 alias lsbig="command ls -flh *(.OL[1,10])"
3211 #a2# Only show directories
3212 alias lsd='command ls -d *(/)'
3213 #a2# Only show empty directories
3214 alias lse='command ls -d *(/^F)'
3215 #a2# Display the ten newest files
3216 alias lsnew="command ls -rtlh *(D.om[1,10])"
3217 #a2# Display the ten oldest files
3218 alias lsold="command ls -rtlh *(D.Om[1,10])"
3219 #a2# Display the ten smallest files
3220 alias lssmall="command ls -Srl *(.oL[1,10])"
3221 #a2# Display the ten newest directories and ten newest .directories
3222 alias lsnewdir="command ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
3223 #a2# Display the ten oldest directories and ten oldest .directories
3224 alias lsolddir="command ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
3225
3226 # some useful aliases
3227 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir \$OLDCWD}
3228 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
3229
3230 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3231 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3232 #a2# scp with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3233 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3234
3235 # work around non utf8 capable software in utf environment via $LANG and luit
3236 if check_com isutfenv && check_com luit ; then
3237     if check_com -c mrxvt ; then
3238         isutfenv && [[ -n "$LANG" ]] && \
3239             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3240     fi
3241
3242     if check_com -c aterm ; then
3243         isutfenv && [[ -n "$LANG" ]] && \
3244             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3245     fi
3246
3247     if check_com -c centericq ; then
3248         isutfenv && [[ -n "$LANG" ]] && \
3249             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3250     fi
3251 fi
3252
3253 # useful functions
3254
3255 #f5# Backup \kbd{file_or_folder {\rm to} file_or_folder\_timestamp}
3256 function bk () {
3257     emulate -L zsh
3258     local current_date=$(date -u "+%Y-%m-%dT%H:%M:%SZ")
3259     local clean keep move verbose result all to_bk
3260     setopt extended_glob
3261     keep=1
3262     while getopts ":hacmrv" opt; do
3263         case $opt in
3264             a) (( all++ ));;
3265             c) unset move clean && (( ++keep ));;
3266             m) unset keep clean && (( ++move ));;
3267             r) unset move keep && (( ++clean ));;
3268             v) verbose="-v";;
3269             h) <<__EOF0__
3270 bk [-hcmv] FILE [FILE ...]
3271 bk -r [-av] [FILE [FILE ...]]
3272 Backup a file or folder in place and append the timestamp
3273 Remove backups of a file or folder, or all backups in the current directory
3274
3275 Usage:
3276 -h    Display this help text
3277 -c    Keep the file/folder as is, create a copy backup using cp(1) (default)
3278 -m    Move the file/folder, using mv(1)
3279 -r    Remove backups of the specified file or directory, using rm(1). If none
3280       is provided, remove all backups in the current directory.
3281 -a    Remove all (even hidden) backups.
3282 -v    Verbose
3283
3284 The -c, -r and -m options are mutually exclusive. If specified at the same time,
3285 the last one is used.
3286
3287 The return code is the sum of all cp/mv/rm return codes.
3288 __EOF0__
3289 return 0;;
3290             \?) bk -h >&2; return 1;;
3291         esac
3292     done
3293     shift "$((OPTIND-1))"
3294     if (( keep > 0 )); then
3295         if islinux || isfreebsd; then
3296             for to_bk in "$@"; do
3297                 cp $verbose -a "${to_bk%/}" "${to_bk%/}_$current_date"
3298                 (( result += $? ))
3299             done
3300         else
3301             for to_bk in "$@"; do
3302                 cp $verbose -pR "${to_bk%/}" "${to_bk%/}_$current_date"
3303                 (( result += $? ))
3304             done
3305         fi
3306     elif (( move > 0 )); then
3307         while (( $# > 0 )); do
3308             mv $verbose "${1%/}" "${1%/}_$current_date"
3309             (( result += $? ))
3310             shift
3311         done
3312     elif (( clean > 0 )); then
3313         if (( $# > 0 )); then
3314             for to_bk in "$@"; do
3315                 rm $verbose -rf "${to_bk%/}"_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z
3316                 (( result += $? ))
3317             done
3318         else
3319             if (( all > 0 )); then
3320                 rm $verbose -rf *_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z(D)
3321             else
3322                 rm $verbose -rf *_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z
3323             fi
3324             (( result += $? ))
3325         fi
3326     fi
3327     return $result
3328 }
3329
3330 #f5# cd to directoy and list files
3331 function cl () {
3332     emulate -L zsh
3333     cd $1 && ls -a
3334 }
3335
3336 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
3337 function cd () {
3338     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
3339         [[ ! -e ${1:h} ]] && return 1
3340         print "Correcting ${1} to ${1:h}"
3341         builtin cd ${1:h}
3342     else
3343         builtin cd "$@"
3344     fi
3345 }
3346
3347 #f5# Create Directoy and \kbd{cd} to it
3348 function mkcd () {
3349     if (( ARGC != 1 )); then
3350         printf 'usage: mkcd <new-directory>\n'
3351         return 1;
3352     fi
3353     if [[ ! -d "$1" ]]; then
3354         command mkdir -p "$1"
3355     else
3356         printf '`%s'\'' already exists: cd-ing.\n' "$1"
3357     fi
3358     builtin cd "$1"
3359 }
3360
3361 #f5# Create temporary directory and \kbd{cd} to it
3362 function cdt () {
3363     builtin cd "$(mktemp -d)"
3364     builtin pwd
3365 }
3366
3367 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
3368 function accessed () {
3369     emulate -L zsh
3370     print -l -- *(a-${1:-1})
3371 }
3372
3373 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
3374 function changed () {
3375     emulate -L zsh
3376     print -l -- *(c-${1:-1})
3377 }
3378
3379 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
3380 function modified () {
3381     emulate -L zsh
3382     print -l -- *(m-${1:-1})
3383 }
3384 # modified() was named new() in earlier versions, add an alias for backwards compatibility
3385 check_com new || alias new=modified
3386
3387 # use colors when GNU grep with color-support
3388 if (( $#grep_options > 0 )); then
3389     o=${grep_options:+"${grep_options[*]}"}
3390     #a2# Execute \kbd{grep -{}-color=auto}
3391     alias grep='grep '$o
3392     alias egrep='egrep '$o
3393     unset o
3394 fi
3395
3396 # Translate DE<=>EN
3397 # 'translate' looks up a word in a file with language-to-language
3398 # translations (field separator should be " : "). A typical wordlist looks
3399 # like the following:
3400 #  | english-word : german-translation
3401 # It's also only possible to translate english to german but not reciprocal.
3402 # Use the following oneliner to reverse the sort order:
3403 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3404 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3405 #f5# Translates a word
3406 function trans () {
3407     emulate -L zsh
3408     case "$1" in
3409         -[dD]*)
3410             translate -l de-en $2
3411             ;;
3412         -[eE]*)
3413             translate -l en-de $2
3414             ;;
3415         *)
3416             echo "Usage: $0 { -D | -E }"
3417             echo "         -D == German to English"
3418             echo "         -E == English to German"
3419     esac
3420 }
3421
3422 # Usage: simple-extract <file>
3423 # Using option -d deletes the original archive file.
3424 #f5# Smart archive extractor
3425 function simple-extract () {
3426     emulate -L zsh
3427     setopt extended_glob noclobber
3428     local ARCHIVE DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
3429     local RC=0
3430     zparseopts -D -E "d=DELETE_ORIGINAL"
3431     for ARCHIVE in "${@}"; do
3432         case $ARCHIVE in
3433             *(tar.bz2|tbz2|tbz))
3434                 DECOMP_CMD="tar -xvjf -"
3435                 USES_STDIN=true
3436                 USES_STDOUT=false
3437                 ;;
3438             *(tar.gz|tgz))
3439                 DECOMP_CMD="tar -xvzf -"
3440                 USES_STDIN=true
3441                 USES_STDOUT=false
3442                 ;;
3443             *(tar.xz|txz|tar.lzma))
3444                 DECOMP_CMD="tar -xvJf -"
3445                 USES_STDIN=true
3446                 USES_STDOUT=false
3447                 ;;
3448             *tar)
3449                 DECOMP_CMD="tar -xvf -"
3450                 USES_STDIN=true
3451                 USES_STDOUT=false
3452                 ;;
3453             *rar)
3454                 DECOMP_CMD="unrar x"
3455                 USES_STDIN=false
3456                 USES_STDOUT=false
3457                 ;;
3458             *lzh)
3459                 DECOMP_CMD="lha x"
3460                 USES_STDIN=false
3461                 USES_STDOUT=false
3462                 ;;
3463             *7z)
3464                 DECOMP_CMD="7z x"
3465                 USES_STDIN=false
3466                 USES_STDOUT=false
3467                 ;;
3468             *(zip|jar))
3469                 DECOMP_CMD="unzip"
3470                 USES_STDIN=false
3471                 USES_STDOUT=false
3472                 ;;
3473             *deb)
3474                 DECOMP_CMD="ar -x"
3475                 USES_STDIN=false
3476                 USES_STDOUT=false
3477                 ;;
3478             *bz2)
3479                 DECOMP_CMD="bzip2 -d -c -"
3480                 USES_STDIN=true
3481                 USES_STDOUT=true
3482                 ;;
3483             *(gz|Z))
3484                 DECOMP_CMD="gzip -d -c -"
3485                 USES_STDIN=true
3486                 USES_STDOUT=true
3487                 ;;
3488             *(xz|lzma))
3489                 DECOMP_CMD="xz -d -c -"
3490                 USES_STDIN=true
3491                 USES_STDOUT=true
3492                 ;;
3493             *)
3494                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
3495                 RC=$((RC+1))
3496                 continue
3497                 ;;
3498         esac
3499
3500         if ! check_com ${DECOMP_CMD[(w)1]}; then
3501             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
3502             RC=$((RC+2))
3503             continue
3504         fi
3505
3506         GZTARGET="${ARCHIVE:t:r}"
3507         if [[ -f $ARCHIVE ]] ; then
3508
3509             print "Extracting '$ARCHIVE' ..."
3510             if $USES_STDIN; then
3511                 if $USES_STDOUT; then
3512                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
3513                 else
3514                     ${=DECOMP_CMD} < "$ARCHIVE"
3515                 fi
3516             else
3517                 if $USES_STDOUT; then
3518                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
3519                 else
3520                     ${=DECOMP_CMD} "$ARCHIVE"
3521                 fi
3522             fi
3523             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
3524
3525         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
3526             if check_com curl; then
3527                 WGET_CMD="curl -L -s -o -"
3528             elif check_com wget; then
3529                 WGET_CMD="wget -q -O -"
3530             elif check_com fetch; then
3531                 WGET_CMD="fetch -q -o -"
3532             else
3533                 print "ERROR: neither wget, curl nor fetch is installed" >&2
3534                 RC=$((RC+4))
3535                 continue
3536             fi
3537             print "Downloading and Extracting '$ARCHIVE' ..."
3538             if $USES_STDIN; then
3539                 if $USES_STDOUT; then
3540                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
3541                     RC=$((RC+$?))
3542                 else
3543                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
3544                     RC=$((RC+$?))
3545                 fi
3546             else
3547                 if $USES_STDOUT; then
3548                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
3549                 else
3550                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
3551                 fi
3552             fi
3553
3554         else
3555             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
3556             RC=$((RC+8))
3557         fi
3558     done
3559     return $RC
3560 }
3561
3562 function __archive_or_uri () {
3563     _alternative \
3564         'files:Archives:_files -g "*.(#l)(tar.bz2|tbz2|tbz|tar.gz|tgz|tar.xz|txz|tar.lzma|tar|rar|lzh|7z|zip|jar|deb|bz2|gz|Z|xz|lzma)"' \
3565         '_urls:Remote Archives:_urls'
3566 }
3567
3568 function _simple_extract () {
3569     _arguments \
3570         '-d[delete original archivefile after extraction]' \
3571         '*:Archive Or Uri:__archive_or_uri'
3572 }
3573 compdef _simple_extract simple-extract
3574 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias se=simple-extract
3575
3576 #f5# Change the xterm title from within GNU-screen
3577 function xtrename () {
3578     emulate -L zsh
3579     if [[ $1 != "-f" ]] ; then
3580         if [[ -z ${DISPLAY} ]] ; then
3581             printf 'xtrename only makes sense in X11.\n'
3582             return 1
3583         fi
3584     else
3585         shift
3586     fi
3587     if [[ -z $1 ]] ; then
3588         printf 'usage: xtrename [-f] "title for xterm"\n'
3589         printf '  renames the title of xterm from _within_ screen.\n'
3590         printf '  also works without screen.\n'
3591         printf '  will not work if DISPLAY is unset, use -f to override.\n'
3592         return 0
3593     fi
3594     print -n "\eP\e]0;${1}\C-G\e\\"
3595     return 0
3596 }
3597
3598 # Create small urls via http://goo.gl using curl(1).
3599 # API reference: https://code.google.com/apis/urlshortener/
3600 function zurl () {
3601     emulate -L zsh
3602     setopt extended_glob
3603
3604     if [[ -z $1 ]]; then
3605         print "USAGE: zurl <URL>"
3606         return 1
3607     fi
3608
3609     local PN url prog api json contenttype item
3610     local -a data
3611     PN=$0
3612     url=$1
3613
3614     # Prepend 'http://' to given URL where necessary for later output.
3615     if [[ ${url} != http(s|)://* ]]; then
3616         url='http://'${url}
3617     fi
3618
3619     if check_com -c curl; then
3620         prog=curl
3621     else
3622         print "curl is not available, but mandatory for ${PN}. Aborting."
3623         return 1
3624     fi
3625     api='https://www.googleapis.com/urlshortener/v1/url'
3626     contenttype="Content-Type: application/json"
3627     json="{\"longUrl\": \"${url}\"}"
3628     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
3629     # Parse the response
3630     for item in "${data[@]}"; do
3631         case "$item" in
3632             ' '#'"id":'*)
3633                 item=${item#*: \"}
3634                 item=${item%\",*}
3635                 printf '%s\n' "$item"
3636                 return 0
3637                 ;;
3638         esac
3639     done
3640     return 1
3641 }
3642
3643 #f2# Find history events by search pattern and list them by date.
3644 function whatwhen () {
3645     emulate -L zsh
3646     local usage help ident format_l format_s first_char remain first last
3647     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3648     help='Use `whatwhen -h'\'' for further explanations.'
3649     ident=${(l,${#${:-Usage: }},, ,)}
3650     format_l="${ident}%s\t\t\t%s\n"
3651     format_s="${format_l//(\\t)##/\\t}"
3652     # Make the first char of the word to search for case
3653     # insensitive; e.g. [aA]
3654     first_char=[${(L)1[1]}${(U)1[1]}]
3655     remain=${1[2,-1]}
3656     # Default search range is `-100'.
3657     first=${2:-\-100}
3658     # Optional, just used for `<first> <last>' given.
3659     last=$3
3660     case $1 in
3661         ("")
3662             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3663             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3664         ;;
3665         (-h)
3666             printf '%s\n\n' ${usage}
3667             print 'OPTIONS:'
3668             printf $format_l '-h' 'show help text'
3669             print '\f'
3670             print 'SEARCH RANGE:'
3671             printf $format_l "'0'" 'the whole history,'
3672             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3673             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3674             printf '\n%s\n' 'EXAMPLES:'
3675             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3676             printf $format_l 'whatwhen zsh -250'
3677             printf $format_l 'whatwhen foo 1 99'
3678         ;;
3679         (\?)
3680             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3681         ;;
3682         (*)
3683             # -l list results on stout rather than invoking $EDITOR.
3684             # -i Print dates as in YYYY-MM-DD.
3685             # -m Search for a - quoted - pattern within the history.
3686             fc -li -m "*${first_char}${remain}*" $first $last
3687         ;;
3688     esac
3689 }
3690
3691 # mercurial related stuff
3692 if check_com -c hg ; then
3693     # gnu like diff for mercurial
3694     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3695     #f5# GNU like diff for mercurial
3696     function hgdi () {
3697         emulate -L zsh
3698         local i
3699         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3700     }
3701
3702     # build debian package
3703     #a2# Alias for \kbd{hg-buildpackage}
3704     alias hbp='hg-buildpackage'
3705
3706     # execute commands on the versioned patch-queue from the current repos
3707     [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3708
3709     # diffstat for specific version of a mercurial repository
3710     #   hgstat      => display diffstat between last revision and tip
3711     #   hgstat 1234 => display diffstat between revision 1234 and tip
3712     #f5# Diffstat for specific version of a mercurial repos
3713     function hgstat () {
3714         emulate -L zsh
3715         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3716     }
3717
3718 fi # end of check whether we have the 'hg'-executable
3719
3720 # grml-small cleanups
3721
3722 # The following is used to remove zsh-config-items that do not work
3723 # in grml-small by default.
3724 # If you do not want these adjustments (for whatever reason), set
3725 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3726 # sources if it is there).
3727
3728 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3729
3730     unset "abk[V]"
3731     unalias    'V'      &> /dev/null
3732     unfunction vman     &> /dev/null
3733     unfunction viless   &> /dev/null
3734     unfunction 2html    &> /dev/null
3735
3736     # manpages are not in grmlsmall
3737     unfunction manzsh   &> /dev/null
3738     unfunction man2     &> /dev/null
3739
3740 fi
3741
3742 zrclocal
3743
3744 ## genrefcard.pl settings
3745
3746 ### doc strings for external functions from files
3747 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3748
3749 ### example: split functions-search 8,16,24,32
3750 #@# split functions-search 8
3751
3752 ## END OF FILE #################################################################
3753 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3754 # Local variables:
3755 # mode: sh
3756 # End: