etc/zsh/zshrc

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