Test the correct parameter for non-emptiness
[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     Available styles in 'items:<item>' are: pre, post. These are strings that
2005     are inserted before (pre) and after (post) the item in question. Thus, the
2006     following would cause the user name to be printed in red instead of the
2007     default blue:
2008
2009         zstyle ':prompt:grml:*:items:user' pre '%F{red}'
2010
2011     Note, that the \`post' style may remain at its default value, because its
2012     default value is '%f', which turns the foreground text attribute off (which
2013     is exactly, what is still required with the new \`pre' value).
2014 __EOF0__
2015 }
2016
2017 function prompt_grml-chroot_help () {
2018     <<__EOF0__
2019   prompt grml-chroot
2020
2021     This is a variation of the grml prompt, see: prompt -h grml
2022
2023     The main difference is the default value of the \`items' style. The rest
2024     behaves exactly the same. Here are the defaults for \`grml-chroot':
2025
2026         - left: grml-chroot user at host path percent
2027         - right: (empty list)
2028 __EOF0__
2029 }
2030
2031 function prompt_grml-large_help () {
2032     <<__EOF0__
2033   prompt grml-large
2034
2035     This is a variation of the grml prompt, see: prompt -h grml
2036
2037     The main difference is the default value of the \`items' style. In
2038     particular, this theme uses _two_ lines instead of one with the plain
2039     \`grml' theme. The rest behaves exactly the same. Here are the defaults
2040     for \`grml-large':
2041
2042         - left: rc jobs history shell-level change-root time date newline user
2043                 at host path vcs percent
2044         - right: sad-smiley
2045 __EOF0__
2046 }
2047
2048 function grml_prompt_setup () {
2049     emulate -L zsh
2050     autoload -Uz vcs_info
2051     # The following autoload is disabled for now, since this setup includes a
2052     # static version of the ‘add-zsh-hook’ function above. It needs to be
2053     # reenabled as soon as that static definition is removed again.
2054     #autoload -Uz add-zsh-hook
2055     add-zsh-hook precmd prompt_$1_precmd
2056 }
2057
2058 function prompt_grml_setup () {
2059     grml_prompt_setup grml
2060 }
2061
2062 function prompt_grml-chroot_setup () {
2063     grml_prompt_setup grml-chroot
2064 }
2065
2066 function prompt_grml-large_setup () {
2067     grml_prompt_setup grml-large
2068 }
2069
2070 # These maps define default tokens and pre-/post-decoration for items to be
2071 # used within the themes. All defaults may be customised in a context sensitive
2072 # matter by using zsh's `zstyle' mechanism.
2073 typeset -gA grml_prompt_pre_default \
2074             grml_prompt_post_default \
2075             grml_prompt_token_default \
2076             grml_prompt_token_function
2077
2078 grml_prompt_pre_default=(
2079     at                ''
2080     battery           ' '
2081     change-root       ''
2082     date              '%F{blue}'
2083     grml-chroot       '%F{red}'
2084     history           '%F{green}'
2085     host              ''
2086     jobs              '%F{cyan}'
2087     newline           ''
2088     path              '%B'
2089     percent           ''
2090     rc                '%B%F{red}'
2091     rc-always         ''
2092     sad-smiley        ''
2093     shell-level       '%F{red}'
2094     time              '%F{blue}'
2095     user              '%B%F{blue}'
2096     vcs               ''
2097 )
2098
2099 grml_prompt_post_default=(
2100     at                ''
2101     battery           ''
2102     change-root       ''
2103     date              '%f'
2104     grml-chroot       '%f '
2105     history           '%f'
2106     host              ''
2107     jobs              '%f'
2108     newline           ''
2109     path              '%b'
2110     percent           ''
2111     rc                '%f%b'
2112     rc-always         ''
2113     sad-smiley        ''
2114     shell-level       '%f'
2115     time              '%f'
2116     user              '%f%b'
2117     vcs               ''
2118 )
2119
2120 grml_prompt_token_default=(
2121     at                '@'
2122     battery           'GRML_BATTERY_LEVEL'
2123     change-root       'debian_chroot'
2124     date              '%D{%Y-%m-%d}'
2125     grml-chroot       'GRML_CHROOT'
2126     history           '{history#%!} '
2127     host              '%m '
2128     jobs              '[%j running job(s)] '
2129     newline           $'\n'
2130     path              '%40<..<%~%<< '
2131     percent           '%# '
2132     rc                '%(?..%? )'
2133     rc-always         '%?'
2134     sad-smiley        '%(?..:()'
2135     shell-level       '%(3L.+ .)'
2136     time              '%D{%H:%M:%S} '
2137     user              '%n'
2138     vcs               '0'
2139 )
2140
2141 function grml_theme_has_token () {
2142     if (( ARGC != 1 )); then
2143         printf 'usage: grml_theme_has_token <name>\n'
2144         return 1
2145     fi
2146     (( ${+grml_prompt_token_default[$1]} ))
2147 }
2148
2149 function GRML_theme_add_token_usage () {
2150     <<__EOF0__
2151   Usage: grml_theme_add_token <name> [-f|-i] <token/function> [<pre> <post>]
2152
2153     <name> is the name for the newly added token. If the \`-f' or \`-i' options
2154     are used, <token/function> is the name of the function (see below for
2155     details). Otherwise it is the literal token string to be used. <pre> and
2156     <post> are optional.
2157
2158   Options:
2159
2160     -f <function>   Use a function named \`<function>' each time the token
2161                     is to be expanded.
2162
2163     -i <function>   Use a function named \`<function>' to initialise the
2164                     value of the token _once_ at runtime.
2165
2166     The functions are called with one argument: the token's new name. The
2167     return value is expected in the \$REPLY parameter. The use of these
2168     options is mutually exclusive.
2169
2170     There is a utility function \`grml_theme_has_token', which you can use
2171     to test if a token exists before trying to add it. This can be a guard
2172     for situations in which a \`grml_theme_add_token' call may happen more
2173     than once.
2174
2175   Example:
2176
2177     To add a new token \`day' that expands to the current weekday in the
2178     current locale in green foreground colour, use this:
2179
2180       grml_theme_add_token day '%D{%A}' '%F{green}' '%f'
2181
2182     Another example would be support for \$VIRTUAL_ENV:
2183
2184       function virtual_env_prompt () {
2185         REPLY=\${VIRTUAL_ENV+\${VIRTUAL_ENV:t} }
2186       }
2187       grml_theme_add_token virtual-env -f virtual_env_prompt
2188
2189     After that, you will be able to use a changed \`items' style to
2190     assemble your prompt.
2191 __EOF0__
2192 }
2193
2194 function grml_theme_add_token () {
2195     emulate -L zsh
2196     local name token pre post
2197     local -i init funcall
2198
2199     if (( ARGC == 0 )); then
2200         GRML_theme_add_token_usage
2201         return 0
2202     fi
2203
2204     init=0
2205     funcall=0
2206     pre=''
2207     post=''
2208     name=$1
2209     shift
2210     if [[ $1 == '-f' ]]; then
2211         funcall=1
2212         shift
2213     elif [[ $1 == '-i' ]]; then
2214         init=1
2215         shift
2216     fi
2217
2218     if (( ARGC == 0 )); then
2219         printf '
2220 grml_theme_add_token: No token-string/function-name provided!\n\n'
2221         GRML_theme_add_token_usage
2222         return 1
2223     fi
2224     token=$1
2225     shift
2226     if (( ARGC != 0 && ARGC != 2 )); then
2227         printf '
2228 grml_theme_add_token: <pre> and <post> need to by specified _both_!\n\n'
2229         GRML_theme_add_token_usage
2230         return 1
2231     fi
2232     if (( ARGC )); then
2233         pre=$1
2234         post=$2
2235         shift 2
2236     fi
2237
2238     if grml_theme_has_token $name; then
2239         printf '
2240 grml_theme_add_token: Token `%s'\'' exists! Giving up!\n\n' $name
2241         GRML_theme_add_token_usage
2242         return 2
2243     fi
2244     if (( init )); then
2245         $token $name
2246         token=$REPLY
2247     fi
2248     grml_prompt_pre_default[$name]=$pre
2249     grml_prompt_post_default[$name]=$post
2250     if (( funcall )); then
2251         grml_prompt_token_function[$name]=$token
2252         grml_prompt_token_default[$name]=23
2253     else
2254         grml_prompt_token_default[$name]=$token
2255     fi
2256 }
2257
2258 function grml_typeset_and_wrap () {
2259     emulate -L zsh
2260     local target="$1"
2261     local new="$2"
2262     local left="$3"
2263     local right="$4"
2264
2265     if (( ${+parameters[$new]} )); then
2266         typeset -g "${target}=${(P)target}${left}${(P)new}${right}"
2267     fi
2268 }
2269
2270 function grml_prompt_addto () {
2271     emulate -L zsh
2272     local target="$1"
2273     local lr it apre apost new v
2274     local -a items
2275     shift
2276
2277     [[ $target == PS1 ]] && lr=left || lr=right
2278     zstyle -a ":prompt:${grmltheme}:${lr}:setup" items items || items=( "$@" )
2279     typeset -g "${target}="
2280     for it in "${items[@]}"; do
2281         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" pre apre \
2282             || apre=${grml_prompt_pre_default[$it]}
2283         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" post apost \
2284             || apost=${grml_prompt_post_default[$it]}
2285         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" token new \
2286             || new=${grml_prompt_token_default[$it]}
2287         typeset -g "${target}=${(P)target}${apre}"
2288         if (( ${+grml_prompt_token_function[$it]} )); then
2289             ${grml_prompt_token_function[$it]} $it
2290             typeset -g "${target}=${(P)target}${REPLY}"
2291         else
2292             case $it in
2293             battery)
2294                 grml_typeset_and_wrap $target $new '' ''
2295                 ;;
2296             change-root)
2297                 grml_typeset_and_wrap $target $new '(' ')'
2298                 ;;
2299             grml-chroot)
2300                 if [[ -n ${(P)new} ]]; then
2301                     typeset -g "${target}=${(P)target}(CHROOT)"
2302                 fi
2303                 ;;
2304             vcs)
2305                 v="vcs_info_msg_${new}_"
2306                 if (( ! vcscalled )); then
2307                     vcs_info
2308                     vcscalled=1
2309                 fi
2310                 if (( ${+parameters[$v]} )) && [[ -n "${(P)v}" ]]; then
2311                     typeset -g "${target}=${(P)target}${(P)v}"
2312                 fi
2313                 ;;
2314             *) typeset -g "${target}=${(P)target}${new}" ;;
2315             esac
2316         fi
2317         typeset -g "${target}=${(P)target}${apost}"
2318     done
2319 }
2320
2321 function prompt_grml_precmd () {
2322     emulate -L zsh
2323     local grmltheme=grml
2324     local -a left_items right_items
2325     left_items=(rc change-root user at host path vcs percent)
2326     right_items=(sad-smiley)
2327
2328     prompt_grml_precmd_worker
2329 }
2330
2331 function prompt_grml-chroot_precmd () {
2332     emulate -L zsh
2333     local grmltheme=grml-chroot
2334     local -a left_items right_items
2335     left_items=(grml-chroot user at host path percent)
2336     right_items=()
2337
2338     prompt_grml_precmd_worker
2339 }
2340
2341 function prompt_grml-large_precmd () {
2342     emulate -L zsh
2343     local grmltheme=grml-large
2344     local -a left_items right_items
2345     left_items=(rc jobs history shell-level change-root time date newline
2346                 user at host path vcs percent)
2347     right_items=(sad-smiley)
2348
2349     prompt_grml_precmd_worker
2350 }
2351
2352 function prompt_grml_precmd_worker () {
2353     emulate -L zsh
2354     local -i vcscalled=0
2355
2356     grml_prompt_addto PS1 "${left_items[@]}"
2357     if zstyle -T ":prompt:${grmltheme}:right:setup" use-rprompt; then
2358         grml_prompt_addto RPS1 "${right_items[@]}"
2359     fi
2360 }
2361
2362 function grml_prompt_fallback () {
2363     setopt prompt_subst
2364     local p0 p1
2365
2366     p0="${RED}%(?..%? )${WHITE}${debian_chroot:+($debian_chroot)}"
2367     p1="${BLUE}%n${NO_COLOR}@%m %40<...<%B%~%b%<< "'${vcs_info_msg_0_}'"%# "
2368     if (( EUID == 0 )); then
2369         PROMPT="${BLUE}${p0}${RED}${p1}"
2370     else
2371         PROMPT="${RED}${p0}${BLUE}${p1}"
2372     fi
2373 }
2374
2375 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2376     # Since we define the required functions in here and not in files in
2377     # $fpath, we need to stick the theme's name into `$prompt_themes'
2378     # ourselves, since promptinit does not pick them up otherwise.
2379     prompt_themes+=( grml grml-chroot grml-large )
2380     # Also, keep the array sorted...
2381     prompt_themes=( "${(@on)prompt_themes}" )
2382 else
2383     print 'Notice: no promptinit available :('
2384     grml_prompt_fallback
2385     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2386 fi
2387
2388 if is437; then
2389     # The prompt themes use modern features of zsh, that require at least
2390     # version 4.3.7 of the shell. Use the fallback otherwise.
2391     if [[ $GRML_DISPLAY_BATTERY -gt 0 ]]; then
2392         zstyle ':prompt:grml:right:setup' items sad-smiley battery
2393         add-zsh-hook precmd battery
2394     fi
2395     if [[ "$TERM" == dumb ]] ; then
2396         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" pre ''
2397         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" post ' '
2398         for i in rc user path jobs history date time shell-level; do
2399             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" pre ''
2400             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" post ''
2401         done
2402         unset i
2403         zstyle ':prompt:grml(|-large|-chroot):right:setup' use-rprompt false
2404     elif (( EUID == 0 )); then
2405         zstyle ':prompt:grml(|-large|-chroot):*:items:user' pre '%B%F{red}'
2406     fi
2407
2408     # Finally enable one of the prompts.
2409     if [[ -n $GRML_CHROOT ]]; then
2410         prompt grml-chroot
2411     elif [[ $GRMLPROMPT -gt 0 ]]; then
2412         prompt grml-large
2413     else
2414         prompt grml
2415     fi
2416 else
2417     grml_prompt_fallback
2418     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2419 fi
2420
2421 # Terminal-title wizardry
2422
2423 function ESC_print () {
2424     info_print $'\ek' $'\e\\' "$@"
2425 }
2426 function set_title () {
2427     info_print  $'\e]0;' $'\a' "$@"
2428 }
2429
2430 function info_print () {
2431     local esc_begin esc_end
2432     esc_begin="$1"
2433     esc_end="$2"
2434     shift 2
2435     printf '%s' ${esc_begin}
2436     printf '%s' "$*"
2437     printf '%s' "${esc_end}"
2438 }
2439
2440 function grml_reset_screen_title () {
2441     # adjust title of xterm
2442     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2443     [[ ${NOTITLE:-} -gt 0 ]] && return 0
2444     case $TERM in
2445         (xterm*|rxvt*)
2446             set_title ${(%):-"%n@%m: %~"}
2447             ;;
2448     esac
2449 }
2450
2451 function grml_vcs_to_screen_title () {
2452     if [[ $TERM == screen* ]] ; then
2453         if [[ -n ${vcs_info_msg_1_} ]] ; then
2454             ESC_print ${vcs_info_msg_1_}
2455         else
2456             ESC_print "zsh"
2457         fi
2458     fi
2459 }
2460
2461 function grml_maintain_name () {
2462     # set hostname if not running on host with name 'grml'
2463     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2464        NAME="@$HOSTNAME"
2465     fi
2466 }
2467
2468 function grml_cmd_to_screen_title () {
2469     # get the name of the program currently running and hostname of local
2470     # machine set screen window title if running in a screen
2471     if [[ "$TERM" == screen* ]] ; then
2472         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME"
2473         ESC_print ${CMD}
2474     fi
2475 }
2476
2477 function grml_control_xterm_title () {
2478     case $TERM in
2479         (xterm*|rxvt*)
2480             set_title "${(%):-"%n@%m:"}" "$1"
2481             ;;
2482     esac
2483 }
2484
2485 # The following autoload is disabled for now, since this setup includes a
2486 # static version of the ‘add-zsh-hook’ function above. It needs to be
2487 # reenabled as soon as that static definition is removed again.
2488 #zrcautoload add-zsh-hook || add-zsh-hook () { :; }
2489 if [[ $NOPRECMD -eq 0 ]]; then
2490     add-zsh-hook precmd grml_reset_screen_title
2491     add-zsh-hook precmd grml_vcs_to_screen_title
2492     add-zsh-hook preexec grml_maintain_name
2493     add-zsh-hook preexec grml_cmd_to_screen_title
2494     if [[ $NOTITLE -eq 0 ]]; then
2495         add-zsh-hook preexec grml_control_xterm_title
2496     fi
2497 fi
2498
2499 # 'hash' some often used directories
2500 #d# start
2501 hash -d deb=/var/cache/apt/archives
2502 hash -d doc=/usr/share/doc
2503 hash -d linux=/lib/modules/$(command uname -r)/build/
2504 hash -d log=/var/log
2505 hash -d slog=/var/log/syslog
2506 hash -d src=/usr/src
2507 hash -d www=/var/www
2508 #d# end
2509
2510 # some aliases
2511 if check_com -c screen ; then
2512     if [[ $UID -eq 0 ]] ; then
2513         if [[ -r /etc/grml/screenrc ]]; then
2514             alias screen='screen -c /etc/grml/screenrc'
2515         fi
2516     elif [[ ! -r $HOME/.screenrc ]] ; then
2517         if [[ -r /etc/grml/screenrc_grml ]]; then
2518             alias screen='screen -c /etc/grml/screenrc_grml'
2519         else
2520             if [[ -r /etc/grml/screenrc ]]; then
2521                 alias screen='screen -c /etc/grml/screenrc'
2522             fi
2523         fi
2524     fi
2525 fi
2526
2527 # do we have GNU ls with color-support?
2528 if [[ "$TERM" != dumb ]]; then
2529     #a1# List files with colors (\kbd{ls \ldots})
2530     alias ls="command ls ${ls_options:+${ls_options[*]}}"
2531     #a1# List all files, with colors (\kbd{ls -la \ldots})
2532     alias la="command ls -la ${ls_options:+${ls_options[*]}}"
2533     #a1# List files with long colored list, without dotfiles (\kbd{ls -l \ldots})
2534     alias ll="command ls -l ${ls_options:+${ls_options[*]}}"
2535     #a1# List files with long colored list, human readable sizes (\kbd{ls -hAl \ldots})
2536     alias lh="command ls -hAl ${ls_options:+${ls_options[*]}}"
2537     #a1# List files with long colored list, append qualifier to filenames (\kbd{ls -l \ldots})\\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2538     alias l="command ls -l ${ls_options:+${ls_options[*]}}"
2539 else
2540     alias la='command ls -la'
2541     alias ll='command ls -l'
2542     alias lh='command ls -hAl'
2543     alias l='command ls -l'
2544 fi
2545
2546 if [[ -r /proc/mdstat ]]; then
2547     alias mdstat='cat /proc/mdstat'
2548 fi
2549
2550 alias ...='cd ../../'
2551
2552 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2553 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2554     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2555 fi
2556
2557 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2558 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2559 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2560
2561 # make sure it is not assigned yet
2562 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2563 function utf2iso () {
2564     if isutfenv ; then
2565         local ENV
2566         for ENV in $(env | command grep -i '.utf') ; do
2567             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2568         done
2569     fi
2570 }
2571
2572 # make sure it is not assigned yet
2573 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2574 function iso2utf () {
2575     if ! isutfenv ; then
2576         local ENV
2577         for ENV in $(env | command grep -i '\.iso') ; do
2578             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2579         done
2580     fi
2581 }
2582
2583 # especially for roadwarriors using GNU screen and ssh:
2584 if ! check_com asc &>/dev/null ; then
2585   function asc () { autossh -t "$@" 'screen -RdU' }
2586   compdef asc=ssh
2587 fi
2588
2589 #f1# Hints for the use of zsh on grml
2590 function zsh-help () {
2591     print "$bg[white]$fg[black]
2592 zsh-help - hints for use of zsh on grml
2593 =======================================$reset_color"
2594
2595     print '
2596 Main configuration of zsh happens in /etc/zsh/zshrc.
2597 That file is part of the package grml-etc-core, if you want to
2598 use them on a non-grml-system just get the tar.gz from
2599 http://deb.grml.org/ or (preferably) get it from the git repository:
2600
2601   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2602
2603 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2604 The file is still there, but it is empty for backwards compatibility.
2605
2606 For your own changes use these two files:
2607     $HOME/.zshrc.pre
2608     $HOME/.zshrc.local
2609
2610 The former is sourced very early in our zshrc, the latter is sourced
2611 very lately.
2612
2613 System wide configuration without touching configuration files of grml
2614 can take place in /etc/zsh/zshrc.local.
2615
2616 For information regarding zsh start at http://grml.org/zsh/
2617
2618 Take a look at grml'\''s zsh refcard:
2619 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2620
2621 Check out the main zsh refcard:
2622 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2623
2624 And of course visit the zsh-lovers:
2625 % man zsh-lovers
2626
2627 You can adjust some options through environment variables when
2628 invoking zsh without having to edit configuration files.
2629 Basically meant for bash users who are not used to the power of
2630 the zsh yet. :)
2631
2632   "NOCOR=1    zsh" => deactivate automatic correction
2633   "NOMENU=1   zsh" => do not use auto menu completion
2634                       (note: use ctrl-d for completion instead!)
2635   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2636   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2637                       preexec() and precmd() completely
2638   "GRML_DISPLAY_BATTERY=1  zsh"
2639                    => activate battery status on right side of prompt (WIP)
2640   "COMMAND_NOT_FOUND=1 zsh"
2641                    => Enable a handler if an external command was not found
2642                       The command called in the handler can be altered by setting
2643                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2644                       "/usr/share/command-not-found/command-not-found"
2645
2646 A value greater than 0 is enables a feature; a value equal to zero
2647 disables it. If you like one or the other of these settings, you can
2648 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2649 zshrc.'
2650
2651     print "
2652 $bg[white]$fg[black]
2653 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2654 Enjoy your grml system with the zsh!$reset_color"
2655 }
2656
2657 # debian stuff
2658 if [[ -r /etc/debian_version ]] ; then
2659     if [[ -z "$GRML_NO_APT_ALIASES" ]]; then
2660         #a3# Execute \kbd{apt-cache search}
2661         alias acs='apt-cache search'
2662         #a3# Execute \kbd{apt-cache show}
2663         alias acsh='apt-cache show'
2664         #a3# Execute \kbd{apt-cache policy}
2665         alias acp='apt-cache policy'
2666         #a3# Execute \kbd{apt-get dist-upgrade}
2667         salias adg="apt-get dist-upgrade"
2668         #a3# Execute \kbd{apt-get install}
2669         salias agi="apt-get install"
2670         #a3# Execute \kbd{aptitude install}
2671         salias ati="aptitude install"
2672         #a3# Execute \kbd{apt-get upgrade}
2673         salias ag="apt-get upgrade"
2674         #a3# Execute \kbd{apt-get update}
2675         salias au="apt-get update"
2676         #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2677         salias -a up="aptitude update ; aptitude safe-upgrade"
2678         #a3# Execute \kbd{dpkg-buildpackage}
2679         alias dbp='dpkg-buildpackage'
2680         #a3# Execute \kbd{grep-excuses}
2681         alias ge='grep-excuses'
2682     fi
2683
2684     # get a root shell as normal user in live-cd mode:
2685     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2686        alias su="sudo su"
2687     fi
2688
2689 fi
2690
2691 # use /var/log/syslog iff present, fallback to journalctl otherwise
2692 if [ -e /var/log/syslog ] ; then
2693   #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog || journalctl}
2694   salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2695   #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog || journalctl}
2696   salias tlog="tail -f /var/log/syslog"    # follow the syslog
2697 elif check_com -c journalctl ; then
2698   salias llog="journalctl"
2699   salias tlog="journalctl -f"
2700 fi
2701
2702 # sort installed Debian-packages by size
2703 if check_com -c dpkg-query ; then
2704     #a3# List installed Debian-packages sorted by size
2705     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"
2706 fi
2707
2708 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2709 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2710     if check_com -c wodim; then
2711         function cdrecord () {
2712             <<__EOF0__
2713 cdrecord is not provided under its original name by Debian anymore.
2714 See #377109 in the BTS of Debian for more details.
2715
2716 Please use the wodim binary instead
2717 __EOF0__
2718             return 1
2719         }
2720     fi
2721 fi
2722
2723 if isgrmlcd; then
2724     # No core dumps: important for a live-cd-system
2725     limit -s core 0
2726 fi
2727
2728 # grmlstuff
2729 function grmlstuff () {
2730 # people should use 'grml-x'!
2731     if check_com -c 915resolution; then
2732         function 855resolution () {
2733             echo "Please use 915resolution as resolution modifying tool for Intel \
2734 graphic chipset."
2735             return -1
2736         }
2737     fi
2738
2739     #a1# Output version of running grml
2740     alias grml-version='cat /etc/grml_version'
2741
2742     if check_com -c grml-debootstrap ; then
2743         function debian2hd () {
2744             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2745             return 1
2746         }
2747     fi
2748 }
2749
2750 # now run the functions
2751 isgrml && checkhome
2752 is4    && isgrml    && grmlstuff
2753 is4    && grmlcomp
2754
2755 # keephack
2756 is4 && xsource "/etc/zsh/keephack"
2757
2758 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2759 # You use it as follows:
2760 # $ NTREF=/reference/file
2761 # $ ls -l *(e:nt:)
2762 # This lists all the files in the current directory newer than the reference file.
2763 # You can also specify the reference file inline; note quotes:
2764 # $ ls -l *(e:'nt ~/.zshenv':)
2765 is4 && function nt () {
2766     if [[ -n $1 ]] ; then
2767         local NTREF=${~1}
2768     fi
2769     [[ $REPLY -nt $NTREF ]]
2770 }
2771
2772 # shell functions
2773
2774 #f1# Reload an autoloadable function
2775 function freload () { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2776 compdef _functions freload
2777
2778 #
2779 # Usage:
2780 #
2781 #      e.g.:   a -> b -> c -> d  ....
2782 #
2783 #      sll a
2784 #
2785 #
2786 #      if parameter is given with leading '=', lookup $PATH for parameter and resolve that
2787 #
2788 #      sll =java
2789 #
2790 #      Note: limit for recursive symlinks on linux:
2791 #            http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?id=refs/heads/master#l808
2792 #            This limits recursive symlink follows to 8,
2793 #            while limiting consecutive symlinks to 40.
2794 #
2795 #      When resolving and displaying information about symlinks, no check is made
2796 #      that the displayed information does make any sense on your OS.
2797 #      We leave that decission to the user.
2798 #
2799 #      The zstat module is used to detect symlink loops. zstat is available since zsh4.
2800 #      With an older zsh you will need to abort with <C-c> in that case.
2801 #      When a symlink loop is detected, a warning ist printed and further processing is stopped.
2802 #
2803 #      Module zstat is loaded by default in grml zshrc, no extra action needed for that.
2804 #
2805 #      Known bugs:
2806 #      If you happen to come accross a symlink that points to a destination on an other partition
2807 #      with the same inode number, that will be marked as symlink loop though it is not.
2808 #      Two hints for this situation:
2809 #      I)  Play lottery the same day, as you seem to be rather lucky right now.
2810 #      II) Send patches.
2811 #
2812 #      return status:
2813 #      0 upon success
2814 #      1 file/dir not accesible
2815 #      2 symlink loop detected
2816 #
2817 #f1# List symlinks in detail (more detailed version of 'readlink -f', 'whence -s' and 'namei -l')
2818 function sll () {
2819     if [[ -z ${1} ]] ; then
2820         printf 'Usage: %s <symlink(s)>\n' "${0}"
2821         return 1
2822     fi
2823
2824     local file jumpd curdir
2825     local -i 10 RTN LINODE i
2826     local -a    SEENINODES
2827     curdir="${PWD}"
2828     RTN=0
2829
2830     for file in "${@}" ; do
2831         SEENINODES=()
2832         ls -l "${file:a}"   || RTN=1
2833
2834         while [[ -h "$file" ]] ; do
2835             if is4 ; then
2836                 LINODE=$(zstat -L +inode "${file}")
2837                 for i in ${SEENINODES} ; do
2838                     if (( ${i} == ${LINODE} )) ; then
2839                         builtin cd -q "${curdir}"
2840                         print 'link loop detected, aborting!'
2841                         return 2
2842                     fi
2843                 done
2844                 SEENINODES+=${LINODE}
2845             fi
2846             jumpd="${file:h}"
2847             file="${file:t}"
2848
2849             if [[ -d ${jumpd} ]] ; then
2850                 builtin cd -q "${jumpd}"  || RTN=1
2851             fi
2852             file=$(readlink "$file")
2853
2854             jumpd="${file:h}"
2855             file="${file:t}"
2856
2857             if [[ -d ${jumpd} ]] ; then
2858                 builtin cd -q "${jumpd}"  || RTN=1
2859             fi
2860
2861             ls -l "${PWD}/${file}"     || RTN=1
2862         done
2863         shift 1
2864         if (( ${#} >= 1 )) ; then
2865             print ""
2866         fi
2867         builtin cd -q "${curdir}"
2868     done
2869     return ${RTN}
2870 }
2871
2872 # TODO: Is it supported to use pager settings like this?
2873 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2874 # with respect to wordsplitting. (ie. ${=PAGER})
2875 if check_com -c $PAGER ; then
2876     #f3# View Debian's changelog of given package(s)
2877     function dchange () {
2878         emulate -L zsh
2879         [[ -z "$1" ]] && printf 'Usage: %s <package_name(s)>\n' "$0" && return 1
2880
2881         local package
2882         for package in "$@" ; do
2883             if [[ -r /usr/share/doc/${package}/changelog.Debian.gz ]] ; then
2884                 $PAGER /usr/share/doc/${package}/changelog.Debian.gz
2885             elif [[ -r /usr/share/doc/${package}/changelog.gz ]] ; then
2886                 $PAGER /usr/share/doc/${package}/changelog.gz
2887             elif [[ -r /usr/share/doc/${package}/changelog ]] ; then
2888                 $PAGER /usr/share/doc/${package}/changelog
2889             else
2890                 if check_com -c aptitude ; then
2891                     echo "No changelog for package $package found, using aptitude to retrieve it."
2892                     aptitude changelog "$package"
2893                 elif check_com -c apt-get ; then
2894                     echo "No changelog for package $package found, using apt-get to retrieve it."
2895                     apt-get changelog "$package"
2896                 else
2897                     echo "No changelog for package $package found, sorry."
2898                 fi
2899             fi
2900         done
2901     }
2902     function _dchange () { _files -W /usr/share/doc -/ }
2903     compdef _dchange dchange
2904
2905     #f3# View Debian's NEWS of a given package
2906     function dnews () {
2907         emulate -L zsh
2908         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2909             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2910         else
2911             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2912                 $PAGER /usr/share/doc/$1/NEWS.gz
2913             else
2914                 echo "No NEWS file for package $1 found, sorry."
2915                 return 1
2916             fi
2917         fi
2918     }
2919     function _dnews () { _files -W /usr/share/doc -/ }
2920     compdef _dnews dnews
2921
2922     #f3# View Debian's copyright of a given package
2923     function dcopyright () {
2924         emulate -L zsh
2925         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2926             $PAGER /usr/share/doc/$1/copyright
2927         else
2928             echo "No copyright file for package $1 found, sorry."
2929             return 1
2930         fi
2931     }
2932     function _dcopyright () { _files -W /usr/share/doc -/ }
2933     compdef _dcopyright dcopyright
2934
2935     #f3# View upstream's changelog of a given package
2936     function uchange () {
2937         emulate -L zsh
2938         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2939             $PAGER /usr/share/doc/$1/changelog.gz
2940         else
2941             echo "No changelog for package $1 found, sorry."
2942             return 1
2943         fi
2944     }
2945     function _uchange () { _files -W /usr/share/doc -/ }
2946     compdef _uchange uchange
2947 fi
2948
2949 # zsh profiling
2950 function profile () {
2951     ZSH_PROFILE_RC=1 zsh "$@"
2952 }
2953
2954 #f1# Edit an alias via zle
2955 function edalias () {
2956     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2957 }
2958 compdef _aliases edalias
2959
2960 #f1# Edit a function via zle
2961 function edfunc () {
2962     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2963 }
2964 compdef _functions edfunc
2965
2966 # use it e.g. via 'Restart apache2'
2967 #m# f6 Start() \kbd{service \em{process}}\quad\kbd{start}
2968 #m# f6 Restart() \kbd{service \em{process}}\quad\kbd{restart}
2969 #m# f6 Stop() \kbd{service \em{process}}\quad\kbd{stop}
2970 #m# f6 Reload() \kbd{service \em{process}}\quad\kbd{reload}
2971 #m# f6 Force-Reload() \kbd{service \em{process}}\quad\kbd{force-reload}
2972 #m# f6 Status() \kbd{service \em{process}}\quad\kbd{status}
2973 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2974     function __start_stop () {
2975         local action_="${1:l}"  # e.g Start/Stop/Restart
2976         local service_="$2"
2977         local param_="$3"
2978
2979         local service_target_="$(readlink /etc/init.d/$service_)"
2980         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2981             # runit
2982             case "${action_}" in
2983                 start) if [[ ! -e /etc/service/$service_ ]]; then
2984                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2985                        else
2986                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2987                        fi ;;
2988                 # there is no reload in runits sysv emulation
2989                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2990                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2991             esac
2992         else
2993             # sysv/sysvinit-utils, upstart
2994             if check_com -c service ; then
2995               $SUDO service "$service_" "${action_}" "$param_"
2996             else
2997               $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2998             fi
2999         fi
3000     }
3001
3002     function _grmlinitd () {
3003         local -a scripts
3004         scripts=( /etc/init.d/*(x:t) )
3005         _describe "service startup script" scripts
3006     }
3007
3008     for i in Start Restart Stop Force-Reload Reload Status ; do
3009         eval "function $i () { __start_stop $i \"\$1\" \"\$2\" ; }"
3010         compdef _grmlinitd $i
3011     done
3012     builtin unset -v i
3013 fi
3014
3015 #f1# Provides useful information on globbing
3016 function H-Glob () {
3017     echo -e "
3018     /      directories
3019     .      plain files
3020     @      symbolic links
3021     =      sockets
3022     p      named pipes (FIFOs)
3023     *      executable plain files (0100)
3024     %      device files (character or block special)
3025     %b     block special files
3026     %c     character special files
3027     r      owner-readable files (0400)
3028     w      owner-writable files (0200)
3029     x      owner-executable files (0100)
3030     A      group-readable files (0040)
3031     I      group-writable files (0020)
3032     E      group-executable files (0010)
3033     R      world-readable files (0004)
3034     W      world-writable files (0002)
3035     X      world-executable files (0001)
3036     s      setuid files (04000)
3037     S      setgid files (02000)
3038     t      files with the sticky bit (01000)
3039
3040   print *(m-1)          # Files modified up to a day ago
3041   print *(a1)           # Files accessed a day ago
3042   print *(@)            # Just symlinks
3043   print *(Lk+50)        # Files bigger than 50 kilobytes
3044   print *(Lk-50)        # Files smaller than 50 kilobytes
3045   print **/*.c          # All *.c files recursively starting in \$PWD
3046   print **/*.c~file.c   # Same as above, but excluding 'file.c'
3047   print (foo|bar).*     # Files starting with 'foo' or 'bar'
3048   print *~*.*           # All Files that do not contain a dot
3049   chmod 644 *(.^x)      # make all plain non-executable files publically readable
3050   print -l *(.c|.h)     # Lists *.c and *.h
3051   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
3052   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
3053 }
3054 alias help-zshglob=H-Glob
3055
3056 # grep for running process, like: 'any vim'
3057 function any () {
3058     emulate -L zsh
3059     unsetopt KSH_ARRAYS
3060     if [[ -z "$1" ]] ; then
3061         echo "any - grep for process(es) by keyword" >&2
3062         echo "Usage: any <keyword>" >&2 ; return 1
3063     else
3064         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
3065     fi
3066 }
3067
3068
3069 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
3070 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
3071 [[ -r /proc/1/maps ]] && \
3072 function deswap () {
3073     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
3074     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
3075     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
3076 }
3077
3078 # a wrapper for vim, that deals with title setting
3079 #   VIM_OPTIONS
3080 #       set this array to a set of options to vim you always want
3081 #       to have set when calling vim (in .zshrc.local), like:
3082 #           VIM_OPTIONS=( -p )
3083 #       This will cause vim to send every file given on the
3084 #       commandline to be send to it's own tab (needs vim7).
3085 if check_com vim; then
3086     function vim () {
3087         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3088     }
3089 fi
3090
3091 ssl_hashes=( sha512 sha256 sha1 md5 )
3092
3093 for sh in ${ssl_hashes}; do
3094     eval 'ssl-cert-'${sh}'() {
3095         emulate -L zsh
3096         if [[ -z $1 ]] ; then
3097             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
3098             return 1
3099         fi
3100         openssl x509 -noout -fingerprint -'${sh}' -in $1
3101     }'
3102 done; unset sh
3103
3104 function ssl-cert-fingerprints () {
3105     emulate -L zsh
3106     local i
3107     if [[ -z $1 ]] ; then
3108         printf 'usage: ssl-cert-fingerprints <file>\n'
3109         return 1
3110     fi
3111     for i in ${ssl_hashes}
3112         do ssl-cert-$i $1;
3113     done
3114 }
3115
3116 function ssl-cert-info () {
3117     emulate -L zsh
3118     if [[ -z $1 ]] ; then
3119         printf 'usage: ssl-cert-info <file>\n'
3120         return 1
3121     fi
3122     openssl x509 -noout -text -in $1
3123     ssl-cert-fingerprints $1
3124 }
3125
3126 # make sure our environment is clean regarding colors
3127 builtin unset -v BLUE RED GREEN CYAN YELLOW MAGENTA WHITE NO_COLOR
3128
3129 # "persistent history"
3130 # just write important commands you always need to $GRML_IMPORTANT_COMMANDS
3131 # defaults for backward compatibility to ~/.important_commands
3132 if [[ -r ~/.important_commands ]] ; then
3133     GRML_IMPORTANT_COMMANDS=~/.important_commands
3134 else
3135     GRML_IMPORTANT_COMMANDS=${GRML_IMPORTANT_COMMANDS:-${ZDOTDIR:-${HOME}}/.important_commands}
3136 fi
3137 [[ -r ${GRML_IMPORTANT_COMMANDS} ]] && builtin fc -R ${GRML_IMPORTANT_COMMANDS}
3138
3139 # load the lookup subsystem if it's available on the system
3140 zrcautoload lookupinit && lookupinit
3141
3142 # variables
3143
3144 # set terminal property (used e.g. by msgid-chooser)
3145 export COLORTERM="yes"
3146
3147 # aliases
3148
3149 # general
3150 #a2# Execute \kbd{du -sch}
3151 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias da='du -sch'
3152
3153 # listing stuff
3154 #a2# Execute \kbd{ls -lSrah}
3155 alias dir="command ls -lSrah"
3156 #a2# Only show dot-directories
3157 alias lad='command ls -d .*(/)'
3158 #a2# Only show dot-files
3159 alias lsa='command ls -a .*(.)'
3160 #a2# Only files with setgid/setuid/sticky flag
3161 alias lss='command ls -l *(s,S,t)'
3162 #a2# Only show symlinks
3163 alias lsl='command ls -l *(@)'
3164 #a2# Display only executables
3165 alias lsx='command ls -l *(*)'
3166 #a2# Display world-{readable,writable,executable} files
3167 alias lsw='command ls -ld *(R,W,X.^ND/)'
3168 #a2# Display the ten biggest files
3169 alias lsbig="command ls -flh *(.OL[1,10])"
3170 #a2# Only show directories
3171 alias lsd='command ls -d *(/)'
3172 #a2# Only show empty directories
3173 alias lse='command ls -d *(/^F)'
3174 #a2# Display the ten newest files
3175 alias lsnew="command ls -rtlh *(D.om[1,10])"
3176 #a2# Display the ten oldest files
3177 alias lsold="command ls -rtlh *(D.Om[1,10])"
3178 #a2# Display the ten smallest files
3179 alias lssmall="command ls -Srl *(.oL[1,10])"
3180 #a2# Display the ten newest directories and ten newest .directories
3181 alias lsnewdir="command ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
3182 #a2# Display the ten oldest directories and ten oldest .directories
3183 alias lsolddir="command ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
3184
3185 # some useful aliases
3186 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir \$OLDCWD}
3187 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
3188
3189 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3190 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3191 #a2# scp with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3192 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3193
3194 # work around non utf8 capable software in utf environment via $LANG and luit
3195 if check_com isutfenv && check_com luit ; then
3196     if check_com -c mrxvt ; then
3197         isutfenv && [[ -n "$LANG" ]] && \
3198             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3199     fi
3200
3201     if check_com -c aterm ; then
3202         isutfenv && [[ -n "$LANG" ]] && \
3203             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3204     fi
3205
3206     if check_com -c centericq ; then
3207         isutfenv && [[ -n "$LANG" ]] && \
3208             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3209     fi
3210 fi
3211
3212 # useful functions
3213
3214 #f5# Backup \kbd{file_or_folder {\rm to} file_or_folder\_timestamp}
3215 function bk () {
3216     emulate -L zsh
3217     local current_date=$(date -u "+%Y-%m-%dT%H:%M:%SZ")
3218     local clean keep move verbose result all to_bk
3219     setopt extended_glob
3220     keep=1
3221     while getopts ":hacmrv" opt; do
3222         case $opt in
3223             a) (( all++ ));;
3224             c) unset move clean && (( ++keep ));;
3225             m) unset keep clean && (( ++move ));;
3226             r) unset move keep && (( ++clean ));;
3227             v) verbose="-v";;
3228             h) <<__EOF0__
3229 bk [-hcmv] FILE [FILE ...]
3230 bk -r [-av] [FILE [FILE ...]]
3231 Backup a file or folder in place and append the timestamp
3232 Remove backups of a file or folder, or all backups in the current directory
3233
3234 Usage:
3235 -h    Display this help text
3236 -c    Keep the file/folder as is, create a copy backup using cp(1) (default)
3237 -m    Move the file/folder, using mv(1)
3238 -r    Remove backups of the specified file or directory, using rm(1). If none
3239       is provided, remove all backups in the current directory.
3240 -a    Remove all (even hidden) backups.
3241 -v    Verbose
3242
3243 The -c, -r and -m options are mutually exclusive. If specified at the same time,
3244 the last one is used.
3245
3246 The return code is the sum of all cp/mv/rm return codes.
3247 __EOF0__
3248 return 0;;
3249             \?) bk -h >&2; return 1;;
3250         esac
3251     done
3252     shift "$((OPTIND-1))"
3253     if (( keep > 0 )); then
3254         if islinux || isfreebsd; then
3255             for to_bk in "$@"; do
3256                 cp $verbose -a "${to_bk%/}" "${to_bk%/}_$current_date"
3257                 (( result += $? ))
3258             done
3259         else
3260             for to_bk in "$@"; do
3261                 cp $verbose -pR "${to_bk%/}" "${to_bk%/}_$current_date"
3262                 (( result += $? ))
3263             done
3264         fi
3265     elif (( move > 0 )); then
3266         while (( $# > 0 )); do
3267             mv $verbose "${1%/}" "${1%/}_$current_date"
3268             (( result += $? ))
3269             shift
3270         done
3271     elif (( clean > 0 )); then
3272         if (( $# > 0 )); then
3273             for to_bk in "$@"; do
3274                 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
3275                 (( result += $? ))
3276             done
3277         else
3278             if (( all > 0 )); then
3279                 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)
3280             else
3281                 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
3282             fi
3283             (( result += $? ))
3284         fi
3285     fi
3286     return $result
3287 }
3288
3289 #f5# cd to directoy and list files
3290 function cl () {
3291     emulate -L zsh
3292     cd $1 && ls -a
3293 }
3294
3295 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
3296 function cd () {
3297     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
3298         [[ ! -e ${1:h} ]] && return 1
3299         print "Correcting ${1} to ${1:h}"
3300         builtin cd ${1:h}
3301     else
3302         builtin cd "$@"
3303     fi
3304 }
3305
3306 #f5# Create Directoy and \kbd{cd} to it
3307 function mkcd () {
3308     if (( ARGC != 1 )); then
3309         printf 'usage: mkcd <new-directory>\n'
3310         return 1;
3311     fi
3312     if [[ ! -d "$1" ]]; then
3313         command mkdir -p "$1"
3314     else
3315         printf '`%s'\'' already exists: cd-ing.\n' "$1"
3316     fi
3317     builtin cd "$1"
3318 }
3319
3320 #f5# Create temporary directory and \kbd{cd} to it
3321 function cdt () {
3322     builtin cd "$(mktemp -d)"
3323     builtin pwd
3324 }
3325
3326 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
3327 function accessed () {
3328     emulate -L zsh
3329     print -l -- *(a-${1:-1})
3330 }
3331
3332 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
3333 function changed () {
3334     emulate -L zsh
3335     print -l -- *(c-${1:-1})
3336 }
3337
3338 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
3339 function modified () {
3340     emulate -L zsh
3341     print -l -- *(m-${1:-1})
3342 }
3343 # modified() was named new() in earlier versions, add an alias for backwards compatibility
3344 check_com new || alias new=modified
3345
3346 # use colors when GNU grep with color-support
3347 if (( $#grep_options > 0 )); then
3348     o=${grep_options:+"${grep_options[*]}"}
3349     #a2# Execute \kbd{grep -{}-color=auto}
3350     alias grep='grep '$o
3351     alias egrep='egrep '$o
3352     unset o
3353 fi
3354
3355 # Translate DE<=>EN
3356 # 'translate' looks up a word in a file with language-to-language
3357 # translations (field separator should be " : "). A typical wordlist looks
3358 # like the following:
3359 #  | english-word : german-translation
3360 # It's also only possible to translate english to german but not reciprocal.
3361 # Use the following oneliner to reverse the sort order:
3362 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3363 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3364 #f5# Translates a word
3365 function trans () {
3366     emulate -L zsh
3367     case "$1" in
3368         -[dD]*)
3369             translate -l de-en $2
3370             ;;
3371         -[eE]*)
3372             translate -l en-de $2
3373             ;;
3374         *)
3375             echo "Usage: $0 { -D | -E }"
3376             echo "         -D == German to English"
3377             echo "         -E == English to German"
3378     esac
3379 }
3380
3381 # Usage: simple-extract <file>
3382 # Using option -d deletes the original archive file.
3383 #f5# Smart archive extractor
3384 function simple-extract () {
3385     emulate -L zsh
3386     setopt extended_glob noclobber
3387     local ARCHIVE DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
3388     local RC=0
3389     zparseopts -D -E "d=DELETE_ORIGINAL"
3390     for ARCHIVE in "${@}"; do
3391         case $ARCHIVE in
3392             *(tar.bz2|tbz2|tbz))
3393                 DECOMP_CMD="tar -xvjf -"
3394                 USES_STDIN=true
3395                 USES_STDOUT=false
3396                 ;;
3397             *(tar.gz|tgz))
3398                 DECOMP_CMD="tar -xvzf -"
3399                 USES_STDIN=true
3400                 USES_STDOUT=false
3401                 ;;
3402             *(tar.xz|txz|tar.lzma))
3403                 DECOMP_CMD="tar -xvJf -"
3404                 USES_STDIN=true
3405                 USES_STDOUT=false
3406                 ;;
3407             *tar)
3408                 DECOMP_CMD="tar -xvf -"
3409                 USES_STDIN=true
3410                 USES_STDOUT=false
3411                 ;;
3412             *rar)
3413                 DECOMP_CMD="unrar x"
3414                 USES_STDIN=false
3415                 USES_STDOUT=false
3416                 ;;
3417             *lzh)
3418                 DECOMP_CMD="lha x"
3419                 USES_STDIN=false
3420                 USES_STDOUT=false
3421                 ;;
3422             *7z)
3423                 DECOMP_CMD="7z x"
3424                 USES_STDIN=false
3425                 USES_STDOUT=false
3426                 ;;
3427             *(zip|jar))
3428                 DECOMP_CMD="unzip"
3429                 USES_STDIN=false
3430                 USES_STDOUT=false
3431                 ;;
3432             *deb)
3433                 DECOMP_CMD="ar -x"
3434                 USES_STDIN=false
3435                 USES_STDOUT=false
3436                 ;;
3437             *bz2)
3438                 DECOMP_CMD="bzip2 -d -c -"
3439                 USES_STDIN=true
3440                 USES_STDOUT=true
3441                 ;;
3442             *(gz|Z))
3443                 DECOMP_CMD="gzip -d -c -"
3444                 USES_STDIN=true
3445                 USES_STDOUT=true
3446                 ;;
3447             *(xz|lzma))
3448                 DECOMP_CMD="xz -d -c -"
3449                 USES_STDIN=true
3450                 USES_STDOUT=true
3451                 ;;
3452             *)
3453                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
3454                 RC=$((RC+1))
3455                 continue
3456                 ;;
3457         esac
3458
3459         if ! check_com ${DECOMP_CMD[(w)1]}; then
3460             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
3461             RC=$((RC+2))
3462             continue
3463         fi
3464
3465         GZTARGET="${ARCHIVE:t:r}"
3466         if [[ -f $ARCHIVE ]] ; then
3467
3468             print "Extracting '$ARCHIVE' ..."
3469             if $USES_STDIN; then
3470                 if $USES_STDOUT; then
3471                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
3472                 else
3473                     ${=DECOMP_CMD} < "$ARCHIVE"
3474                 fi
3475             else
3476                 if $USES_STDOUT; then
3477                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
3478                 else
3479                     ${=DECOMP_CMD} "$ARCHIVE"
3480                 fi
3481             fi
3482             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
3483
3484         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
3485             if check_com curl; then
3486                 WGET_CMD="curl -L -s -o -"
3487             elif check_com wget; then
3488                 WGET_CMD="wget -q -O -"
3489             elif check_com fetch; then
3490                 WGET_CMD="fetch -q -o -"
3491             else
3492                 print "ERROR: neither wget, curl nor fetch is installed" >&2
3493                 RC=$((RC+4))
3494                 continue
3495             fi
3496             print "Downloading and Extracting '$ARCHIVE' ..."
3497             if $USES_STDIN; then
3498                 if $USES_STDOUT; then
3499                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
3500                     RC=$((RC+$?))
3501                 else
3502                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
3503                     RC=$((RC+$?))
3504                 fi
3505             else
3506                 if $USES_STDOUT; then
3507                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
3508                 else
3509                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
3510                 fi
3511             fi
3512
3513         else
3514             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
3515             RC=$((RC+8))
3516         fi
3517     done
3518     return $RC
3519 }
3520
3521 function __archive_or_uri () {
3522     _alternative \
3523         '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)"' \
3524         '_urls:Remote Archives:_urls'
3525 }
3526
3527 function _simple_extract () {
3528     _arguments \
3529         '-d[delete original archivefile after extraction]' \
3530         '*:Archive Or Uri:__archive_or_uri'
3531 }
3532 compdef _simple_extract simple-extract
3533 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias se=simple-extract
3534
3535 #f5# Change the xterm title from within GNU-screen
3536 function xtrename () {
3537     emulate -L zsh
3538     if [[ $1 != "-f" ]] ; then
3539         if [[ -z ${DISPLAY} ]] ; then
3540             printf 'xtrename only makes sense in X11.\n'
3541             return 1
3542         fi
3543     else
3544         shift
3545     fi
3546     if [[ -z $1 ]] ; then
3547         printf 'usage: xtrename [-f] "title for xterm"\n'
3548         printf '  renames the title of xterm from _within_ screen.\n'
3549         printf '  also works without screen.\n'
3550         printf '  will not work if DISPLAY is unset, use -f to override.\n'
3551         return 0
3552     fi
3553     print -n "\eP\e]0;${1}\C-G\e\\"
3554     return 0
3555 }
3556
3557 # Create small urls via http://goo.gl using curl(1).
3558 # API reference: https://code.google.com/apis/urlshortener/
3559 function zurl () {
3560     emulate -L zsh
3561     setopt extended_glob
3562
3563     if [[ -z $1 ]]; then
3564         print "USAGE: zurl <URL>"
3565         return 1
3566     fi
3567
3568     local PN url prog api json contenttype item
3569     local -a data
3570     PN=$0
3571     url=$1
3572
3573     # Prepend 'http://' to given URL where necessary for later output.
3574     if [[ ${url} != http(s|)://* ]]; then
3575         url='http://'${url}
3576     fi
3577
3578     if check_com -c curl; then
3579         prog=curl
3580     else
3581         print "curl is not available, but mandatory for ${PN}. Aborting."
3582         return 1
3583     fi
3584     api='https://www.googleapis.com/urlshortener/v1/url'
3585     contenttype="Content-Type: application/json"
3586     json="{\"longUrl\": \"${url}\"}"
3587     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
3588     # Parse the response
3589     for item in "${data[@]}"; do
3590         case "$item" in
3591             ' '#'"id":'*)
3592                 item=${item#*: \"}
3593                 item=${item%\",*}
3594                 printf '%s\n' "$item"
3595                 return 0
3596                 ;;
3597         esac
3598     done
3599     return 1
3600 }
3601
3602 #f2# Find history events by search pattern and list them by date.
3603 function whatwhen () {
3604     emulate -L zsh
3605     local usage help ident format_l format_s first_char remain first last
3606     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3607     help='Use `whatwhen -h'\'' for further explanations.'
3608     ident=${(l,${#${:-Usage: }},, ,)}
3609     format_l="${ident}%s\t\t\t%s\n"
3610     format_s="${format_l//(\\t)##/\\t}"
3611     # Make the first char of the word to search for case
3612     # insensitive; e.g. [aA]
3613     first_char=[${(L)1[1]}${(U)1[1]}]
3614     remain=${1[2,-1]}
3615     # Default search range is `-100'.
3616     first=${2:-\-100}
3617     # Optional, just used for `<first> <last>' given.
3618     last=$3
3619     case $1 in
3620         ("")
3621             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3622             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3623         ;;
3624         (-h)
3625             printf '%s\n\n' ${usage}
3626             print 'OPTIONS:'
3627             printf $format_l '-h' 'show help text'
3628             print '\f'
3629             print 'SEARCH RANGE:'
3630             printf $format_l "'0'" 'the whole history,'
3631             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3632             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3633             printf '\n%s\n' 'EXAMPLES:'
3634             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3635             printf $format_l 'whatwhen zsh -250'
3636             printf $format_l 'whatwhen foo 1 99'
3637         ;;
3638         (\?)
3639             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3640         ;;
3641         (*)
3642             # -l list results on stout rather than invoking $EDITOR.
3643             # -i Print dates as in YYYY-MM-DD.
3644             # -m Search for a - quoted - pattern within the history.
3645             fc -li -m "*${first_char}${remain}*" $first $last
3646         ;;
3647     esac
3648 }
3649
3650 # mercurial related stuff
3651 if check_com -c hg ; then
3652     # gnu like diff for mercurial
3653     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3654     #f5# GNU like diff for mercurial
3655     function hgdi () {
3656         emulate -L zsh
3657         local i
3658         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3659     }
3660
3661     # build debian package
3662     #a2# Alias for \kbd{hg-buildpackage}
3663     alias hbp='hg-buildpackage'
3664
3665     # execute commands on the versioned patch-queue from the current repos
3666     [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3667
3668     # diffstat for specific version of a mercurial repository
3669     #   hgstat      => display diffstat between last revision and tip
3670     #   hgstat 1234 => display diffstat between revision 1234 and tip
3671     #f5# Diffstat for specific version of a mercurial repos
3672     function hgstat () {
3673         emulate -L zsh
3674         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3675     }
3676
3677 fi # end of check whether we have the 'hg'-executable
3678
3679 # grml-small cleanups
3680
3681 # The following is used to remove zsh-config-items that do not work
3682 # in grml-small by default.
3683 # If you do not want these adjustments (for whatever reason), set
3684 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3685 # sources if it is there).
3686
3687 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3688
3689     unset abk[V]
3690     unalias    'V'      &> /dev/null
3691     unfunction vman     &> /dev/null
3692     unfunction viless   &> /dev/null
3693     unfunction 2html    &> /dev/null
3694
3695     # manpages are not in grmlsmall
3696     unfunction manzsh   &> /dev/null
3697     unfunction man2     &> /dev/null
3698
3699 fi
3700
3701 zrclocal
3702
3703 ## genrefcard.pl settings
3704
3705 ### doc strings for external functions from files
3706 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3707
3708 ### example: split functions-search 8,16,24,32
3709 #@# split functions-search 8
3710
3711 ## END OF FILE #################################################################
3712 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3713 # Local variables:
3714 # mode: sh
3715 # End: