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