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