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 # make sure to use right prompt only when not running a command
2482 is41 && setopt transient_rprompt
2483
2484 # Terminal-title wizardry
2485
2486 function ESC_print () {
2487     info_print $'\ek' $'\e\\' "$@"
2488 }
2489 function set_title () {
2490     info_print  $'\e]0;' $'\a' "$@"
2491 }
2492
2493 function info_print () {
2494     local esc_begin esc_end
2495     esc_begin="$1"
2496     esc_end="$2"
2497     shift 2
2498     printf '%s' ${esc_begin}
2499     printf '%s' "$*"
2500     printf '%s' "${esc_end}"
2501 }
2502
2503 function grml_reset_screen_title () {
2504     # adjust title of xterm
2505     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2506     [[ ${NOTITLE:-} -gt 0 ]] && return 0
2507     case $TERM in
2508         (xterm*|rxvt*)
2509             set_title ${(%):-"%n@%m: %~"}
2510             ;;
2511     esac
2512 }
2513
2514 function grml_vcs_to_screen_title () {
2515     if [[ $TERM == screen* ]] ; then
2516         if [[ -n ${vcs_info_msg_1_} ]] ; then
2517             ESC_print ${vcs_info_msg_1_}
2518         else
2519             ESC_print "zsh"
2520         fi
2521     fi
2522 }
2523
2524 function grml_maintain_name () {
2525     local localname
2526     localname="$(uname -n)"
2527
2528     # set hostname if not running on local machine
2529     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != "${localname}" ]] ; then
2530        NAME="@$HOSTNAME"
2531     fi
2532 }
2533
2534 function grml_cmd_to_screen_title () {
2535     # get the name of the program currently running and hostname of local
2536     # machine set screen window title if running in a screen
2537     if [[ "$TERM" == screen* ]] ; then
2538         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME"
2539         ESC_print ${CMD}
2540     fi
2541 }
2542
2543 function grml_control_xterm_title () {
2544     case $TERM in
2545         (xterm*|rxvt*)
2546             set_title "${(%):-"%n@%m:"}" "$2"
2547             ;;
2548     esac
2549 }
2550
2551 # The following autoload is disabled for now, since this setup includes a
2552 # static version of the ‘add-zsh-hook’ function above. It needs to be
2553 # re-enabled as soon as that static definition is removed again.
2554 #zrcautoload add-zsh-hook || add-zsh-hook () { :; }
2555 if [[ $NOPRECMD -eq 0 ]]; then
2556     add-zsh-hook precmd grml_reset_screen_title
2557     add-zsh-hook precmd grml_vcs_to_screen_title
2558     add-zsh-hook preexec grml_maintain_name
2559     add-zsh-hook preexec grml_cmd_to_screen_title
2560     if [[ $NOTITLE -eq 0 ]]; then
2561         add-zsh-hook preexec grml_control_xterm_title
2562     fi
2563 fi
2564
2565 # 'hash' some often used directories
2566 #d# start
2567 hash -d deb=/var/cache/apt/archives
2568 hash -d doc=/usr/share/doc
2569 hash -d linux=/lib/modules/$(command uname -r)/build/
2570 hash -d log=/var/log
2571 hash -d slog=/var/log/syslog
2572 hash -d src=/usr/src
2573 hash -d www=/var/www
2574 #d# end
2575
2576 # some aliases
2577 if check_com -c screen ; then
2578     if [[ $UID -eq 0 ]] ; then
2579         if [[ -r /etc/grml/screenrc ]]; then
2580             alias screen='screen -c /etc/grml/screenrc'
2581         fi
2582     elif [[ ! -r $HOME/.screenrc ]] ; then
2583         if [[ -r /etc/grml/screenrc_grml ]]; then
2584             alias screen='screen -c /etc/grml/screenrc_grml'
2585         else
2586             if [[ -r /etc/grml/screenrc ]]; then
2587                 alias screen='screen -c /etc/grml/screenrc'
2588             fi
2589         fi
2590     fi
2591 fi
2592
2593 # do we have GNU ls with color-support?
2594 if [[ "$TERM" != dumb ]]; then
2595     #a1# List files with colors (\kbd{ls \ldots})
2596     alias ls="command ls ${ls_options:+${ls_options[*]}}"
2597     #a1# List all files, with colors (\kbd{ls -la \ldots})
2598     alias la="command ls -la ${ls_options:+${ls_options[*]}}"
2599     #a1# List files with long colored list, without dotfiles (\kbd{ls -l \ldots})
2600     alias ll="command ls -l ${ls_options:+${ls_options[*]}}"
2601     #a1# List files with long colored list, human readable sizes (\kbd{ls -hAl \ldots})
2602     alias lh="command ls -hAl ${ls_options:+${ls_options[*]}}"
2603     #a1# List files with long colored list, append qualifier to filenames (\kbd{ls -l \ldots})\\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2604     alias l="command ls -l ${ls_options:+${ls_options[*]}}"
2605 else
2606     alias la='command ls -la'
2607     alias ll='command ls -l'
2608     alias lh='command ls -hAl'
2609     alias l='command ls -l'
2610 fi
2611
2612 if [[ -r /proc/mdstat ]]; then
2613     alias mdstat='cat /proc/mdstat'
2614 fi
2615
2616 alias ...='cd ../../'
2617
2618 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2619 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2620     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2621 fi
2622
2623 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2624 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2625 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2626
2627 # make sure it is not assigned yet
2628 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2629 function utf2iso () {
2630     if isutfenv ; then
2631         local ENV
2632         for ENV in $(env | command grep -i '.utf') ; do
2633             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2634         done
2635     fi
2636 }
2637
2638 # make sure it is not assigned yet
2639 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2640 function iso2utf () {
2641     if ! isutfenv ; then
2642         local ENV
2643         for ENV in $(env | command grep -i '\.iso') ; do
2644             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2645         done
2646     fi
2647 }
2648
2649 # especially for roadwarriors using GNU screen and ssh:
2650 if ! check_com asc &>/dev/null ; then
2651   function asc () { autossh -t "$@" 'screen -RdU' }
2652   compdef asc=ssh
2653 fi
2654
2655 #f1# Hints for the use of zsh on grml
2656 function zsh-help () {
2657     print "$bg[white]$fg[black]
2658 zsh-help - hints for use of zsh on grml
2659 =======================================$reset_color"
2660
2661     print '
2662 Main configuration of zsh happens in /etc/zsh/zshrc.
2663 That file is part of the package grml-etc-core, if you want to
2664 use them on a non-grml-system just get the tar.gz from
2665 http://deb.grml.org/ or (preferably) get it from the git repository:
2666
2667   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2668
2669 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2670 The file is still there, but it is empty for backwards compatibility.
2671
2672 For your own changes use these two files:
2673     $HOME/.zshrc.pre
2674     $HOME/.zshrc.local
2675
2676 The former is sourced very early in our zshrc, the latter is sourced
2677 very lately.
2678
2679 System wide configuration without touching configuration files of grml
2680 can take place in /etc/zsh/zshrc.local.
2681
2682 For information regarding zsh start at http://grml.org/zsh/
2683
2684 Take a look at grml'\''s zsh refcard:
2685 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2686
2687 Check out the main zsh refcard:
2688 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2689
2690 And of course visit the zsh-lovers:
2691 % man zsh-lovers
2692
2693 You can adjust some options through environment variables when
2694 invoking zsh without having to edit configuration files.
2695 Basically meant for bash users who are not used to the power of
2696 the zsh yet. :)
2697
2698   "NOCOR=1    zsh" => deactivate automatic correction
2699   "NOMENU=1   zsh" => do not use auto menu completion
2700                       (note: use ctrl-d for completion instead!)
2701   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2702   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2703                       preexec() and precmd() completely
2704   "GRML_DISPLAY_BATTERY=1  zsh"
2705                    => activate battery status on right side of prompt (WIP)
2706   "COMMAND_NOT_FOUND=1 zsh"
2707                    => Enable a handler if an external command was not found
2708                       The command called in the handler can be altered by setting
2709                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2710                       "/usr/share/command-not-found/command-not-found"
2711
2712 A value greater than 0 is enables a feature; a value equal to zero
2713 disables it. If you like one or the other of these settings, you can
2714 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2715 zshrc.'
2716
2717     print "
2718 $bg[white]$fg[black]
2719 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2720 Enjoy your grml system with the zsh!$reset_color"
2721 }
2722
2723 # debian stuff
2724 if [[ -r /etc/debian_version ]] ; then
2725     if [[ -z "$GRML_NO_APT_ALIASES" ]]; then
2726         #a3# Execute \kbd{apt-cache policy}
2727         alias acp='apt-cache policy'
2728         if check_com -c apt ; then
2729           #a3# Execute \kbd{apt search}
2730           alias acs='apt search'
2731           #a3# Execute \kbd{apt show}
2732           alias acsh='apt show'
2733           #a3# Execute \kbd{apt dist-upgrade}
2734           salias adg="apt dist-upgrade"
2735           #a3# Execute \kbd{apt upgrade}
2736           salias ag="apt upgrade"
2737           #a3# Execute \kbd{apt install}
2738           salias agi="apt install"
2739           #a3# Execute \kbd{apt update}
2740           salias au="apt update"
2741         else
2742           alias acs='apt-cache search'
2743           alias acsh='apt-cache show'
2744           salias adg="apt-get dist-upgrade"
2745           salias ag="apt-get upgrade"
2746           salias agi="apt-get install"
2747           salias au="apt-get update"
2748         fi
2749         #a3# Execute \kbd{aptitude install}
2750         salias ati="aptitude install"
2751         #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2752         salias -a up="aptitude update ; aptitude safe-upgrade"
2753         #a3# Execute \kbd{dpkg-buildpackage}
2754         alias dbp='dpkg-buildpackage'
2755         #a3# Execute \kbd{grep-excuses}
2756         alias ge='grep-excuses'
2757     fi
2758
2759     # get a root shell as normal user in live-cd mode:
2760     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2761        alias su="sudo su"
2762     fi
2763
2764 fi
2765
2766 # use /var/log/syslog iff present, fallback to journalctl otherwise
2767 if [ -e /var/log/syslog ] ; then
2768   #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog || journalctl}
2769   salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2770   #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog || journalctl}
2771   salias tlog="tail -f /var/log/syslog"    # follow the syslog
2772 elif check_com -c journalctl ; then
2773   salias llog="journalctl"
2774   salias tlog="journalctl -f"
2775 fi
2776
2777 # sort installed Debian-packages by size
2778 if check_com -c dpkg-query ; then
2779     #a3# List installed Debian-packages sorted by size
2780     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"
2781 fi
2782
2783 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2784 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2785     if check_com -c wodim; then
2786         function cdrecord () {
2787             <<__EOF0__
2788 cdrecord is not provided under its original name by Debian anymore.
2789 See #377109 in the BTS of Debian for more details.
2790
2791 Please use the wodim binary instead
2792 __EOF0__
2793             return 1
2794         }
2795     fi
2796 fi
2797
2798 if isgrmlcd; then
2799     # No core dumps: important for a live-cd-system
2800     limit -s core 0
2801 fi
2802
2803 # grmlstuff
2804 function grmlstuff () {
2805 # people should use 'grml-x'!
2806     if check_com -c 915resolution; then
2807         function 855resolution () {
2808             echo "Please use 915resolution as resolution modifying tool for Intel \
2809 graphic chipset."
2810             return -1
2811         }
2812     fi
2813
2814     #a1# Output version of running grml
2815     alias grml-version='cat /etc/grml_version'
2816
2817     if check_com -c grml-debootstrap ; then
2818         function debian2hd () {
2819             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2820             return 1
2821         }
2822     fi
2823
2824     if check_com -c tmate && check_com -c qrencode ; then
2825         function grml-remote-support() {
2826             tmate -L grml-remote-support new -s grml-remote-support -d
2827             tmate -L grml-remote-support wait tmate-ready
2828             tmate -L grml-remote-support display -p '#{tmate_ssh}' | qrencode -t ANSI
2829             echo "tmate session: $(tmate -L grml-remote-support display -p '#{tmate_ssh}')"
2830             echo
2831             echo "Scan this QR code and send it to your support team."
2832         }
2833     fi
2834 }
2835
2836 # now run the functions
2837 isgrml && checkhome
2838 is4    && isgrml    && grmlstuff
2839 is4    && grmlcomp
2840
2841 # keephack
2842 is4 && xsource "/etc/zsh/keephack"
2843
2844 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2845 # You use it as follows:
2846 # $ NTREF=/reference/file
2847 # $ ls -l *(e:nt:)
2848 # This lists all the files in the current directory newer than the reference file.
2849 # You can also specify the reference file inline; note quotes:
2850 # $ ls -l *(e:'nt ~/.zshenv':)
2851 is4 && function nt () {
2852     if [[ -n $1 ]] ; then
2853         local NTREF=${~1}
2854     fi
2855     [[ $REPLY -nt $NTREF ]]
2856 }
2857
2858 # shell functions
2859
2860 #f1# Reload an autoloadable function
2861 function freload () { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2862 compdef _functions freload
2863
2864 #
2865 # Usage:
2866 #
2867 #      e.g.:   a -> b -> c -> d  ....
2868 #
2869 #      sll a
2870 #
2871 #
2872 #      if parameter is given with leading '=', lookup $PATH for parameter and resolve that
2873 #
2874 #      sll =java
2875 #
2876 #      Note: limit for recursive symlinks on linux:
2877 #            http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?id=refs/heads/master#l808
2878 #            This limits recursive symlink follows to 8,
2879 #            while limiting consecutive symlinks to 40.
2880 #
2881 #      When resolving and displaying information about symlinks, no check is made
2882 #      that the displayed information does make any sense on your OS.
2883 #      We leave that decission to the user.
2884 #
2885 #      The zstat module is used to detect symlink loops. zstat is available since zsh4.
2886 #      With an older zsh you will need to abort with <C-c> in that case.
2887 #      When a symlink loop is detected, a warning ist printed and further processing is stopped.
2888 #
2889 #      Module zstat is loaded by default in grml zshrc, no extra action needed for that.
2890 #
2891 #      Known bugs:
2892 #      If you happen to come across a symlink that points to a destination on another partition
2893 #      with the same inode number, that will be marked as symlink loop though it is not.
2894 #      Two hints for this situation:
2895 #      I)  Play lottery the same day, as you seem to be rather lucky right now.
2896 #      II) Send patches.
2897 #
2898 #      return status:
2899 #      0 upon success
2900 #      1 file/dir not accesible
2901 #      2 symlink loop detected
2902 #
2903 #f1# List symlinks in detail (more detailed version of 'readlink -f', 'whence -s' and 'namei -l')
2904 function sll () {
2905     if [[ -z ${1} ]] ; then
2906         printf 'Usage: %s <symlink(s)>\n' "${0}"
2907         return 1
2908     fi
2909
2910     local file jumpd curdir
2911     local -i 10 RTN LINODE i
2912     local -a    SEENINODES
2913     curdir="${PWD}"
2914     RTN=0
2915
2916     for file in "${@}" ; do
2917         SEENINODES=()
2918         ls -l "${file:a}"   || RTN=1
2919
2920         while [[ -h "$file" ]] ; do
2921             if is4 ; then
2922                 LINODE=$(zstat -L +inode "${file}")
2923                 for i in ${SEENINODES} ; do
2924                     if (( ${i} == ${LINODE} )) ; then
2925                         builtin cd -q "${curdir}"
2926                         print 'link loop detected, aborting!'
2927                         return 2
2928                     fi
2929                 done
2930                 SEENINODES+=${LINODE}
2931             fi
2932             jumpd="${file:h}"
2933             file="${file:t}"
2934
2935             if [[ -d ${jumpd} ]] ; then
2936                 builtin cd -q "${jumpd}"  || RTN=1
2937             fi
2938             file=$(readlink "$file")
2939
2940             jumpd="${file:h}"
2941             file="${file:t}"
2942
2943             if [[ -d ${jumpd} ]] ; then
2944                 builtin cd -q "${jumpd}"  || RTN=1
2945             fi
2946
2947             ls -l "${PWD}/${file}"     || RTN=1
2948         done
2949         shift 1
2950         if (( ${#} >= 1 )) ; then
2951             print ""
2952         fi
2953         builtin cd -q "${curdir}"
2954     done
2955     return ${RTN}
2956 }
2957
2958 if check_com -c $PAGER ; then
2959     #f3# View Debian's changelog of given package(s)
2960     function dchange () {
2961         emulate -L zsh
2962         [[ -z "$1" ]] && printf 'Usage: %s <package_name(s)>\n' "$0" && return 1
2963
2964         local package
2965
2966         # `less` as $PAGER without e.g. `|lesspipe %s` inside $LESSOPEN can't properly
2967         # read *.gz files, try to detect this to use vi instead iff available
2968         local viewer
2969
2970         if [[ ${$(typeset -p PAGER)[2]} = -a ]] ; then
2971           viewer=($PAGER)    # support PAGER=(less -Mr) but leave array untouched
2972         else
2973           viewer=(${=PAGER}) # support PAGER='less -Mr'
2974         fi
2975
2976         if [[ ${viewer[1]:t} = less ]] && [[ -z "${LESSOPEN}" ]] && check_com vi ; then
2977           viewer='vi'
2978         fi
2979
2980         for package in "$@" ; do
2981             if [[ -r /usr/share/doc/${package}/changelog.Debian.gz ]] ; then
2982                 $viewer /usr/share/doc/${package}/changelog.Debian.gz
2983             elif [[ -r /usr/share/doc/${package}/changelog.gz ]] ; then
2984                 $viewer /usr/share/doc/${package}/changelog.gz
2985             elif [[ -r /usr/share/doc/${package}/changelog ]] ; then
2986                 $viewer /usr/share/doc/${package}/changelog
2987             else
2988                 if check_com -c aptitude ; then
2989                     echo "No changelog for package $package found, using aptitude to retrieve it."
2990                     aptitude changelog "$package"
2991                 elif check_com -c apt-get ; then
2992                     echo "No changelog for package $package found, using apt-get to retrieve it."
2993                     apt-get changelog "$package"
2994                 else
2995                     echo "No changelog for package $package found, sorry."
2996                 fi
2997             fi
2998         done
2999     }
3000     function _dchange () { _files -W /usr/share/doc -/ }
3001     compdef _dchange dchange
3002
3003     #f3# View Debian's NEWS of a given package
3004     function dnews () {
3005         emulate -L zsh
3006         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
3007             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
3008         else
3009             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
3010                 $PAGER /usr/share/doc/$1/NEWS.gz
3011             else
3012                 echo "No NEWS file for package $1 found, sorry."
3013                 return 1
3014             fi
3015         fi
3016     }
3017     function _dnews () { _files -W /usr/share/doc -/ }
3018     compdef _dnews dnews
3019
3020     #f3# View Debian's copyright of a given package
3021     function dcopyright () {
3022         emulate -L zsh
3023         if [[ -r /usr/share/doc/$1/copyright ]] ; then
3024             $PAGER /usr/share/doc/$1/copyright
3025         else
3026             echo "No copyright file for package $1 found, sorry."
3027             return 1
3028         fi
3029     }
3030     function _dcopyright () { _files -W /usr/share/doc -/ }
3031     compdef _dcopyright dcopyright
3032
3033     #f3# View upstream's changelog of a given package
3034     function uchange () {
3035         emulate -L zsh
3036         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
3037             $PAGER /usr/share/doc/$1/changelog.gz
3038         else
3039             echo "No changelog for package $1 found, sorry."
3040             return 1
3041         fi
3042     }
3043     function _uchange () { _files -W /usr/share/doc -/ }
3044     compdef _uchange uchange
3045 fi
3046
3047 # zsh profiling
3048 function profile () {
3049     ZSH_PROFILE_RC=1 zsh "$@"
3050 }
3051
3052 #f1# Edit an alias via zle
3053 function edalias () {
3054     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
3055 }
3056 compdef _aliases edalias
3057
3058 #f1# Edit a function via zle
3059 function edfunc () {
3060     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
3061 }
3062 compdef _functions edfunc
3063
3064 # use it e.g. via 'Restart apache2'
3065 #m# f6 Start() \kbd{service \em{process}}\quad\kbd{start}
3066 #m# f6 Restart() \kbd{service \em{process}}\quad\kbd{restart}
3067 #m# f6 Stop() \kbd{service \em{process}}\quad\kbd{stop}
3068 #m# f6 Reload() \kbd{service \em{process}}\quad\kbd{reload}
3069 #m# f6 Force-Reload() \kbd{service \em{process}}\quad\kbd{force-reload}
3070 #m# f6 Status() \kbd{service \em{process}}\quad\kbd{status}
3071 if [[ -d /etc/init.d || -d /etc/service ]] ; then
3072     function __start_stop () {
3073         local action_="${1:l}"  # e.g Start/Stop/Restart
3074         local service_="$2"
3075         local param_="$3"
3076
3077         local service_target_="$(readlink /etc/init.d/$service_)"
3078         if [[ $service_target_ == "/usr/bin/sv" ]]; then
3079             # runit
3080             case "${action_}" in
3081                 start) if [[ ! -e /etc/service/$service_ ]]; then
3082                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
3083                        else
3084                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3085                        fi ;;
3086                 # there is no reload in runits sysv emulation
3087                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
3088                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
3089             esac
3090         else
3091             # sysv/sysvinit-utils, upstart
3092             if check_com -c service ; then
3093               $SUDO service "$service_" "${action_}" "$param_"
3094             else
3095               $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3096             fi
3097         fi
3098     }
3099
3100     function _grmlinitd () {
3101         local -a scripts
3102         scripts=( /etc/init.d/*(x:t) )
3103         _describe "service startup script" scripts
3104     }
3105
3106     for i in Start Restart Stop Force-Reload Reload Status ; do
3107         eval "function $i () { __start_stop $i \"\$1\" \"\$2\" ; }"
3108         compdef _grmlinitd $i
3109     done
3110     builtin unset -v i
3111 fi
3112
3113 #f1# Provides useful information on globbing
3114 function H-Glob () {
3115     echo -e "
3116     /      directories
3117     .      plain files
3118     @      symbolic links
3119     =      sockets
3120     p      named pipes (FIFOs)
3121     *      executable plain files (0100)
3122     %      device files (character or block special)
3123     %b     block special files
3124     %c     character special files
3125     r      owner-readable files (0400)
3126     w      owner-writable files (0200)
3127     x      owner-executable files (0100)
3128     A      group-readable files (0040)
3129     I      group-writable files (0020)
3130     E      group-executable files (0010)
3131     R      world-readable files (0004)
3132     W      world-writable files (0002)
3133     X      world-executable files (0001)
3134     s      setuid files (04000)
3135     S      setgid files (02000)
3136     t      files with the sticky bit (01000)
3137
3138   print *(m-1)          # Files modified up to a day ago
3139   print *(a1)           # Files accessed a day ago
3140   print *(@)            # Just symlinks
3141   print *(Lk+50)        # Files bigger than 50 kilobytes
3142   print *(Lk-50)        # Files smaller than 50 kilobytes
3143   print **/*.c          # All *.c files recursively starting in \$PWD
3144   print **/*.c~file.c   # Same as above, but excluding 'file.c'
3145   print (foo|bar).*     # Files starting with 'foo' or 'bar'
3146   print *~*.*           # All Files that do not contain a dot
3147   chmod 644 *(.^x)      # make all plain non-executable files publically readable
3148   print -l *(.c|.h)     # Lists *.c and *.h
3149   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
3150   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
3151 }
3152 alias help-zshglob=H-Glob
3153
3154 # grep for running process, like: 'any vim'
3155 function any () {
3156     emulate -L zsh
3157     unsetopt KSH_ARRAYS
3158     if [[ -z "$1" ]] ; then
3159         echo "any - grep for process(es) by keyword" >&2
3160         echo "Usage: any <keyword>" >&2 ; return 1
3161     else
3162         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
3163     fi
3164 }
3165
3166
3167 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
3168 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
3169 [[ -r /proc/1/maps ]] && \
3170 function deswap () {
3171     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
3172     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
3173     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
3174 }
3175
3176 # a wrapper for vim, that deals with title setting
3177 #   VIM_OPTIONS
3178 #       set this array to a set of options to vim you always want
3179 #       to have set when calling vim (in .zshrc.local), like:
3180 #           VIM_OPTIONS=( -p )
3181 #       This will cause vim to send every file given on the
3182 #       commandline to be send to it's own tab (needs vim7).
3183 if check_com vim; then
3184     function vim () {
3185         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3186     }
3187 fi
3188
3189 ssl_hashes=( sha512 sha256 sha1 md5 )
3190
3191 for sh in ${ssl_hashes}; do
3192     eval 'ssl-cert-'${sh}'() {
3193         emulate -L zsh
3194         if [[ -z $1 ]] ; then
3195             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
3196             return 1
3197         fi
3198         openssl x509 -noout -fingerprint -'${sh}' -in $1
3199     }'
3200 done; unset sh
3201
3202 function ssl-cert-fingerprints () {
3203     emulate -L zsh
3204     local i
3205     if [[ -z $1 ]] ; then
3206         printf 'usage: ssl-cert-fingerprints <file>\n'
3207         return 1
3208     fi
3209     for i in ${ssl_hashes}
3210         do ssl-cert-$i $1;
3211     done
3212 }
3213
3214 function ssl-cert-info () {
3215     emulate -L zsh
3216     if [[ -z $1 ]] ; then
3217         printf 'usage: ssl-cert-info <file>\n'
3218         return 1
3219     fi
3220     openssl x509 -noout -text -in $1
3221     ssl-cert-fingerprints $1
3222 }
3223
3224 # make sure our environment is clean regarding colors
3225 builtin unset -v BLUE RED GREEN CYAN YELLOW MAGENTA WHITE NO_COLOR
3226
3227 # "persistent history"
3228 # just write important commands you always need to $GRML_IMPORTANT_COMMANDS
3229 # defaults for backward compatibility to ~/.important_commands
3230 if [[ -r ~/.important_commands ]] ; then
3231     GRML_IMPORTANT_COMMANDS=~/.important_commands
3232 else
3233     GRML_IMPORTANT_COMMANDS=${GRML_IMPORTANT_COMMANDS:-${ZDOTDIR:-${HOME}}/.important_commands}
3234 fi
3235 [[ -r ${GRML_IMPORTANT_COMMANDS} ]] && builtin fc -R ${GRML_IMPORTANT_COMMANDS}
3236
3237 # load the lookup subsystem if it's available on the system
3238 zrcautoload lookupinit && lookupinit
3239
3240 # variables
3241
3242 # set terminal property (used e.g. by msgid-chooser)
3243 export COLORTERM="yes"
3244
3245 # aliases
3246
3247 # general
3248 #a2# Execute \kbd{du -sch}
3249 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias da='du -sch'
3250
3251 # listing stuff
3252 #a2# Execute \kbd{ls -lSrah}
3253 alias dir="command ls -lSrah"
3254 #a2# Only show dot-directories
3255 alias lad='command ls -d .*(/)'
3256 #a2# Only show dot-files
3257 alias lsa='command ls -a .*(.)'
3258 #a2# Only files with setgid/setuid/sticky flag
3259 alias lss='command ls -l *(s,S,t)'
3260 #a2# Only show symlinks
3261 alias lsl='command ls -l *(@)'
3262 #a2# Display only executables
3263 alias lsx='command ls -l *(*)'
3264 #a2# Display world-{readable,writable,executable} files
3265 alias lsw='command ls -ld *(R,W,X.^ND/)'
3266 #a2# Display the ten biggest files
3267 alias lsbig="command ls -flh *(.OL[1,10])"
3268 #a2# Only show directories
3269 alias lsd='command ls -d *(/)'
3270 #a2# Only show empty directories
3271 alias lse='command ls -d *(/^F)'
3272 #a2# Display the ten newest files
3273 alias lsnew="command ls -rtlh *(D.om[1,10])"
3274 #a2# Display the ten oldest files
3275 alias lsold="command ls -rtlh *(D.Om[1,10])"
3276 #a2# Display the ten smallest files
3277 alias lssmall="command ls -Srl *(.oL[1,10])"
3278 #a2# Display the ten newest directories and ten newest .directories
3279 alias lsnewdir="command ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
3280 #a2# Display the ten oldest directories and ten oldest .directories
3281 alias lsolddir="command ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
3282
3283 # some useful aliases
3284 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir \$OLDCWD}
3285 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
3286
3287 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3288 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3289 #a2# scp with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3290 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3291
3292 # work around non utf8 capable software in utf environment via $LANG and luit
3293 if check_com isutfenv && check_com luit ; then
3294     if check_com -c mrxvt ; then
3295         isutfenv && [[ -n "$LANG" ]] && \
3296             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3297     fi
3298
3299     if check_com -c aterm ; then
3300         isutfenv && [[ -n "$LANG" ]] && \
3301             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3302     fi
3303
3304     if check_com -c centericq ; then
3305         isutfenv && [[ -n "$LANG" ]] && \
3306             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3307     fi
3308 fi
3309
3310 # useful functions
3311
3312 #f5# Backup \kbd{file_or_folder {\rm to} file_or_folder\_timestamp}
3313 function bk () {
3314     emulate -L zsh
3315     local current_date=$(date -u "+%Y%m%dT%H%M%SZ")
3316     local clean keep move verbose result all to_bk
3317     setopt extended_glob
3318     keep=1
3319     while getopts ":hacmrv" opt; do
3320         case $opt in
3321             a) (( all++ ));;
3322             c) unset move clean && (( ++keep ));;
3323             m) unset keep clean && (( ++move ));;
3324             r) unset move keep && (( ++clean ));;
3325             v) verbose="-v";;
3326             h) <<__EOF0__
3327 bk [-hcmv] FILE [FILE ...]
3328 bk -r [-av] [FILE [FILE ...]]
3329 Backup a file or folder in place and append the timestamp
3330 Remove backups of a file or folder, or all backups in the current directory
3331
3332 Usage:
3333 -h    Display this help text
3334 -c    Keep the file/folder as is, create a copy backup using cp(1) (default)
3335 -m    Move the file/folder, using mv(1)
3336 -r    Remove backups of the specified file or directory, using rm(1). If none
3337       is provided, remove all backups in the current directory.
3338 -a    Remove all (even hidden) backups.
3339 -v    Verbose
3340
3341 The -c, -r and -m options are mutually exclusive. If specified at the same time,
3342 the last one is used.
3343
3344 The return code is the sum of all cp/mv/rm return codes.
3345 __EOF0__
3346 return 0;;
3347             \?) bk -h >&2; return 1;;
3348         esac
3349     done
3350     shift "$((OPTIND-1))"
3351     if (( keep > 0 )); then
3352         if islinux || isfreebsd; then
3353             for to_bk in "$@"; do
3354                 cp $verbose -a "${to_bk%/}" "${to_bk%/}_$current_date"
3355                 (( result += $? ))
3356             done
3357         else
3358             for to_bk in "$@"; do
3359                 cp $verbose -pR "${to_bk%/}" "${to_bk%/}_$current_date"
3360                 (( result += $? ))
3361             done
3362         fi
3363     elif (( move > 0 )); then
3364         while (( $# > 0 )); do
3365             mv $verbose "${1%/}" "${1%/}_$current_date"
3366             (( result += $? ))
3367             shift
3368         done
3369     elif (( clean > 0 )); then
3370         if (( $# > 0 )); then
3371             for to_bk in "$@"; do
3372                 rm $verbose -rf "${to_bk%/}"_[0-9](#c8)T([0-1][0-9]|2[0-3])([0-5][0-9])(#c2)Z
3373                 (( result += $? ))
3374             done
3375         else
3376             if (( all > 0 )); then
3377                 rm $verbose -rf *_[0-9](#c8)T([0-1][0-9]|2[0-3])([0-5][0-9])(#c2)Z(D)
3378             else
3379                 rm $verbose -rf *_[0-9](#c8)T([0-1][0-9]|2[0-3])([0-5][0-9])(#c2)Z
3380             fi
3381             (( result += $? ))
3382         fi
3383     fi
3384     return $result
3385 }
3386
3387 #f5# cd to directory and list files
3388 function cl () {
3389     emulate -L zsh
3390     cd $1 && ls -a
3391 }
3392
3393 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
3394 function cd () {
3395     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
3396         [[ ! -e ${1:h} ]] && return 1
3397         print "Correcting ${1} to ${1:h}"
3398         builtin cd ${1:h}
3399     else
3400         builtin cd "$@"
3401     fi
3402 }
3403
3404 #f5# Create Directory and \kbd{cd} to it
3405 function mkcd () {
3406     if (( ARGC != 1 )); then
3407         printf 'usage: mkcd <new-directory>\n'
3408         return 1;
3409     fi
3410     if [[ ! -d "$1" ]]; then
3411         command mkdir -p "$1"
3412     else
3413         printf '`%s'\'' already exists: cd-ing.\n' "$1"
3414     fi
3415     builtin cd "$1"
3416 }
3417
3418 #f5# Create temporary directory and \kbd{cd} to it
3419 function cdt () {
3420     builtin cd "$(mktemp -d)"
3421     builtin pwd
3422 }
3423
3424 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
3425 function accessed () {
3426     emulate -L zsh
3427     print -l -- *(a-${1:-1})
3428 }
3429
3430 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
3431 function changed () {
3432     emulate -L zsh
3433     print -l -- *(c-${1:-1})
3434 }
3435
3436 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
3437 function modified () {
3438     emulate -L zsh
3439     print -l -- *(m-${1:-1})
3440 }
3441 # modified() was named new() in earlier versions, add an alias for backwards compatibility
3442 check_com new || alias new=modified
3443
3444 # use colors when GNU grep with color-support
3445 if (( $#grep_options > 0 )); then
3446     o=${grep_options:+"${grep_options[*]}"}
3447     #a2# Execute \kbd{grep -{}-color=auto}
3448     alias grep='grep '$o
3449     alias egrep='egrep '$o
3450     unset o
3451 fi
3452
3453 # Translate DE<=>EN
3454 # 'translate' looks up a word in a file with language-to-language
3455 # translations (field separator should be " : "). A typical wordlist looks
3456 # like the following:
3457 #  | english-word : german-translation
3458 # It's also only possible to translate english to german but not reciprocal.
3459 # Use the following oneliner to reverse the sort order:
3460 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3461 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3462 #f5# Translates a word
3463 function trans () {
3464     emulate -L zsh
3465     case "$1" in
3466         -[dD]*)
3467             translate -l de-en $2
3468             ;;
3469         -[eE]*)
3470             translate -l en-de $2
3471             ;;
3472         *)
3473             echo "Usage: $0 { -D | -E }"
3474             echo "         -D == German to English"
3475             echo "         -E == English to German"
3476     esac
3477 }
3478
3479 # Usage: simple-extract <file>
3480 # Using option -d deletes the original archive file.
3481 #f5# Smart archive extractor
3482 function simple-extract () {
3483     emulate -L zsh
3484     setopt extended_glob noclobber
3485     local ARCHIVE DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
3486     local RC=0
3487     zparseopts -D -E "d=DELETE_ORIGINAL"
3488     for ARCHIVE in "${@}"; do
3489         case $ARCHIVE in
3490             *(tar.bz2|tbz2|tbz))
3491                 DECOMP_CMD="tar -xvjf -"
3492                 USES_STDIN=true
3493                 USES_STDOUT=false
3494                 ;;
3495             *(tar.gz|tgz))
3496                 DECOMP_CMD="tar -xvzf -"
3497                 USES_STDIN=true
3498                 USES_STDOUT=false
3499                 ;;
3500             *(tar.xz|txz|tar.lzma))
3501                 DECOMP_CMD="tar -xvJf -"
3502                 USES_STDIN=true
3503                 USES_STDOUT=false
3504                 ;;
3505             *tar.zst)
3506                 DECOMP_CMD="tar --zstd -xvf -"
3507                 USES_STDIN=true
3508                 USES_STDOUT=false
3509                 ;;
3510             *tar)
3511                 DECOMP_CMD="tar -xvf -"
3512                 USES_STDIN=true
3513                 USES_STDOUT=false
3514                 ;;
3515             *rar)
3516                 DECOMP_CMD="unrar x"
3517                 USES_STDIN=false
3518                 USES_STDOUT=false
3519                 ;;
3520             *lzh)
3521                 DECOMP_CMD="lha x"
3522                 USES_STDIN=false
3523                 USES_STDOUT=false
3524                 ;;
3525             *7z)
3526                 DECOMP_CMD="7z x"
3527                 USES_STDIN=false
3528                 USES_STDOUT=false
3529                 ;;
3530             *(zip|jar))
3531                 DECOMP_CMD="unzip"
3532                 USES_STDIN=false
3533                 USES_STDOUT=false
3534                 ;;
3535             *deb)
3536                 DECOMP_CMD="ar -x"
3537                 USES_STDIN=false
3538                 USES_STDOUT=false
3539                 ;;
3540             *bz2)
3541                 DECOMP_CMD="bzip2 -d -c -"
3542                 USES_STDIN=true
3543                 USES_STDOUT=true
3544                 ;;
3545             *(gz|Z))
3546                 DECOMP_CMD="gzip -d -c -"
3547                 USES_STDIN=true
3548                 USES_STDOUT=true
3549                 ;;
3550             *(xz|lzma))
3551                 DECOMP_CMD="xz -d -c -"
3552                 USES_STDIN=true
3553                 USES_STDOUT=true
3554                 ;;
3555             *zst)
3556                 DECOMP_CMD="zstd -d -c -"
3557                 USES_STDIN=true
3558                 USES_STDOUT=true
3559                 ;;
3560             *)
3561                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
3562                 RC=$((RC+1))
3563                 continue
3564                 ;;
3565         esac
3566
3567         if ! check_com ${DECOMP_CMD[(w)1]}; then
3568             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
3569             RC=$((RC+2))
3570             continue
3571         fi
3572
3573         GZTARGET="${ARCHIVE:t:r}"
3574         if [[ -f $ARCHIVE ]] ; then
3575
3576             print "Extracting '$ARCHIVE' ..."
3577             if $USES_STDIN; then
3578                 if $USES_STDOUT; then
3579                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
3580                 else
3581                     ${=DECOMP_CMD} < "$ARCHIVE"
3582                 fi
3583             else
3584                 if $USES_STDOUT; then
3585                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
3586                 else
3587                     ${=DECOMP_CMD} "$ARCHIVE"
3588                 fi
3589             fi
3590             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
3591
3592         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
3593             if check_com curl; then
3594                 WGET_CMD="curl -L -s -o -"
3595             elif check_com wget; then
3596                 WGET_CMD="wget -q -O -"
3597             elif check_com fetch; then
3598                 WGET_CMD="fetch -q -o -"
3599             else
3600                 print "ERROR: neither wget, curl nor fetch is installed" >&2
3601                 RC=$((RC+4))
3602                 continue
3603             fi
3604             print "Downloading and Extracting '$ARCHIVE' ..."
3605             if $USES_STDIN; then
3606                 if $USES_STDOUT; then
3607                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
3608                     RC=$((RC+$?))
3609                 else
3610                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
3611                     RC=$((RC+$?))
3612                 fi
3613             else
3614                 if $USES_STDOUT; then
3615                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
3616                 else
3617                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
3618                 fi
3619             fi
3620
3621         else
3622             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
3623             RC=$((RC+8))
3624         fi
3625     done
3626     return $RC
3627 }
3628
3629 function __archive_or_uri () {
3630     _alternative \
3631         '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)"' \
3632         '_urls:Remote Archives:_urls'
3633 }
3634
3635 function _simple_extract () {
3636     _arguments \
3637         '-d[delete original archivefile after extraction]' \
3638         '*:Archive Or Uri:__archive_or_uri'
3639 }
3640 compdef _simple_extract simple-extract
3641 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias se=simple-extract
3642
3643 #f5# Change the xterm title from within GNU-screen
3644 function xtrename () {
3645     emulate -L zsh
3646     if [[ $1 != "-f" ]] ; then
3647         if [[ -z ${DISPLAY} ]] ; then
3648             printf 'xtrename only makes sense in X11.\n'
3649             return 1
3650         fi
3651     else
3652         shift
3653     fi
3654     if [[ -z $1 ]] ; then
3655         printf 'usage: xtrename [-f] "title for xterm"\n'
3656         printf '  renames the title of xterm from _within_ screen.\n'
3657         printf '  also works without screen.\n'
3658         printf '  will not work if DISPLAY is unset, use -f to override.\n'
3659         return 0
3660     fi
3661     print -n "\eP\e]0;${1}\C-G\e\\"
3662     return 0
3663 }
3664
3665 # Create small urls via http://goo.gl using curl(1).
3666 # API reference: https://code.google.com/apis/urlshortener/
3667 function zurl () {
3668     emulate -L zsh
3669     setopt extended_glob
3670
3671     if [[ -z $1 ]]; then
3672         print "USAGE: zurl <URL>"
3673         return 1
3674     fi
3675
3676     local PN url prog api json contenttype item
3677     local -a data
3678     PN=$0
3679     url=$1
3680
3681     # Prepend 'http://' to given URL where necessary for later output.
3682     if [[ ${url} != http(s|)://* ]]; then
3683         url='http://'${url}
3684     fi
3685
3686     if check_com -c curl; then
3687         prog=curl
3688     else
3689         print "curl is not available, but mandatory for ${PN}. Aborting."
3690         return 1
3691     fi
3692     api='https://www.googleapis.com/urlshortener/v1/url'
3693     contenttype="Content-Type: application/json"
3694     json="{\"longUrl\": \"${url}\"}"
3695     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
3696     # Parse the response
3697     for item in "${data[@]}"; do
3698         case "$item" in
3699             ' '#'"id":'*)
3700                 item=${item#*: \"}
3701                 item=${item%\",*}
3702                 printf '%s\n' "$item"
3703                 return 0
3704                 ;;
3705         esac
3706     done
3707     return 1
3708 }
3709
3710 #f2# Find history events by search pattern and list them by date.
3711 function whatwhen () {
3712     emulate -L zsh
3713     local usage help ident format_l format_s first_char remain first last
3714     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3715     help='Use `whatwhen -h'\'' for further explanations.'
3716     ident=${(l,${#${:-Usage: }},, ,)}
3717     format_l="${ident}%s\t\t\t%s\n"
3718     format_s="${format_l//(\\t)##/\\t}"
3719     # Make the first char of the word to search for case
3720     # insensitive; e.g. [aA]
3721     first_char=[${(L)1[1]}${(U)1[1]}]
3722     remain=${1[2,-1]}
3723     # Default search range is `-100'.
3724     first=${2:-\-100}
3725     # Optional, just used for `<first> <last>' given.
3726     last=$3
3727     case $1 in
3728         ("")
3729             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3730             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3731         ;;
3732         (-h)
3733             printf '%s\n\n' ${usage}
3734             print 'OPTIONS:'
3735             printf $format_l '-h' 'show help text'
3736             print '\f'
3737             print 'SEARCH RANGE:'
3738             printf $format_l "'0'" 'the whole history,'
3739             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3740             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3741             printf '\n%s\n' 'EXAMPLES:'
3742             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3743             printf $format_l 'whatwhen zsh -250'
3744             printf $format_l 'whatwhen foo 1 99'
3745         ;;
3746         (\?)
3747             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3748         ;;
3749         (*)
3750             # -l list results on stout rather than invoking $EDITOR.
3751             # -i Print dates as in YYYY-MM-DD.
3752             # -m Search for a - quoted - pattern within the history.
3753             fc -li -m "*${first_char}${remain}*" $first $last
3754         ;;
3755     esac
3756 }
3757
3758 # mercurial related stuff
3759 if check_com -c hg ; then
3760     # gnu like diff for mercurial
3761     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3762     #f5# GNU like diff for mercurial
3763     function hgdi () {
3764         emulate -L zsh
3765         local i
3766         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3767     }
3768
3769     # build debian package
3770     #a2# Alias for \kbd{hg-buildpackage}
3771     alias hbp='hg-buildpackage'
3772
3773     # execute commands on the versioned patch-queue from the current repos
3774     [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3775
3776     # diffstat for specific version of a mercurial repository
3777     #   hgstat      => display diffstat between last revision and tip
3778     #   hgstat 1234 => display diffstat between revision 1234 and tip
3779     #f5# Diffstat for specific version of a mercurial repos
3780     function hgstat () {
3781         emulate -L zsh
3782         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3783     }
3784
3785 fi # end of check whether we have the 'hg'-executable
3786
3787 # disable bracketed paste mode for dumb terminals
3788 [[ "$TERM" == dumb ]] && unset zle_bracketed_paste
3789
3790 # grml-small cleanups and workarounds
3791
3792 # The following is used to remove zsh-config-items that do not work
3793 # in grml-small by default.
3794 # If you do not want these adjustments (for whatever reason), set
3795 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3796 # sources if it is there).
3797
3798 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3799
3800     # Clean up
3801
3802     unset "abk[V]"
3803     unalias    'V'      &> /dev/null
3804     unfunction vman     &> /dev/null
3805     unfunction viless   &> /dev/null
3806     unfunction 2html    &> /dev/null
3807
3808     # manpages are not in grmlsmall
3809     unfunction manzsh   &> /dev/null
3810     unfunction man2     &> /dev/null
3811
3812     # Workarounds
3813
3814     # See https://github.com/grml/grml/issues/56
3815     if ! [[ -x ${commands[dig]} ]]; then
3816         function dig_after_all () {
3817             unfunction dig
3818             unfunction _dig
3819             autoload -Uz _dig
3820             unfunction dig_after_all
3821         }
3822         function dig () {
3823             if [[ -x ${commands[dig]} ]]; then
3824                 dig_after_all
3825                 command dig "$@"
3826                 return "$!"
3827             fi
3828             printf 'This installation does not include `dig'\'' for size reasons.\n'
3829             printf 'Try `drill'\'' as a light weight alternative.\n'
3830             return 0
3831         }
3832         function _dig () {
3833             if [[ -x ${commands[dig]} ]]; then
3834                 dig_after_all
3835                 zle -M 'Found `dig'\'' installed. '
3836             else
3837                 zle -M 'Try `drill'\'' instead of `dig'\''.'
3838             fi
3839         }
3840         compdef _dig dig
3841     fi
3842 fi
3843
3844 zrclocal
3845
3846 ## genrefcard.pl settings
3847
3848 ### doc strings for external functions from files
3849 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3850
3851 ### example: split functions-search 8,16,24,32
3852 #@# split functions-search 8
3853
3854 ## END OF FILE #################################################################
3855 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3856 # Local variables:
3857 # mode: sh
3858 # End: