etc/zsh/zshrc

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