etc/zsh/zshrc

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