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