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