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