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 zle -N grml_toggle_abbrev
 737 bindkey '^xA' 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     #k# complete word from currently visible 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-chroot':
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 -gt 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# execute \kbd{@a@}:\quad ls with colors
1777     alias ls='ls -b -CF '${ls_options:+"${ls_options[*]}"}
1778     #a1# execute \kbd{@a@}:\quad list all files, with colors
1779     alias la='ls -la '${ls_options:+"${ls_options[*]}"}
1780     #a1# long colored list, without dotfiles (@a@)
1781     alias ll='ls -l '${ls_options:+"${ls_options[*]}"}
1782     #a1# long colored list, human readable sizes (@a@)
1783     alias lh='ls -hAl '${ls_options:+"${ls_options[*]}"}
1784     #a1# List files, append qualifier to filenames \\&\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 rebuildfstab ; then
2144         #a1# Rebuild /etc/fstab
2145         alias grml-rebuildfstab='rebuildfstab -v -r -config'
2146     fi
2147
2148     if check_com -c grml-debootstrap ; then
2149         debian2hd() {
2150             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2151             return 1
2152         }
2153     fi
2154 }
2155
2156 # now run the functions
2157 isgrml && checkhome
2158 is4    && isgrml    && grmlstuff
2159 is4    && grmlcomp
2160
2161 # keephack
2162 is4 && xsource "/etc/zsh/keephack"
2163
2164 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2165 # You use it as follows:
2166 # $ NTREF=/reference/file
2167 # $ ls -l *(e:nt:)
2168 # This lists all the files in the current directory newer than the reference file.
2169 # You can also specify the reference file inline; note quotes:
2170 # $ ls -l *(e:'nt ~/.zshenv':)
2171 is4 && nt() {
2172     if [[ -n $1 ]] ; then
2173         local NTREF=${~1}
2174     fi
2175     [[ $REPLY -nt $NTREF ]]
2176 }
2177
2178 # shell functions
2179
2180 #f1# Reload an autoloadable function
2181 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2182 compdef _functions freload
2183
2184 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
2185 sll() {
2186     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
2187     for file in "$@" ; do
2188         while [[ -h "$file" ]] ; do
2189             ls -l $file
2190             file=$(readlink "$file")
2191         done
2192     done
2193 }
2194
2195 # TODO: Is it supported to use pager settings like this?
2196 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2197 # with respect to wordsplitting. (ie. ${=PAGER})
2198 if check_com -c $PAGER ; then
2199     #f1# View Debian's changelog of a given package
2200     dchange() {
2201         emulate -L zsh
2202         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
2203             $PAGER /usr/share/doc/$1/changelog.Debian.gz
2204         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2205             $PAGER /usr/share/doc/$1/changelog.gz
2206         else
2207             if check_com -c aptitude ; then
2208                 echo "No changelog for package $1 found, using aptitude to retrieve it."
2209                 if isgrml ; then
2210                     aptitude -t unstable changelog $1
2211                 else
2212                     aptitude changelog $1
2213                 fi
2214             else
2215                 echo "No changelog for package $1 found, sorry."
2216                 return 1
2217             fi
2218         fi
2219     }
2220     _dchange() { _files -W /usr/share/doc -/ }
2221     compdef _dchange dchange
2222
2223     #f1# View Debian's NEWS of a given package
2224     dnews() {
2225         emulate -L zsh
2226         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2227             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2228         else
2229             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2230                 $PAGER /usr/share/doc/$1/NEWS.gz
2231             else
2232                 echo "No NEWS file for package $1 found, sorry."
2233                 return 1
2234             fi
2235         fi
2236     }
2237     _dnews() { _files -W /usr/share/doc -/ }
2238     compdef _dnews dnews
2239
2240     #f1# View Debian's copyright of a given package
2241     dcopyright() {
2242         emulate -L zsh
2243         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2244             $PAGER /usr/share/doc/$1/copyright
2245         else
2246             echo "No copyright file for package $1 found, sorry."
2247             return 1
2248         fi
2249     }
2250     _dcopyright() { _files -W /usr/share/doc -/ }
2251     compdef _dcopyright dcopyright
2252
2253     #f1# View upstream's changelog of a given package
2254     uchange() {
2255         emulate -L zsh
2256         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2257             $PAGER /usr/share/doc/$1/changelog.gz
2258         else
2259             echo "No changelog for package $1 found, sorry."
2260             return 1
2261         fi
2262     }
2263     _uchange() { _files -W /usr/share/doc -/ }
2264     compdef _uchange uchange
2265 fi
2266
2267 # zsh profiling
2268 profile() {
2269     ZSH_PROFILE_RC=1 $SHELL "$@"
2270 }
2271
2272 #f1# Edit an alias via zle
2273 edalias() {
2274     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2275 }
2276 compdef _aliases edalias
2277
2278 #f1# Edit a function via zle
2279 edfunc() {
2280     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2281 }
2282 compdef _functions edfunc
2283
2284 # use it e.g. via 'Restart apache2'
2285 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
2286 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
2287 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
2288 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
2289 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
2290 #m# f6 Status() \kbd{/etc/init.d/\em{process}}\quad\kbd{status}
2291 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2292     __start_stop() {
2293         local action_="${1:l}"  # e.g Start/Stop/Restart
2294         local service_="$2"
2295         local param_="$3"
2296
2297         local service_target_="$(readlink /etc/init.d/$service_)"
2298         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2299             # runit
2300             case "${action_}" in
2301                 start) if [[ ! -e /etc/service/$service_ ]]; then
2302                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2303                        else
2304                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2305                        fi ;;
2306                 # there is no reload in runits sysv emulation
2307                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2308                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2309             esac
2310         else
2311             # sysvinit
2312             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2313         fi
2314     }
2315
2316     _grmlinitd() {
2317         local -a scripts
2318         scripts=( /etc/init.d/*(x:t) )
2319         _describe "service startup script" scripts
2320     }
2321
2322     for i in Start Restart Stop Force-Reload Reload Status ; do
2323         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
2324         compdef _grmlinitd $i
2325     done
2326 fi
2327
2328 #f1# Provides useful information on globbing
2329 H-Glob() {
2330     echo -e "
2331     /      directories
2332     .      plain files
2333     @      symbolic links
2334     =      sockets
2335     p      named pipes (FIFOs)
2336     *      executable plain files (0100)
2337     %      device files (character or block special)
2338     %b     block special files
2339     %c     character special files
2340     r      owner-readable files (0400)
2341     w      owner-writable files (0200)
2342     x      owner-executable files (0100)
2343     A      group-readable files (0040)
2344     I      group-writable files (0020)
2345     E      group-executable files (0010)
2346     R      world-readable files (0004)
2347     W      world-writable files (0002)
2348     X      world-executable files (0001)
2349     s      setuid files (04000)
2350     S      setgid files (02000)
2351     t      files with the sticky bit (01000)
2352
2353   print *(m-1)          # Files modified up to a day ago
2354   print *(a1)           # Files accessed a day ago
2355   print *(@)            # Just symlinks
2356   print *(Lk+50)        # Files bigger than 50 kilobytes
2357   print *(Lk-50)        # Files smaller than 50 kilobytes
2358   print **/*.c          # All *.c files recursively starting in \$PWD
2359   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2360   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2361   print *~*.*           # All Files that do not contain a dot
2362   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2363   print -l *(.c|.h)     # Lists *.c and *.h
2364   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2365   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2366 }
2367 alias help-zshglob=H-Glob
2368
2369 #v1# set number of lines to display per page
2370 HELP_LINES_PER_PAGE=20
2371 #v1# set location of help-zle cache file
2372 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
2373 #f1# helper function for help-zle, actually generates the help text
2374 help_zle_parse_keybindings()
2375 {
2376     emulate -L zsh
2377     setopt extendedglob
2378     unsetopt ksharrays  #indexing starts at 1
2379
2380     #v1# choose files that help-zle will parse for keybindings
2381     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
2382
2383     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
2384         local load_cache=0
2385         for f ($HELPZLE_KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
2386         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
2387     fi
2388
2389     #fill with default keybindings, possibly to be overwriten in a file later
2390     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
2391     local -A help_zle_keybindings
2392     help_zle_keybindings['<Ctrl>@']="set MARK"
2393     help_zle_keybindings['<Ctrl>x<Ctrl>j']="vi-join lines"
2394     help_zle_keybindings['<Ctrl>x<Ctrl>b']="jump to matching brace"
2395     help_zle_keybindings['<Ctrl>x<Ctrl>u']="undo"
2396     help_zle_keybindings['<Ctrl>_']="undo"
2397     help_zle_keybindings['<Ctrl>x<Ctrl>f<c>']="find <c> in cmdline"
2398     help_zle_keybindings['<Ctrl>a']="goto beginning of line"
2399     help_zle_keybindings['<Ctrl>e']="goto end of line"
2400     help_zle_keybindings['<Ctrl>t']="transpose charaters"
2401     help_zle_keybindings['<Alt>t']="transpose words"
2402     help_zle_keybindings['<Alt>s']="spellcheck word"
2403     help_zle_keybindings['<Ctrl>k']="backward kill buffer"
2404     help_zle_keybindings['<Ctrl>u']="forward kill buffer"
2405     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
2406     help_zle_keybindings["<Alt>'"]="quote line"
2407     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
2408     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
2409     help_zle_keybindings['<Alt>u']="make next word Uppercase"
2410     help_zle_keybindings['<Alt>l']="make next word lowercase"
2411     help_zle_keybindings['<Ctrl>xd']="preview expansion under cursor"
2412     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
2413     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
2414     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
2415     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
2416     help_zle_keybindings['<Ctrl>v']="insert next keypress symbol literally (e.g. for bindkey)"
2417     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
2418     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
2419     help_zle_keybindings['<Alt>h']="show help/manpage for current command"
2420
2421     #init global variables
2422     unset help_zle_lines help_zle_sln
2423     typeset -g -a help_zle_lines
2424     typeset -g help_zle_sln=1
2425
2426     local k v
2427     local lastkeybind_desc contents     #last description starting with #k# that we found
2428     local num_lines_elapsed=0            #number of lines between last description and keybinding
2429     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
2430     for f in $HELPZLE_KEYBINDING_FILES; do
2431         [[ -r "$f" ]] || continue   #not readable ? skip it
2432         contents="$(<$f)"
2433         for cline in "${(f)contents}"; do
2434             #zsh pattern: matches lines like: #k# ..............
2435             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
2436                 lastkeybind_desc="$match[*]"
2437                 num_lines_elapsed=0
2438             #zsh pattern: matches lines that set a keybinding using bindkey or compdef -k
2439             #             ignores lines that are commentend out
2440             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
2441             elif [[ "$cline" == [^#]#(bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
2442                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
2443                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
2444                     #substitute keybinding string with something readable
2445                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
2446                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
2447                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
2448                     help_zle_keybindings[${k}]=$lastkeybind_desc
2449                 fi
2450                 lastkeybind_desc=""
2451             else
2452               ((num_lines_elapsed++))
2453             fi
2454         done
2455     done
2456     unset contents
2457     #calculate length of keybinding column
2458     local kstrlen=0
2459     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
2460     #convert the assoc array into preformated lines, which we are able to sort
2461     for k v in ${(kv)help_zle_keybindings[@]}; do
2462         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
2463         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
2464     done
2465     #sort lines alphabetically
2466     help_zle_lines=("${(i)help_zle_lines[@]}")
2467     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
2468     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
2469     zcompile $HELP_ZLE_CACHE_FILE
2470 }
2471 typeset -g help_zle_sln
2472 typeset -g -a help_zle_lines
2473
2474 #f1# Provides (partially autogenerated) help on keybindings and the zsh line editor
2475 help-zle()
2476 {
2477     emulate -L zsh
2478     unsetopt ksharrays  #indexing starts at 1
2479     #help lines already generated ? no ? then do it
2480     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
2481     #already displayed all lines ? go back to the start
2482     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
2483     local sln=$help_zle_sln
2484     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
2485     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
2486     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
2487 }
2488 #k# display help for keybindings and ZLE (cycle pages with consecutive use)
2489 zle -N help-zle && bindkey '^xz' help-zle
2490
2491 # grep for running process, like: 'any vim'
2492 any() {
2493     emulate -L zsh
2494     unsetopt KSH_ARRAYS
2495     if [[ -z "$1" ]] ; then
2496         echo "any - grep for process(es) by keyword" >&2
2497         echo "Usage: any <keyword>" >&2 ; return 1
2498     else
2499         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
2500     fi
2501 }
2502
2503
2504 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2505 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2506 [[ -r /proc/1/maps ]] && \
2507 deswap() {
2508     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2509     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2510     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2511 }
2512
2513 # a wrapper for vim, that deals with title setting
2514 #   VIM_OPTIONS
2515 #       set this array to a set of options to vim you always want
2516 #       to have set when calling vim (in .zshrc.local), like:
2517 #           VIM_OPTIONS=( -p )
2518 #       This will cause vim to send every file given on the
2519 #       commandline to be send to it's own tab (needs vim7).
2520 if check_com vim; then
2521     vim() {
2522         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
2523     }
2524 fi
2525
2526 # make a backup of a file
2527 bk() {
2528     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
2529 }
2530
2531 ssl_hashes=( sha512 sha256 sha1 md5 )
2532
2533 for sh in ${ssl_hashes}; do
2534     eval 'ssl-cert-'${sh}'() {
2535         emulate -L zsh
2536         if [[ -z $1 ]] ; then
2537             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
2538             return 1
2539         fi
2540         openssl x509 -noout -fingerprint -'${sh}' -in $1
2541     }'
2542 done; unset sh
2543
2544 ssl-cert-fingerprints() {
2545     emulate -L zsh
2546     local i
2547     if [[ -z $1 ]] ; then
2548         printf 'usage: ssl-cert-fingerprints <file>\n'
2549         return 1
2550     fi
2551     for i in ${ssl_hashes}
2552         do ssl-cert-$i $1;
2553     done
2554 }
2555
2556 ssl-cert-info() {
2557     emulate -L zsh
2558     if [[ -z $1 ]] ; then
2559         printf 'usage: ssl-cert-info <file>\n'
2560         return 1
2561     fi
2562     openssl x509 -noout -text -in $1
2563     ssl-cert-fingerprints $1
2564 }
2565
2566 # make sure our environment is clean regarding colors
2567 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
2568
2569 # "persistent history"
2570 # just write important commands you always need to ~/.important_commands
2571 if [[ -r ~/.important_commands ]] ; then
2572     fc -R ~/.important_commands
2573 fi
2574
2575 # load the lookup subsystem if it's available on the system
2576 zrcautoload lookupinit && lookupinit
2577
2578 # variables
2579
2580 # set terminal property (used e.g. by msgid-chooser)
2581 export COLORTERM="yes"
2582
2583 # aliases
2584
2585 # general
2586 #a2# Execute \kbd{du -sch}
2587 alias da='du -sch'
2588 #a2# Execute \kbd{jobs -l}
2589 alias j='jobs -l'
2590
2591 # listing stuff
2592 #a2# Execute \kbd{ls -lSrah}
2593 alias dir="ls -lSrah"
2594 #a2# Only show dot-directories
2595 alias lad='ls -d .*(/)'
2596 #a2# Only show dot-files
2597 alias lsa='ls -a .*(.)'
2598 #a2# Only files with setgid/setuid/sticky flag
2599 alias lss='ls -l *(s,S,t)'
2600 #a2# Only show symlinks
2601 alias lsl='ls -l *(@)'
2602 #a2# Display only executables
2603 alias lsx='ls -l *(*)'
2604 #a2# Display world-{readable,writable,executable} files
2605 alias lsw='ls -ld *(R,W,X.^ND/)'
2606 #a2# Display the ten biggest files
2607 alias lsbig="ls -flh *(.OL[1,10])"
2608 #a2# Only show directories
2609 alias lsd='ls -d *(/)'
2610 #a2# Only show empty directories
2611 alias lse='ls -d *(/^F)'
2612 #a2# Display the ten newest files
2613 alias lsnew="ls -rtlh *(D.om[1,10])"
2614 #a2# Display the ten oldest files
2615 alias lsold="ls -rtlh *(D.Om[1,10])"
2616 #a2# Display the ten smallest files
2617 alias lssmall="ls -Srl *(.oL[1,10])"
2618 #a2# Display the ten newest directories and ten newest .directories
2619 alias lsnewdir="ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
2620 #a2# Display the ten oldest directories and ten oldest .directories
2621 alias lsolddir="ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
2622
2623 # some useful aliases
2624 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir $OLDCWD}
2625 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
2626
2627 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
2628 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2629 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2630
2631 # work around non utf8 capable software in utf environment via $LANG and luit
2632 if check_com isutfenv && check_com luit ; then
2633     if check_com -c mrxvt ; then
2634         isutfenv && [[ -n "$LANG" ]] && \
2635             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
2636     fi
2637
2638     if check_com -c aterm ; then
2639         isutfenv && [[ -n "$LANG" ]] && \
2640             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
2641     fi
2642
2643     if check_com -c centericq ; then
2644         isutfenv && [[ -n "$LANG" ]] && \
2645             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
2646     fi
2647 fi
2648
2649 # useful functions
2650
2651 #f5# Backup \kbd{file {\rm to} file\_timestamp}
2652 bk() {
2653     emulate -L zsh
2654     cp -b $1 $1_`date --iso-8601=m`
2655 }
2656
2657 #f5# cd to directoy and list files
2658 cl() {
2659     emulate -L zsh
2660     cd $1 && ls -a
2661 }
2662
2663 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
2664 cd() {
2665     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
2666         [[ ! -e ${1:h} ]] && return 1
2667         print "Correcting ${1} to ${1:h}"
2668         builtin cd ${1:h}
2669     else
2670         builtin cd "$@"
2671     fi
2672 }
2673
2674 #f5# Create Directoy and \kbd{cd} to it
2675 mkcd() {
2676     if (( ARGC != 1 )); then
2677         printf 'usage: mkcd <new-directory>\n'
2678         return 1;
2679     fi
2680     if [[ ! -d "$1" ]]; then
2681         command mkdir -p "$1"
2682     else
2683         printf '`%s'\'' already exists: cd-ing.\n' "$1"
2684     fi
2685     builtin cd "$1"
2686 }
2687
2688 #f5# Create temporary directory and \kbd{cd} to it
2689 cdt() {
2690     local t
2691     t=$(mktemp -d)
2692     echo "$t"
2693     builtin cd "$t"
2694 }
2695
2696 #f5# Create directory under cursor or the selected area
2697 # Press ctrl-xM to create the directory under the cursor or the selected area.
2698 # To select an area press ctrl-@ or ctrl-space and use the cursor.
2699 # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
2700 # directory does not exist yet -> press ctrl-XM and problem solved
2701 inplaceMkDirs() {
2702     local PATHTOMKDIR
2703     if ((REGION_ACTIVE==1)); then
2704         local F=$MARK T=$CURSOR
2705         if [[ $F -gt $T ]]; then
2706             F=${CURSOR}
2707             T=${MARK}
2708         fi
2709         # get marked area from buffer and eliminate whitespace
2710         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
2711         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
2712     else
2713         local bufwords iword
2714         bufwords=(${(z)LBUFFER})
2715         iword=${#bufwords}
2716         bufwords=(${(z)BUFFER})
2717         PATHTOMKDIR="${(Q)bufwords[iword]}"
2718     fi
2719     [[ -z "${PATHTOMKDIR}" ]] && return 1
2720     PATHTOMKDIR=${~PATHTOMKDIR}
2721     if [[ -e "${PATHTOMKDIR}" ]]; then
2722         zle -M " path already exists, doing nothing"
2723     else
2724         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
2725         zle end-of-line
2726     fi
2727 }
2728 #k# mkdir -p <dir> from string under cursor or marked area
2729 zle -N inplaceMkDirs && bindkey '^xM' inplaceMkDirs
2730
2731 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
2732 accessed() {
2733     emulate -L zsh
2734     print -l -- *(a-${1:-1})
2735 }
2736
2737 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
2738 changed() {
2739     emulate -L zsh
2740     print -l -- *(c-${1:-1})
2741 }
2742
2743 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
2744 modified() {
2745     emulate -L zsh
2746     print -l -- *(m-${1:-1})
2747 }
2748 # modified() was named new() in earlier versions, add an alias for backwards compatibility
2749 check_com new || alias new=modified
2750
2751 # use colors when GNU grep with color-support
2752 #a2# Execute \kbd{grep -{}-color=auto}
2753 (( $#grep_options > 0 )) && alias grep='grep '${grep_options:+"${grep_options[*]}"}
2754
2755 # Translate DE<=>EN
2756 # 'translate' looks up fot a word in a file with language-to-language
2757 # translations (field separator should be " : "). A typical wordlist looks
2758 # like at follows:
2759 #  | english-word : german-transmission
2760 # It's also only possible to translate english to german but not reciprocal.
2761 # Use the following oneliner to turn back the sort order:
2762 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
2763 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
2764 #f5# Translates a word
2765 trans() {
2766     emulate -L zsh
2767     case "$1" in
2768         -[dD]*)
2769             translate -l de-en $2
2770             ;;
2771         -[eE]*)
2772             translate -l en-de $2
2773             ;;
2774         *)
2775             echo "Usage: $0 { -D | -E }"
2776             echo "         -D == German to English"
2777             echo "         -E == English to German"
2778     esac
2779 }
2780
2781 # Usage: simple-extract <file>
2782 # Using option -d deletes the original archive file.
2783 #f5# Smart archive extractor
2784 simple-extract() {
2785     emulate -L zsh
2786     setopt extended_glob noclobber
2787     local DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
2788     local RC=0
2789     zparseopts -D -E "d=DELETE_ORIGINAL"
2790     for ARCHIVE in "${@}"; do
2791         case $ARCHIVE in
2792             *(tar.bz2|tbz2|tbz))
2793                 DECOMP_CMD="tar -xvjf -"
2794                 USES_STDIN=true
2795                 USES_STDOUT=false
2796                 ;;
2797             *(tar.gz|tgz))
2798                 DECOMP_CMD="tar -xvzf -"
2799                 USES_STDIN=true
2800                 USES_STDOUT=false
2801                 ;;
2802             *(tar.xz|txz|tar.lzma))
2803                 DECOMP_CMD="tar -xvJf -"
2804                 USES_STDIN=true
2805                 USES_STDOUT=false
2806                 ;;
2807             *tar)
2808                 DECOMP_CMD="tar -xvf -"
2809                 USES_STDIN=true
2810                 USES_STDOUT=false
2811                 ;;
2812             *rar)
2813                 DECOMP_CMD="unrar x"
2814                 USES_STDIN=false
2815                 USES_STDOUT=false
2816                 ;;
2817             *lzh)
2818                 DECOMP_CMD="lha x"
2819                 USES_STDIN=false
2820                 USES_STDOUT=false
2821                 ;;
2822             *7z)
2823                 DECOMP_CMD="7z x"
2824                 USES_STDIN=false
2825                 USES_STDOUT=false
2826                 ;;
2827             *(zip|jar))
2828                 DECOMP_CMD="unzip"
2829                 USES_STDIN=false
2830                 USES_STDOUT=false
2831                 ;;
2832             *deb)
2833                 DECOMP_CMD="ar -x"
2834                 USES_STDIN=false
2835                 USES_STDOUT=false
2836                 ;;
2837             *bz2)
2838                 DECOMP_CMD="bzip2 -d -c -"
2839                 USES_STDIN=true
2840                 USES_STDOUT=true
2841                 ;;
2842             *(gz|Z))
2843                 DECOMP_CMD="gzip -d -c -"
2844                 USES_STDIN=true
2845                 USES_STDOUT=true
2846                 ;;
2847             *(xz|lzma))
2848                 DECOMP_CMD="xz -d -c -"
2849                 USES_STDIN=true
2850                 USES_STDOUT=true
2851                 ;;
2852             *)
2853                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
2854                 RC=$((RC+1))
2855                 continue
2856                 ;;
2857         esac
2858
2859         if ! check_com ${DECOMP_CMD[(w)1]}; then
2860             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
2861             RC=$((RC+2))
2862             continue
2863         fi
2864
2865         GZTARGET="${ARCHIVE:t:r}"
2866         if [[ -f $ARCHIVE ]] ; then
2867
2868             print "Extracting '$ARCHIVE' ..."
2869             if $USES_STDIN; then
2870                 if $USES_STDOUT; then
2871                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
2872                 else
2873                     ${=DECOMP_CMD} < "$ARCHIVE"
2874                 fi
2875             else
2876                 if $USES_STDOUT; then
2877                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
2878                 else
2879                     ${=DECOMP_CMD} "$ARCHIVE"
2880                 fi
2881             fi
2882             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
2883
2884         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
2885             if check_com curl; then
2886                 WGET_CMD="curl -L -k -s -o -"
2887             elif check_com wget; then
2888                 WGET_CMD="wget -q -O - --no-check-certificate"
2889             else
2890                 print "ERROR: neither wget nor curl is installed" >&2
2891                 RC=$((RC+4))
2892                 continue
2893             fi
2894             print "Downloading and Extracting '$ARCHIVE' ..."
2895             if $USES_STDIN; then
2896                 if $USES_STDOUT; then
2897                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
2898                     RC=$((RC+$?))
2899                 else
2900                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
2901                     RC=$((RC+$?))
2902                 fi
2903             else
2904                 if $USES_STDOUT; then
2905                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
2906                 else
2907                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
2908                 fi
2909             fi
2910
2911         else
2912             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
2913             RC=$((RC+8))
2914         fi
2915     done
2916     return $RC
2917 }
2918
2919 __archive_or_uri()
2920 {
2921     _alternative \
2922         '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)"' \
2923         '_urls:Remote Archives:_urls'
2924 }
2925
2926 _simple_extract()
2927 {
2928     _arguments \
2929         '-d[delete original archivefile after extraction]' \
2930         '*:Archive Or Uri:__archive_or_uri'
2931 }
2932 compdef _simple_extract simple-extract
2933 alias se=simple-extract
2934
2935 #f5# Set all ulimit parameters to \kbd{unlimited}
2936 allulimit() {
2937     ulimit -c unlimited
2938     ulimit -d unlimited
2939     ulimit -f unlimited
2940     ulimit -l unlimited
2941     ulimit -n unlimited
2942     ulimit -s unlimited
2943     ulimit -t unlimited
2944 }
2945
2946 #f5# Change the xterm title from within GNU-screen
2947 xtrename() {
2948     emulate -L zsh
2949     if [[ $1 != "-f" ]] ; then
2950         if [[ -z ${DISPLAY} ]] ; then
2951             printf 'xtrename only makes sense in X11.\n'
2952             return 1
2953         fi
2954     else
2955         shift
2956     fi
2957     if [[ -z $1 ]] ; then
2958         printf 'usage: xtrename [-f] "title for xterm"\n'
2959         printf '  renames the title of xterm from _within_ screen.\n'
2960         printf '  also works without screen.\n'
2961         printf '  will not work if DISPLAY is unset, use -f to override.\n'
2962         return 0
2963     fi
2964     print -n "\eP\e]0;${1}\C-G\e\\"
2965     return 0
2966 }
2967
2968 # Create small urls via http://goo.gl using curl(1).
2969 # API reference: https://code.google.com/apis/urlshortener/
2970 function zurl() {
2971     emulate -L zsh
2972     setopt extended_glob
2973
2974     if [[ -z $1 ]]; then
2975         print "USAGE: zurl <URL>"
2976         return 1
2977     fi
2978
2979     local PN url prog api json contenttype item
2980     local -a data
2981     PN=$0
2982     url=$1
2983
2984     # Prepend 'http://' to given URL where necessary for later output.
2985     if [[ ${url} != http(s|)://* ]]; then
2986         url='http://'${url}
2987     fi
2988
2989     if check_com -c curl; then
2990         prog=curl
2991     else
2992         print "curl is not available, but mandatory for ${PN}. Aborting."
2993         return 1
2994     fi
2995     api='https://www.googleapis.com/urlshortener/v1/url'
2996     contenttype="Content-Type: application/json"
2997     json="{\"longUrl\": \"${url}\"}"
2998     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
2999     # Parse the response
3000     for item in "${data[@]}"; do
3001         case "$item" in
3002             ' '#'"id":'*)
3003                 item=${item#*: \"}
3004                 item=${item%\",*}
3005                 printf '%s\n' "$item"
3006                 return 0
3007                 ;;
3008         esac
3009     done
3010     return 1
3011 }
3012
3013 #f2# Find history events by search pattern and list them by date.
3014 whatwhen()  {
3015     emulate -L zsh
3016     local usage help ident format_l format_s first_char remain first last
3017     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3018     help='Use `whatwhen -h'\'' for further explanations.'
3019     ident=${(l,${#${:-Usage: }},, ,)}
3020     format_l="${ident}%s\t\t\t%s\n"
3021     format_s="${format_l//(\\t)##/\\t}"
3022     # Make the first char of the word to search for case
3023     # insensitive; e.g. [aA]
3024     first_char=[${(L)1[1]}${(U)1[1]}]
3025     remain=${1[2,-1]}
3026     # Default search range is `-100'.
3027     first=${2:-\-100}
3028     # Optional, just used for `<first> <last>' given.
3029     last=$3
3030     case $1 in
3031         ("")
3032             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3033             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3034         ;;
3035         (-h)
3036             printf '%s\n\n' ${usage}
3037             print 'OPTIONS:'
3038             printf $format_l '-h' 'show help text'
3039             print '\f'
3040             print 'SEARCH RANGE:'
3041             printf $format_l "'0'" 'the whole history,'
3042             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3043             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3044             printf '\n%s\n' 'EXAMPLES:'
3045             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3046             printf $format_l 'whatwhen zsh -250'
3047             printf $format_l 'whatwhen foo 1 99'
3048         ;;
3049         (\?)
3050             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3051         ;;
3052         (*)
3053             # -l list results on stout rather than invoking $EDITOR.
3054             # -i Print dates as in YYYY-MM-DD.
3055             # -m Search for a - quoted - pattern within the history.
3056             fc -li -m "*${first_char}${remain}*" $first $last
3057         ;;
3058     esac
3059 }
3060
3061 # mercurial related stuff
3062 if check_com -c hg ; then
3063     # gnu like diff for mercurial
3064     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3065     #f5# GNU like diff for mercurial
3066     hgdi() {
3067         emulate -L zsh
3068         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3069     }
3070
3071     # build debian package
3072     #a2# Alias for \kbd{hg-buildpackage}
3073     alias hbp='hg-buildpackage'
3074
3075     # execute commands on the versioned patch-queue from the current repos
3076     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3077
3078     # diffstat for specific version of a mercurial repository
3079     #   hgstat      => display diffstat between last revision and tip
3080     #   hgstat 1234 => display diffstat between revision 1234 and tip
3081     #f5# Diffstat for specific version of a mercurial repos
3082     hgstat() {
3083         emulate -L zsh
3084         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3085     }
3086
3087 fi # end of check whether we have the 'hg'-executable
3088
3089 # grml-small cleanups
3090
3091 # The following is used to remove zsh-config-items that do not work
3092 # in grml-small by default.
3093 # If you do not want these adjustments (for whatever reason), set
3094 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3095 # sources if it is there).
3096
3097 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3098
3099     unset abk[V]
3100     unalias    'V'      &> /dev/null
3101     unfunction vman     &> /dev/null
3102     unfunction viless   &> /dev/null
3103     unfunction 2html    &> /dev/null
3104
3105     # manpages are not in grmlsmall
3106     unfunction manzsh   &> /dev/null
3107     unfunction man2     &> /dev/null
3108
3109 fi
3110
3111 zrclocal
3112
3113 ## genrefcard.pl settings
3114
3115 ### doc strings for external functions from files
3116 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3117
3118 ### example: split functions-search 8,16,24,32
3119 #@# split functions-search 8
3120
3121 ## END OF FILE #################################################################
3122 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3123 # Local variables:
3124 # mode: sh
3125 # End: