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
 106 # zsh profiling {{{
 107 # just execute 'ZSH_PROFILE_RC=1 zsh' and run 'zprof' to get the details
 108 if [[ $ZSH_PROFILE_RC -gt 0 ]] ; then
 109     zmodload zsh/zprof
 110 fi
 111 # }}}
 112
 113 # load .zshrc.pre to give the user the chance to overwrite the defaults
 114 [[ -r ${HOME}/.zshrc.pre ]] && source ${HOME}/.zshrc.pre
 115
 116 # {{{ check for version/system
 117 # check for versions (compatibility reasons)
 118 is4(){
 119     [[ $ZSH_VERSION == <4->* ]] && return 0
 120     return 1
 121 }
 122
 123 is41(){
 124     [[ $ZSH_VERSION == 4.<1->* || $ZSH_VERSION == <5->* ]] && return 0
 125     return 1
 126 }
 127
 128 is42(){
 129     [[ $ZSH_VERSION == 4.<2->* || $ZSH_VERSION == <5->* ]] && return 0
 130     return 1
 131 }
 132
 133 is425(){
 134     [[ $ZSH_VERSION == 4.2.<5->* || $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 135     return 1
 136 }
 137
 138 is43(){
 139     [[ $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 140     return 1
 141 }
 142
 143 is433(){
 144     [[ $ZSH_VERSION == 4.3.<3->* || $ZSH_VERSION == 4.<4->* || $ZSH_VERSION == <5->* ]] && return 0
 145     return 1
 146 }
 147
 148 is439(){
 149     [[ $ZSH_VERSION == 4.3.<9->* || $ZSH_VERSION == 4.<4->* || $ZSH_VERSION == <5->* ]] && return 0
 150     return 1
 151 }
 152
 153 #f1# Checks whether or not you're running grml
 154 isgrml(){
 155     [[ -f /etc/grml_version ]] && return 0
 156     return 1
 157 }
 158
 159 #f1# Checks whether or not you're running a grml cd
 160 isgrmlcd(){
 161     [[ -f /etc/grml_cd ]] && return 0
 162     return 1
 163 }
 164
 165 if isgrml ; then
 166 #f1# Checks whether or not you're running grml-small
 167     isgrmlsmall() {
 168         [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]] && return 0 ; return 1
 169     }
 170 else
 171     isgrmlsmall() { return 1 }
 172 fi
 173
 174 isdarwin(){
 175     [[ $OSTYPE == darwin* ]] && return 0
 176     return 1
 177 }
 178
 179 #f1# are we running within an utf environment?
 180 isutfenv() {
 181     case "$LANG $CHARSET $LANGUAGE" in
 182         *utf*) return 0 ;;
 183         *UTF*) return 0 ;;
 184         *)     return 1 ;;
 185     esac
 186 }
 187
 188 # check for user, if not running as root set $SUDO to sudo
 189 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
 190
 191 # change directory to home on first invocation of zsh
 192 # important for rungetty -> autologin
 193 # Thanks go to Bart Schaefer!
 194 isgrml && checkhome() {
 195     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
 196         export ALREADY_DID_CD_HOME=$HOME
 197         cd
 198     fi
 199 }
 200
 201 # check for zsh v3.1.7+
 202
 203 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
 204      || ${ZSH_VERSION} == 3.<2->.<->*    \
 205      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
 206
 207     printf '-!-\n'
 208     printf '-!- In this configuration we try to make use of features, that only\n'
 209     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
 210     printf '-!- used with a wide range of zsh versions, while using fairly\n'
 211     printf '-!- advanced features in all supported versions.\n'
 212     printf '-!-\n'
 213     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
 214     printf '-!-\n'
 215     printf '-!- While this *may* work, it might as well fail.\n'
 216     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
 217     printf '-!-\n'
 218     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
 219     printf '-!- If it does today, you'\''ve been lucky.\n'
 220     printf '-!-\n'
 221     printf '-!- Ye been warned!\n'
 222     printf '-!-\n'
 223
 224     function zstyle() { : }
 225 fi
 226
 227 # autoload wrapper - use this one instead of autoload directly
 228 # We need to define this function as early as this, because autoloading
 229 # 'is-at-least()' needs it.
 230 function zrcautoload() {
 231     emulate -L zsh
 232     setopt extended_glob
 233     local fdir ffile
 234     local -i ffound
 235
 236     ffile=$1
 237     (( found = 0 ))
 238     for fdir in ${fpath} ; do
 239         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
 240     done
 241
 242     (( ffound == 0 )) && return 1
 243     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
 244         autoload -U ${ffile} || return 1
 245     else
 246         autoload ${ffile} || return 1
 247     fi
 248     return 0
 249 }
 250
 251 # Load is-at-least() for more precise version checks
 252 # Note that this test will *always* fail, if the is-at-least
 253 # function could not be marked for autoloading.
 254 zrcautoload is-at-least || is-at-least() { return 1 }
 255
 256 # }}}
 257
 258 # {{{ set some important options (as early as possible)
 259 setopt append_history       # append history list to the history file (important for multiple parallel zsh sessions!)
 260 is4 && setopt SHARE_HISTORY # import new commands from the history file also in other zsh-session
 261 setopt extended_history     # save each command's beginning timestamp and the duration to the history file
 262 is4 && setopt histignorealldups # If  a  new  command  line being added to the history
 263                             # list duplicates an older one, the older command is removed from the list
 264 setopt histignorespace      # remove command lines from the history list when
 265                             # the first character on the line is a space
 266 setopt auto_cd              # if a command is issued that can't be executed as a normal command,
 267                             # and the command is the name of a directory, perform the cd command to that directory
 268 setopt extended_glob        # in order to use #, ~ and ^ for filename generation
 269                             # grep word *~(*.gz|*.bz|*.bz2|*.zip|*.Z) ->
 270                             # -> searches for word not in compressed files
 271                             # don't forget to quote '^', '~' and '#'!
 272 setopt longlistjobs         # display PID when suspending processes as well
 273 setopt notify               # report the status of backgrounds jobs immediately
 274 setopt hash_list_all        # Whenever a command completion is attempted, make sure \
 275                             # the entire command path is hashed first.
 276 setopt completeinword       # not just at the end
 277 setopt nohup                # and don't kill them, either
 278 setopt auto_pushd           # make cd push the old directory onto the directory stack.
 279 setopt nonomatch            # try to avoid the 'zsh: no matches found...'
 280 setopt nobeep               # avoid "beep"ing
 281 setopt pushd_ignore_dups    # don't push the same dir twice.
 282 setopt noglobdots           # * shouldn't match dotfiles. ever.
 283 setopt noshwordsplit        # use zsh style word splitting
 284 setopt unset                # don't error out when unset parameters are used
 285
 286 # }}}
 287
 288 # setting some default values {{{
 289
 290 NOCOR=${NOCOR:-0}
 291 NOMENU=${NOMENU:-0}
 292 NOPRECMD=${NOPRECMD:-0}
 293 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
 294 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
 295 BATTERY=${BATTERY:-0}
 296 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
 297 GRML_ALWAYS_LOAD_ALL=${GRML_ALWAYS_LOAD_ALL:-0}
 298 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
 299
 300 # }}}
 301
 302 # utility functions {{{
 303 # this function checks if a command exists and returns either true
 304 # or false. This avoids using 'which' and 'whence', which will
 305 # avoid problems with aliases for which on certain weird systems. :-)
 306 # Usage: check_com [-c|-g] word
 307 #   -c  only checks for external commands
 308 #   -g  does the usual tests and also checks for global aliases
 309 check_com() {
 310     emulate -L zsh
 311     local -i comonly gatoo
 312
 313     if [[ $1 == '-c' ]] ; then
 314         (( comonly = 1 ))
 315         shift
 316     elif [[ $1 == '-g' ]] ; then
 317         (( gatoo = 1 ))
 318     else
 319         (( comonly = 0 ))
 320         (( gatoo = 0 ))
 321     fi
 322
 323     if (( ${#argv} != 1 )) ; then
 324         printf 'usage: check_com [-c] <command>\n' >&2
 325         return 1
 326     fi
 327
 328     if (( comonly > 0 )) ; then
 329         [[ -n ${commands[$1]}  ]] && return 0
 330         return 1
 331     fi
 332
 333     if   [[ -n ${commands[$1]}    ]] \
 334       || [[ -n ${functions[$1]}   ]] \
 335       || [[ -n ${aliases[$1]}     ]] \
 336       || [[ -n ${reswords[(r)$1]} ]] ; then
 337
 338         return 0
 339     fi
 340
 341     if (( gatoo > 0 )) && [[ -n ${galiases[$1]} ]] ; then
 342         return 0
 343     fi
 344
 345     return 1
 346 }
 347
 348 # creates an alias and precedes the command with
 349 # sudo if $EUID is not zero.
 350 salias() {
 351     emulate -L zsh
 352     local only=0 ; local multi=0
 353     while [[ $1 == -* ]] ; do
 354         case $1 in
 355             (-o) only=1 ;;
 356             (-a) multi=1 ;;
 357             (--) shift ; break ;;
 358             (-h)
 359                 printf 'usage: salias [-h|-o|-a] <alias-expression>\n'
 360                 printf '  -h      shows this help text.\n'
 361                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
 362                 printf '          be careful using this option.\n'
 363                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
 364                 return 0
 365                 ;;
 366             (*) printf "unkown option: '%s'\n" "$1" ; return 1 ;;
 367         esac
 368         shift
 369     done
 370
 371     if (( ${#argv} > 1 )) ; then
 372         printf 'Too many arguments %s\n' "${#argv}"
 373         return 1
 374     fi
 375
 376     key="${1%%\=*}" ;  val="${1#*\=}"
 377     if (( EUID == 0 )) && (( only == 0 )); then
 378         alias -- "${key}=${val}"
 379     elif (( EUID > 0 )) ; then
 380         (( multi > 0 )) && val="${val// ; / ; sudo }"
 381         alias -- "${key}=sudo ${val}"
 382     fi
 383
 384     return 0
 385 }
 386
 387 # a "print -l ${(u)foo}"-workaround for pre-4.2.0 shells
 388 # usage: uprint foo
 389 #   Where foo is the *name* of the parameter you want printed.
 390 #   Note that foo is no typo; $foo would be wrong here!
 391 if ! is42 ; then
 392     uprint () {
 393         emulate -L zsh
 394         local -a u
 395         local w
 396         local parameter=$1
 397
 398         if [[ -z ${parameter} ]] ; then
 399             printf 'usage: uprint <parameter>\n'
 400             return 1
 401         fi
 402
 403         for w in ${(P)parameter} ; do
 404             [[ -z ${(M)u:#$w} ]] && u=( $u $w )
 405         done
 406
 407         builtin print -l $u
 408     }
 409 fi
 410
 411 # Check if we can read given files and source those we can.
 412 xsource() {
 413     if (( ${#argv} < 1 )) ; then
 414         printf 'usage: xsource FILE(s)...\n' >&2
 415         return 1
 416     fi
 417
 418     while (( ${#argv} > 0 )) ; do
 419         [[ -r "$1" ]] && source "$1"
 420         shift
 421     done
 422     return 0
 423 }
 424
 425 # Check if we can read a given file and 'cat(1)' it.
 426 xcat() {
 427     emulate -L zsh
 428     if (( ${#argv} != 1 )) ; then
 429         printf 'usage: xcat FILE\n' >&2
 430         return 1
 431     fi
 432
 433     [[ -r $1 ]] && cat $1
 434     return 0
 435 }
 436
 437 # Remove these functions again, they are of use only in these
 438 # setup files. This should be called at the end of .zshrc.
 439 xunfunction() {
 440     emulate -L zsh
 441     local -a funcs
 442     funcs=(salias xcat xsource xunfunction zrcautoload)
 443
 444     for func in $funcs ; do
 445         [[ -n ${functions[$func]} ]] \
 446             && unfunction $func
 447     done
 448     return 0
 449 }
 450
 451 # this allows us to stay in sync with grml's zshrc and put own
 452 # modifications in ~/.zshrc.local
 453 zrclocal() {
 454     xsource "/etc/zsh/zshrc.local"
 455     xsource "${HOME}/.zshrc.local"
 456     return 0
 457 }
 458
 459 #}}}
 460
 461 # locale setup {{{
 462 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
 463     xsource "/etc/default/locale"
 464 fi
 465
 466 for var in LANG LC_ALL LC_MESSAGES ; do
 467     [[ -n ${(P)var} ]] && export $var
 468 done
 469
 470 xsource "/etc/sysconfig/keyboard"
 471
 472 TZ=$(xcat /etc/timezone)
 473 # }}}
 474
 475 # {{{ set some variables
 476 if check_com -c vim ; then
 477 #v#
 478     export EDITOR=${EDITOR:-vim}
 479 else
 480     export EDITOR=${EDITOR:-vi}
 481 fi
 482
 483 #v#
 484 export PAGER=${PAGER:-less}
 485
 486 #v#
 487 export MAIL=${MAIL:-/var/mail/$USER}
 488
 489 # if we don't set $SHELL then aterm, rxvt,.. will use /bin/sh or /bin/bash :-/
 490 export SHELL='/bin/zsh'
 491
 492 # color setup for ls:
 493 check_com -c dircolors && eval $(dircolors -b)
 494 # color setup for ls on OS X:
 495 isdarwin && export CLICOLOR=1
 496
 497 # do MacPorts setup on darwin
 498 if isdarwin && [[ -d /opt/local ]]; then
 499     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
 500     # zshenv.
 501     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
 502     MANPATH="/opt/local/share/man:$MANPATH"
 503 fi
 504 # do Fink setup on darwin
 505 isdarwin && xsource /sw/bin/init.sh
 506
 507 # load our function and completion directories
 508 for fdir in /usr/share/grml/zsh/completion /usr/share/grml/zsh/functions; do
 509     fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
 510     if [[ ${fpath} == '/usr/share/grml/zsh/functions' ]] ; then
 511         for func in ${fdir}/**/[^_]*[^~](N.) ; do
 512             zrcautoload ${func:t}
 513         done
 514     fi
 515 done
 516 unset fdir func
 517
 518 # support colors in less
 519 export LESS_TERMCAP_mb=$'\E[01;31m'
 520 export LESS_TERMCAP_md=$'\E[01;31m'
 521 export LESS_TERMCAP_me=$'\E[0m'
 522 export LESS_TERMCAP_se=$'\E[0m'
 523 export LESS_TERMCAP_so=$'\E[01;44;33m'
 524 export LESS_TERMCAP_ue=$'\E[0m'
 525 export LESS_TERMCAP_us=$'\E[01;32m'
 526
 527 MAILCHECK=30       # mailchecks
 528 REPORTTIME=5       # report about cpu-/system-/user-time of command if running longer than 5 seconds
 529 watch=(notme root) # watch for everyone but me and root
 530
 531 # automatically remove duplicates from these arrays
 532 typeset -U path cdpath fpath manpath
 533 # }}}
 534
 535 # {{{ keybindings
 536 if [[ "$TERM" != emacs ]] ; then
 537     [[ -z "$terminfo[kdch1]" ]] || bindkey -M emacs "$terminfo[kdch1]" delete-char
 538     [[ -z "$terminfo[khome]" ]] || bindkey -M emacs "$terminfo[khome]" beginning-of-line
 539     [[ -z "$terminfo[kend]"  ]] || bindkey -M emacs "$terminfo[kend]"  end-of-line
 540     [[ -z "$terminfo[kdch1]" ]] || bindkey -M vicmd "$terminfo[kdch1]" vi-delete-char
 541     [[ -z "$terminfo[khome]" ]] || bindkey -M vicmd "$terminfo[khome]" vi-beginning-of-line
 542     [[ -z "$terminfo[kend]"  ]] || bindkey -M vicmd "$terminfo[kend]"  vi-end-of-line
 543     [[ -z "$terminfo[cuu1]"  ]] || bindkey -M viins "$terminfo[cuu1]"  vi-up-line-or-history
 544     [[ -z "$terminfo[cuf1]"  ]] || bindkey -M viins "$terminfo[cuf1]"  vi-forward-char
 545     [[ -z "$terminfo[kcuu1]" ]] || bindkey -M viins "$terminfo[kcuu1]" vi-up-line-or-history
 546     [[ -z "$terminfo[kcud1]" ]] || bindkey -M viins "$terminfo[kcud1]" vi-down-line-or-history
 547     [[ -z "$terminfo[kcuf1]" ]] || bindkey -M viins "$terminfo[kcuf1]" vi-forward-char
 548     [[ -z "$terminfo[kcub1]" ]] || bindkey -M viins "$terminfo[kcub1]" vi-backward-char
 549     # ncurses stuff:
 550     [[ "$terminfo[kcuu1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuu1]/O/[}" vi-up-line-or-history
 551     [[ "$terminfo[kcud1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcud1]/O/[}" vi-down-line-or-history
 552     [[ "$terminfo[kcuf1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuf1]/O/[}" vi-forward-char
 553     [[ "$terminfo[kcub1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcub1]/O/[}" vi-backward-char
 554     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M viins "${terminfo[khome]/O/[}" beginning-of-line
 555     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M viins "${terminfo[kend]/O/[}"  end-of-line
 556     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M emacs "${terminfo[khome]/O/[}" beginning-of-line
 557     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M emacs "${terminfo[kend]/O/[}"  end-of-line
 558 fi
 559
 560 ## keybindings (run 'bindkeys' for details, more details via man zshzle)
 561 # use emacs style per default:
 562 bindkey -e
 563 # use vi style:
 564 # bindkey -v
 565
 566 #if [[ "$TERM" == screen ]] ; then
 567 bindkey '\e[1~' beginning-of-line       # home
 568 bindkey '\e[4~' end-of-line             # end
 569 bindkey '\e[A'  up-line-or-search       # cursor up
 570 bindkey '\e[B'  down-line-or-search     # <ESC>-
 571
 572 ## alt-backspace is already the default for backwards-delete-word
 573 ## let's also set alt-delete for deleting current word (right of cursor)
 574 #k# Delete current word
 575 bindkey "3~" delete-word
 576
 577 bindkey '^xp'   history-beginning-search-backward
 578 bindkey '^xP'   history-beginning-search-forward
 579 # bindkey -s '^L' "|less\n"             # ctrl-L pipes to less
 580 # bindkey -s '^B' " &\n"                # ctrl-B runs it in the background
 581 # if terminal type is set to 'rxvt':
 582 bindkey '\e[7~' beginning-of-line       # home
 583 bindkey '\e[8~' end-of-line             # end
 584 #fi
 585
 586 # insert unicode character
 587 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
 588 # See for example http://unicode.org/charts/ for unicode characters code
 589 zrcautoload insert-unicode-char
 590 zle -N insert-unicode-char
 591 #k# Insert Unicode character
 592 bindkey '^Xi' insert-unicode-char
 593
 594 #m# k Shift-tab Perform backwards menu completion
 595 if [[ -n "$terminfo[kcbt]" ]]; then
 596     bindkey "$terminfo[kcbt]" reverse-menu-complete
 597 elif [[ -n "$terminfo[cbt]" ]]; then # required for GNU screen
 598     bindkey "$terminfo[cbt]"  reverse-menu-complete
 599 fi
 600
 601 ## toggle the ,. abbreviation feature on/off
 602 # NOABBREVIATION: default abbreviation-state
 603 #                 0 - enabled (default)
 604 #                 1 - disabled
 605 NOABBREVIATION=${NOABBREVIATION:-0}
 606
 607 grml_toggle_abbrev() {
 608     if (( ${NOABBREVIATION} > 0 )) ; then
 609         NOABBREVIATION=0
 610     else
 611         NOABBREVIATION=1
 612     fi
 613 }
 614
 615 zle -N grml_toggle_abbrev
 616 bindkey '^xA' grml_toggle_abbrev
 617
 618 # add a command line to the shells history without executing it
 619 commit-to-history() {
 620     print -s ${(z)BUFFER}
 621     zle send-break
 622 }
 623 zle -N commit-to-history
 624 bindkey "^x^h" commit-to-history
 625
 626 # only slash should be considered as a word separator:
 627 slash-backward-kill-word() {
 628     local WORDCHARS="${WORDCHARS:s@/@}"
 629     # zle backward-word
 630     zle backward-kill-word
 631 }
 632 zle -N slash-backward-kill-word
 633
 634 #k# Kill everything in a word up to its last \kbd{/}
 635 bindkey '\ev' slash-backward-kill-word
 636 #k# Kill everything in a word up to its last \kbd{/}
 637 bindkey '\e^h' slash-backward-kill-word
 638 #k# Kill everything in a word up to its last \kbd{/}
 639 bindkey '\e^?' slash-backward-kill-word
 640
 641 # use the new *-pattern-* widgets for incremental history search
 642 if is439 ; then
 643     bindkey '^r' history-incremental-pattern-search-backward
 644     bindkey '^s' history-incremental-pattern-search-forward
 645 fi
 646 # }}}
 647
 648 # a generic accept-line wrapper {{{
 649
 650 # This widget can prevent unwanted autocorrections from command-name
 651 # to _command-name, rehash automatically on enter and call any number
 652 # of builtin and user-defined widgets in different contexts.
 653 #
 654 # For a broader description, see:
 655 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
 656 #
 657 # The code is imported from the file 'zsh/functions/accept-line' from
 658 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
 659 # distributed under the same terms as zsh itself.
 660
 661 # A newly added command will may not be found or will cause false
 662 # correction attempts, if you got auto-correction set. By setting the
 663 # following style, we force accept-line() to rehash, if it cannot
 664 # find the first word on the command line in the $command[] hash.
 665 zstyle ':acceptline:*' rehash true
 666
 667 function Accept-Line() {
 668     emulate -L zsh
 669     local -a subs
 670     local -xi aldone
 671     local sub
 672
 673     zstyle -a ":acceptline:${alcontext}" actions subs
 674
 675     (( ${#subs} < 1 )) && return 0
 676
 677     (( aldone = 0 ))
 678     for sub in ${subs} ; do
 679         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
 680         zle ${sub}
 681
 682         (( aldone > 0 )) && break
 683     done
 684 }
 685
 686 function Accept-Line-getdefault() {
 687     emulate -L zsh
 688     local default_action
 689
 690     zstyle -s ":acceptline:${alcontext}" default_action default_action
 691     case ${default_action} in
 692         ((accept-line|))
 693             printf ".accept-line"
 694             ;;
 695         (*)
 696             printf ${default_action}
 697             ;;
 698     esac
 699 }
 700
 701 function accept-line() {
 702     emulate -L zsh
 703     local -a cmdline
 704     local -x alcontext
 705     local buf com fname format msg default_action
 706
 707     alcontext='default'
 708     buf="${BUFFER}"
 709     cmdline=(${(z)BUFFER})
 710     com="${cmdline[1]}"
 711     fname="_${com}"
 712
 713     zstyle -t ":acceptline:${alcontext}" rehash \
 714         && [[ -z ${commands[$com]} ]]           \
 715         && rehash
 716
 717     if    [[ -n ${reswords[(r)$com]} ]] \
 718        || [[ -n ${aliases[$com]}     ]] \
 719        || [[ -n ${functions[$com]}   ]] \
 720        || [[ -n ${builtins[$com]}    ]] \
 721        || [[ -n ${commands[$com]}    ]] ; then
 722
 723         # there is something sensible to execute, just do it.
 724         alcontext='normal'
 725         zle Accept-Line
 726
 727         default_action=$(Accept-Line-getdefault)
 728         zstyle -T ":acceptline:${alcontext}" call_default \
 729             && zle ${default_action}
 730         return
 731     fi
 732
 733     if    [[ -o correct              ]] \
 734        || [[ -o correctall           ]] \
 735        && [[ -n ${functions[$fname]} ]] ; then
 736
 737         # nothing there to execute but there is a function called
 738         # _command_name; a completion widget. Makes no sense to
 739         # call it on the commandline, but the correct{,all} options
 740         # will ask for it nevertheless, so warn the user.
 741         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
 742             # Okay, we warned the user before, he called us again,
 743             # so have it his way.
 744             alcontext='force'
 745             zle Accept-Line
 746
 747             default_action=$(Accept-Line-getdefault)
 748             zstyle -T ":acceptline:${alcontext}" call_default \
 749                 && zle ${default_action}
 750             return
 751         fi
 752
 753         # prepare warning message for the user, configurable via zstyle.
 754         zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
 755
 756         if [[ -z ${msg} ]] ; then
 757             msg="%c will not execute and completion %f exists."
 758         fi
 759
 760         zformat -f msg "${msg}" "c:${com}" "f:${fname}"
 761
 762         zle -M -- "${msg}"
 763         return
 764     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
 765         # If we are here, the commandline contains something that is not
 766         # executable, which is neither subject to _command_name correction
 767         # and is not empty. might be a variable assignment
 768         alcontext='misc'
 769         zle Accept-Line
 770
 771         default_action=$(Accept-Line-getdefault)
 772         zstyle -T ":acceptline:${alcontext}" call_default \
 773             && zle ${default_action}
 774         return
 775     fi
 776
 777     # If we got this far, the commandline only contains whitespace, or is empty.
 778     alcontext='empty'
 779     zle Accept-Line
 780
 781     default_action=$(Accept-Line-getdefault)
 782     zstyle -T ":acceptline:${alcontext}" call_default \
 783         && zle ${default_action}
 784 }
 785
 786 zle -N accept-line
 787 zle -N Accept-Line
 788
 789 # }}}
 790
 791 # power completion - abbreviation expansion {{{
 792 # power completion / abbreviation expansion / buffer expansion
 793 # see http://zshwiki.org/home/examples/zleiab for details
 794 # less risky than the global aliases but powerful as well
 795 # just type the abbreviation key and afterwards ',.' to expand it
 796 declare -A abk
 797 setopt extendedglob
 798 setopt interactivecomments
 799 abk=(
 800 #   key   # value                  (#d additional doc string)
 801 #A# start
 802     '...'  '../..'
 803     '....' '../../..'
 804     'BG'   '& exit'
 805     'C'    '| wc -l'
 806     'G'    '|& grep --color=auto '
 807     'H'    '| head'
 808     'Hl'   ' --help |& less -r'    #d (Display help in pager)
 809     'L'    '| less'
 810     'LL'   '|& less -r'
 811     'M'    '| most'
 812     'N'    '&>/dev/null'           #d (No Output)
 813     'R'    '| tr A-z N-za-m'       #d (ROT13)
 814     'SL'   '| sort | less'
 815     'S'    '| sort -u'
 816     'T'    '| tail'
 817     'V'    '|& vim -'
 818 #A# end
 819     'co'   './configure && make && sudo make install'
 820 )
 821
 822 globalias() {
 823     emulate -L zsh
 824     setopt extendedglob
 825     local MATCH
 826
 827     if (( NOABBREVIATION > 0 )) ; then
 828         LBUFFER="${LBUFFER},."
 829         return 0
 830     fi
 831
 832     matched_chars='[.-|_a-zA-Z0-9]#'
 833     LBUFFER=${LBUFFER%%(#m)[.-|_a-zA-Z0-9]#}
 834     LBUFFER+=${abk[$MATCH]:-$MATCH}
 835 }
 836
 837 zle -N globalias
 838 bindkey ",." globalias
 839 # }}}
 840
 841 # {{{ autoloading
 842 zrcautoload zmv    # who needs mmv or rename?
 843 zrcautoload history-search-end
 844
 845 # we don't want to quote/espace URLs on our own...
 846 # if autoload -U url-quote-magic ; then
 847 #    zle -N self-insert url-quote-magic
 848 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
 849 # else
 850 #    print 'Notice: no url-quote-magic available :('
 851 # fi
 852 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
 853
 854 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
 855 alias run-help >&/dev/null && unalias run-help
 856 for rh in run-help{,-git,-svk,-svn}; do
 857     zrcautoload $rh
 858 done; unset rh
 859
 860 # completion system
 861 if zrcautoload compinit ; then
 862     compinit || print 'Notice: no compinit available :('
 863 else
 864     print 'Notice: no compinit available :('
 865     function zstyle { }
 866     function compdef { }
 867 fi
 868
 869 is4 && zrcautoload zed # use ZLE editor to edit a file or function
 870
 871 is4 && \
 872 for mod in complist deltochar mathfunc ; do
 873     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
 874 done
 875
 876 # autoload zsh modules when they are referenced
 877 if is4 ; then
 878     zmodload -a  zsh/stat    zstat
 879     zmodload -a  zsh/zpty    zpty
 880     zmodload -ap zsh/mapfile mapfile
 881 fi
 882
 883 if is4 && zrcautoload insert-files && zle -N insert-files ; then
 884     #k# Insert files
 885     bindkey "^Xf" insert-files # C-x-f
 886 fi
 887
 888 bindkey ' '   magic-space    # also do history expansion on space
 889 #k# Trigger menu-complete
 890 bindkey '\ei' menu-complete  # menu completion via esc-i
 891
 892 # press esc-e for editing command line in $EDITOR or $VISUAL
 893 if is4 && zrcautoload edit-command-line && zle -N edit-command-line ; then
 894     #k# Edit the current line in \kbd{\$EDITOR}
 895     bindkey '\ee' edit-command-line
 896 fi
 897
 898 if is4 && [[ -n ${(k)modules[zsh/complist]} ]] ; then
 899     #k# menu selection: pick item but stay in the menu
 900     bindkey -M menuselect '\e^M' accept-and-menu-complete
 901     # also use + and INSERT since it's easier to press repeatedly
 902     bindkey -M menuselect "+" accept-and-menu-complete
 903     bindkey -M menuselect "^[[2~" accept-and-menu-complete
 904
 905     # accept a completion and try to complete again by using menu
 906     # completion; very useful with completing directories
 907     # by using 'undo' one's got a simple file browser
 908     bindkey -M menuselect '^o' accept-and-infer-next-history
 909 fi
 910
 911 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
 912 insert-datestamp() { LBUFFER+=${(%):-'%D{%Y-%m-%d}'}; }
 913 zle -N insert-datestamp
 914
 915 #k# Insert a timestamp on the command line (yyyy-mm-dd)
 916 bindkey '^Ed' insert-datestamp
 917
 918 # press esc-m for inserting last typed word again (thanks to caphuso!)
 919 insert-last-typed-word() { zle insert-last-word -- 0 -1 };
 920 zle -N insert-last-typed-word;
 921
 922 #k# Insert last typed word
 923 bindkey "\em" insert-last-typed-word
 924
 925 function grml-zsh-fg() {
 926   if (( ${#jobstates} )); then
 927     zle .push-input
 928     [[ -o hist_ignore_space ]] && BUFFER=' ' || BUFFER=''
 929     BUFFER="${BUFFER}fg"
 930     zle .accept-line
 931   else
 932     zle -M 'No background jobs. Doing nothing.'
 933   fi
 934 }
 935 zle -N grml-zsh-fg
 936 #k# A smart shortcut for \kbd{fg<enter>}
 937 bindkey '^z' grml-zsh-fg
 938
 939 # run command line as user root via sudo:
 940 sudo-command-line() {
 941     [[ -z $BUFFER ]] && zle up-history
 942     if [[ $BUFFER != sudo\ * ]]; then
 943         BUFFER="sudo $BUFFER"
 944         CURSOR=$(( CURSOR+5 ))
 945     fi
 946 }
 947 zle -N sudo-command-line
 948
 949 #k# Put the current command line into a \kbd{sudo} call
 950 bindkey "^Os" sudo-command-line
 951
 952 ### jump behind the first word on the cmdline.
 953 ### useful to add options.
 954 function jump_after_first_word() {
 955     local words
 956     words=(${(z)BUFFER})
 957
 958     if (( ${#words} <= 1 )) ; then
 959         CURSOR=${#BUFFER}
 960     else
 961         CURSOR=${#${words[1]}}
 962     fi
 963 }
 964 zle -N jump_after_first_word
 965
 966 bindkey '^x1' jump_after_first_word
 967
 968 # complete word from history with menu (from Book: ZSH, OpenSource-Press)
 969 zle -C hist-complete complete-word _generic
 970 zstyle ':completion:hist-complete:*' completer _history
 971 #k# complete word from history with menu
 972 bindkey "^X^X" hist-complete
 973
 974 # }}}
 975
 976 # {{{ history
 977
 978 ZSHDIR=$HOME/.zsh
 979
 980 #v#
 981 HISTFILE=$HOME/.zsh_history
 982 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
 983 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
 984
 985 # }}}
 986
 987 # dirstack handling {{{
 988
 989 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
 990 DIRSTACKFILE=${DIRSTACKFILE:-${HOME}/.zdirs}
 991
 992 if [[ -f ${DIRSTACKFILE} ]] && [[ ${#dirstack[*]} -eq 0 ]] ; then
 993     dirstack=( ${(f)"$(< $DIRSTACKFILE)"} )
 994     # "cd -" won't work after login by just setting $OLDPWD, so
 995     [[ -d $dirstack[0] ]] && cd $dirstack[0] && cd $OLDPWD
 996 fi
 997
 998 chpwd() {
 999     local -ax my_stack
1000     my_stack=( ${PWD} ${dirstack} )
1001     if is42 ; then
1002         builtin print -l ${(u)my_stack} >! ${DIRSTACKFILE}
1003     else
1004         uprint my_stack >! ${DIRSTACKFILE}
1005     fi
1006 }
1007
1008 # }}}
1009
1010 # directory based profiles {{{
1011
1012 if is433 ; then
1013
1014 CHPWD_PROFILE='default'
1015 function chpwd_profiles() {
1016     # Say you want certain settings to be active in certain directories.
1017     # This is what you want.
1018     #
1019     # zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1020     # zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1021     #
1022     # When that's done and you enter a directory that matches the pattern
1023     # in the third part of the context, a function called chpwd_profile_grml,
1024     # for example, is called (if it exists).
1025     #
1026     # If no pattern matches (read: no profile is detected) the profile is
1027     # set to 'default', which means chpwd_profile_default is attempted to
1028     # be called.
1029     #
1030     # A word about the context (the ':chpwd:profiles:*' stuff in the zstyle
1031     # command) which is used: The third part in the context is matched against
1032     # ${PWD}. That's why using a pattern such as /foo/bar(|/|/*) makes sense.
1033     # Because that way the profile is detected for all these values of ${PWD}:
1034     #   /foo/bar
1035     #   /foo/bar/
1036     #   /foo/bar/baz
1037     # So, if you want to make double damn sure a profile works in /foo/bar
1038     # and everywhere deeper in that tree, just use (|/|/*) and be happy.
1039     #
1040     # The name of the detected profile will be available in a variable called
1041     # 'profile' in your functions. You don't need to do anything, it'll just
1042     # be there.
1043     #
1044     # Then there is the parameter $CHPWD_PROFILE is set to the profile, that
1045     # was is currently active. That way you can avoid running code for a
1046     # profile that is already active, by running code such as the following
1047     # at the start of your function:
1048     #
1049     # function chpwd_profile_grml() {
1050     #     [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1051     #   ...
1052     # }
1053     #
1054     # The initial value for $CHPWD_PROFILE is 'default'.
1055     #
1056     # Version requirement:
1057     #   This feature requires zsh 4.3.3 or newer.
1058     #   If you use this feature and need to know whether it is active in your
1059     #   current shell, there are several ways to do that. Here are two simple
1060     #   ways:
1061     #
1062     #   a) If knowing if the profiles feature is active when zsh starts is
1063     #      good enough for you, you can put the following snippet into your
1064     #      .zshrc.local:
1065     #
1066     #   (( ${+functions[chpwd_profiles]} )) && print "directory profiles active"
1067     #
1068     #   b) If that is not good enough, and you would prefer to be notified
1069     #      whenever a profile changes, you can solve that by making sure you
1070     #      start *every* profile function you create like this:
1071     #
1072     #   function chpwd_profile_myprofilename() {
1073     #       [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1074     #       print "chpwd(): Switching to profile: $profile"
1075     #     ...
1076     #   }
1077     #
1078     #      That makes sure you only get notified if a profile is *changed*,
1079     #      not everytime you change directory, which would probably piss
1080     #      you off fairly quickly. :-)
1081     #
1082     # There you go. Now have fun with that.
1083     local -x profile
1084
1085     zstyle -s ":chpwd:profiles:${PWD}" profile profile || profile='default'
1086     if (( ${+functions[chpwd_profile_$profile]} )) ; then
1087         chpwd_profile_${profile}
1088     fi
1089
1090     CHPWD_PROFILE="${profile}"
1091     return 0
1092 }
1093 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1094
1095 fi # is433
1096
1097 # }}}
1098
1099 # {{{ display battery status on right side of prompt via running 'BATTERY=1 zsh'
1100 if [[ $BATTERY -gt 0 ]] ; then
1101     if ! check_com -c acpi ; then
1102         BATTERY=0
1103     fi
1104 fi
1105
1106 battery() {
1107 if [[ $BATTERY -gt 0 ]] ; then
1108     PERCENT="${${"$(acpi 2>/dev/null)"}/(#b)[[:space:]]#Battery <->: [^0-9]##, (<->)%*/${match[1]}}"
1109     if [[ -z "$PERCENT" ]] ; then
1110         PERCENT='acpi not present'
1111     else
1112         if [[ "$PERCENT" -lt 20 ]] ; then
1113             PERCENT="warning: ${PERCENT}%%"
1114         else
1115             PERCENT="${PERCENT}%%"
1116         fi
1117     fi
1118 fi
1119 }
1120 # }}}
1121
1122 # set colors for use in prompts {{{
1123 if zrcautoload colors && colors 2>/dev/null ; then
1124     BLUE="%{${fg[blue]}%}"
1125     RED="%{${fg_bold[red]}%}"
1126     GREEN="%{${fg[green]}%}"
1127     CYAN="%{${fg[cyan]}%}"
1128     MAGENTA="%{${fg[magenta]}%}"
1129     YELLOW="%{${fg[yellow]}%}"
1130     WHITE="%{${fg[white]}%}"
1131     NO_COLOUR="%{${reset_color}%}"
1132 else
1133     BLUE=$'%{\e[1;34m%}'
1134     RED=$'%{\e[1;31m%}'
1135     GREEN=$'%{\e[1;32m%}'
1136     CYAN=$'%{\e[1;36m%}'
1137     WHITE=$'%{\e[1;37m%}'
1138     MAGENTA=$'%{\e[1;35m%}'
1139     YELLOW=$'%{\e[1;33m%}'
1140     NO_COLOUR=$'%{\e[0m%}'
1141 fi
1142
1143 # }}}
1144
1145 # gather version control information for inclusion in a prompt {{{
1146
1147 if ! is41 ; then
1148     # Be quiet about version problems in grml's zshrc as the user cannot disable
1149     # loading vcs_info() as it is *in* the zshrc - as you can see. :-)
1150     # Just unset most probable variables and disable vcs_info altogether.
1151     local -i i
1152     for i in {0..9} ; do
1153         unset VCS_INFO_message_${i}_
1154     done
1155     zstyle ':vcs_info:*' enable false
1156 fi
1157
1158 if zrcautoload vcs_info; then
1159     GRML_VCS_INFO=0
1160     # `vcs_info' in zsh versions 4.3.10 and below have a broken `_realpath'
1161     # function, which can cause a lot of trouble with our directory-based
1162     # profiles. So:
1163     if [[ ${ZSH_VERSION} == 4.3.<-10> ]] ; then
1164         function VCS_INFO_realpath () {
1165             setopt localoptions NO_shwordsplit chaselinks
1166             ( builtin cd -q $1 2> /dev/null && pwd; )
1167         }
1168     fi
1169 else
1170 # I'm not reindenting the whole code below.
1171 GRML_VCS_INFO=1
1172
1173 # The following code is imported from the file 'zsh/functions/vcs_info'
1174 # from <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>,
1175 # which distributed under the same terms as zsh itself.
1176
1177 # we will be using two variables, so let the code know now.
1178 zstyle ':vcs_info:*' max-exports 2
1179
1180 # vcs_info() documentation:
1181 #{{{
1182 # REQUIREMENTS:
1183 #{{{
1184 #     This functionality requires zsh version >= 4.1.*.
1185 #}}}
1186 #
1187 # LOADING:
1188 #{{{
1189 # To load vcs_info(), copy this file to your $fpath[] and do:
1190 #   % autoload -Uz vcs_info && vcs_info
1191 #
1192 # To work, vcs_info() needs 'setopt prompt_subst' in your setup.
1193 #}}}
1194 #
1195 # QUICKSTART:
1196 #{{{
1197 # To get vcs_info() working quickly (including colors), you can do the
1198 # following (assuming, you loaded vcs_info() properly - see above):
1199 #
1200 # % RED=$'%{\e[31m%}'
1201 # % GR=$'%{\e[32m%}'
1202 # % MA=$'%{\e[35m%}'
1203 # % YE=$'%{\e[33m%}'
1204 # % NC=$'%{\e[0m%}'
1205 #
1206 # % zstyle ':vcs_info:*' actionformats \
1207 #       "${MA}(${NC}%s${MA})${YE}-${MA}[${GR}%b${YE}|${RED}%a${MA}]${NC} "
1208 #
1209 # % zstyle ':vcs_info:*' formats       \
1210 #       "${MA}(${NC}%s${MA})${Y}-${MA}[${GR}%b${MA}]${NC}%} "
1211 #
1212 # % zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YE}%r"
1213 #
1214 # % precmd () { vcs_info }
1215 # % PS1='${MA}[${GR}%n${MA}] ${MA}(${RED}%!${MA}) ${YE}%3~ ${VCS_INFO_message_0_}${NC}%# '
1216 #
1217 # Obviously, the las two lines are there for demonstration: You need to
1218 # call vcs_info() from your precmd() function (see 'SPECIAL FUNCTIONS' in
1219 # 'man zshmisc'). Once that is done you need a *single* quoted
1220 # '${VCS_INFO_message_0_}' in your prompt.
1221 #
1222 # Now call the 'vcs_info_printsys' utility from the command line:
1223 #
1224 # % vcs_info_printsys
1225 # # list of supported version control backends:
1226 # # disabled systems are prefixed by a hash sign (#)
1227 # git
1228 # hg
1229 # bzr
1230 # darcs
1231 # svk
1232 # mtn
1233 # svn
1234 # cvs
1235 # cdv
1236 # tla
1237 # # flavours (cannot be used in the disable style; they
1238 # # are disabled with their master [git-svn -> git]):
1239 # git-p4
1240 # git-svn
1241 #
1242 # Ten version control backends as you can see. You may not want all
1243 # of these. Because there is no point in running the code to detect
1244 # systems you do not use. ever. So, there is a way to disable some
1245 # backends altogether:
1246 #
1247 # % zstyle ':vcs_info:*' disable bzr cdv darcs mtn svk tla
1248 #
1249 # If you rerun 'vcs_info_printsys' now, you will see the backends listed
1250 # in the 'disable' style marked as diabled by a hash sign. That means the
1251 # detection of these systems is skipped *completely*. No wasted time there.
1252 #
1253 # For more control, read the reference below.
1254 #}}}
1255 #
1256 # CONFIGURATION:
1257 #{{{
1258 # The vcs_info() feature can be configured via zstyle.
1259 #
1260 # First, the context in which we are working:
1261 #       :vcs_info:<vcs-string>:<user-context>
1262 #
1263 # ...where <vcs-string> is one of:
1264 #   - git, git-svn, git-p4, hg, darcs, bzr, cdv, mtn, svn, cvs, svk or tla.
1265 #
1266 # ...and <user-context> is a freely configurable string, assignable by the
1267 # user as the first argument to vcs_info() (see its description below).
1268 #
1269 # There is are three special values for <vcs-string>: The first is named
1270 # 'init', that is in effect as long as there was no decision what vcs
1271 # backend to use. The second is 'preinit; it is used *before* vcs_info()
1272 # is run, when initializing the data exporting variables. The third
1273 # special value is 'formats' and is used by the 'vcs_info_lastmsg' for
1274 # looking up its styles.
1275 #
1276 # There are two pre-defined values for <user-context>:
1277 #   default  - the one used if none is specified
1278 #   command  - used by vcs_info_lastmsg to lookup its styles.
1279 #
1280 # You may *not* use 'print_systems_' as a user-context string, because it
1281 # is used internally.
1282 #
1283 # You can of course use ':vcs_info:*' to match all VCSs in all
1284 # user-contexts at once.
1285 #
1286 # Another special context is 'formats', which is used by the
1287 # vcs_info_lastmsg() utility function (see below).
1288 #
1289 #
1290 # This is a description of all styles, that are looked up:
1291 #   formats             - A list of formats, used when actionformats is not
1292 #                         used (which is most of the time).
1293 #   actionformats       - A list of formats, used if a there is a special
1294 #                         action going on in your current repository;
1295 #                         (like an interactive rebase or a merge conflict)
1296 #   branchformat        - Some backends replace %b in the formats and
1297 #                         actionformats styles above, not only by a branch
1298 #                         name but also by a revision number. This style
1299 #                         let's you modify how that string should look like.
1300 #   nvcsformats         - These "formats" are exported, when we didn't detect
1301 #                         a version control system for the current directory.
1302 #                         This is useful, if you want vcs_info() to completely
1303 #                         take over the generation of your prompt.
1304 #                         You would do something like
1305 #                           PS1='${VCS_INFO_message_0_}'
1306 #                         to accomplish that.
1307 #   max-exports         - Defines the maximum number if VCS_INFO_message_*_
1308 #                         variables vcs_info() will export.
1309 #   enable              - Checked in the 'init' context. If set to false,
1310 #                         vcs_info() will do nothing.
1311 #   disable             - Provide a list of systems, you don't want
1312 #                         the vcs_info() to check for repositories
1313 #                         (checked in the 'init' context, too).
1314 #   disable-patterns    - A list of patterns that are checked against $PWD.
1315 #                         If the pattern matches, vcs_info will be disabled.
1316 #                         Say, ~/.zsh is a directory under version control,
1317 #                         in which you do not want vcs_info to be active, do:
1318 #                         zstyle ':vcs_info:*' disable-patterns "$HOME/.zsh+(|/*)"
1319 #   use-simple          - If there are two different ways of gathering
1320 #                         information, you can select the simpler one
1321 #                         by setting this style to true; the default
1322 #                         is to use the not-that-simple code, which is
1323 #                         potentially a lot slower but might be more
1324 #                         accurate in all possible cases.
1325 #   use-prompt-escapes  - determines if we assume that the assembled
1326 #                         string from vcs_info() includes prompt escapes.
1327 #                         (Used by vcs_info_lastmsg().
1328 #
1329 # The use-simple style is only available for the bzr backend.
1330 #
1331 # The default values for these in all contexts are:
1332 #   formats             " (%s)-[%b|%a]-"
1333 #   actionformats       " (%s)-[%b]-"
1334 #   branchformat        "%b:%r" (for bzr, svn and svk)
1335 #   nvcsformats         ""
1336 #   max-exports         2
1337 #   enable              true
1338 #   disable             (empty list)
1339 #   disable-patterns    (empty list)
1340 #   use-simple          false
1341 #   use-prompt-escapes  true
1342 #
1343 #
1344 # In normal formats and actionformats, the following replacements
1345 # are done:
1346 #   %s  - The vcs in use (git, hg, svn etc.)
1347 #   %b  - Information about the current branch.
1348 #   %a  - An identifier, that describes the action.
1349 #         Only makes sense in actionformats.
1350 #   %R  - base directory of the repository.
1351 #   %r  - repository name
1352 #         If %R is '/foo/bar/repoXY', %r is 'repoXY'.
1353 #   %S  - subdirectory within a repository. if $PWD is
1354 #         '/foo/bar/reposXY/beer/tasty', %S is 'beer/tasty'.
1355 #
1356 #
1357 # In branchformat these replacements are done:
1358 #   %b  - the branch name
1359 #   %r  - the current revision number
1360 #
1361 # Not all vcs backends have to support all replacements.
1362 # nvcsformat does not perform *any* replacements. It is just a string.
1363 #}}}
1364 #
1365 # ODDITIES:
1366 #{{{
1367 # If you want to use the %b (bold off) prompt expansion in 'formats', which
1368 # expands %b itself, use %%b. That will cause the vcs_info() expansion to
1369 # replace %%b with %b. So zsh's prompt expansion mechanism can handle it.
1370 # Similarly, to hand down %b from branchformat, use %%%%b. Sorry for this
1371 # inconvenience, but it cannot be easily avoided. Luckily we do not clash
1372 # with a lot of prompt expansions and this only needs to be done for those.
1373 # See 'man zshmisc' for details about EXPANSION OF PROMPT SEQUENCES.
1374 #}}}
1375 #
1376 # FUNCTION DESCRIPTIONS (public API):
1377 #{{{
1378 #   vcs_info()
1379 #       The main function, that runs all backends and assembles
1380 #       all data into ${VCS_INFO_message_*_}. This is the function
1381 #       you want to call from precmd() if you want to include
1382 #       up-to-date information in your prompt (see VARIABLE
1383 #       DESCRIPTION below).
1384 #
1385 #   vcs_info_printsys()
1386 #       Prints a list of all supported version control systems.
1387 #       Useful to find out possible contexts (and which of them are enabled)
1388 #       or values for the 'disable' style.
1389 #
1390 #   vcs_info_lastmsg()
1391 #       Outputs the last ${VCS_INFO_message_*_} value. Takes into account
1392 #       the value of the use-prompt-escapes style in ':vcs_info:formats'.
1393 #       It also only prints max-exports values.
1394 #
1395 # All functions named VCS_INFO_* are for internal use only.
1396 #}}}
1397 #
1398 # VARIABLE DESCRIPTION:
1399 #{{{
1400 #   ${VCS_INFO_message_N_}    (Note the trailing underscore)
1401 #       Where 'N' is an integer, eg: VCS_INFO_message_0_
1402 #       These variables are the storage for the informational message the
1403 #       last vcs_info() call has assembled. These are strongly connected
1404 #       to the formats, actionformats and nvcsformats styles described
1405 #       above. Those styles are lists. the first member of that list gets
1406 #       expanded into ${VCS_INFO_message_0_}, the second into
1407 #       ${VCS_INFO_message_1_} and the Nth into ${VCS_INFO_message_N-1_}.
1408 #       These parameters are exported into the environment.
1409 #       (See the max-exports style above.)
1410 #}}}
1411 #
1412 # EXAMPLES:
1413 #{{{
1414 #   Don't use vcs_info at all (even though it's in your prompt):
1415 #   % zstyle ':vcs_info:*' enable false
1416 #
1417 #   Disable the backends for bzr and svk:
1418 #   % zstyle ':vcs_info:*' disable bzr svk
1419 #
1420 #   Provide a special formats for git:
1421 #   % zstyle ':vcs_info:git:*' formats       ' GIT, BABY! [%b]'
1422 #   % zstyle ':vcs_info:git:*' actionformats ' GIT ACTION! [%b|%a]'
1423 #
1424 #   Use the quicker bzr backend (if you do, please report if it does
1425 #   the-right-thing[tm] - thanks):
1426 #   % zstyle ':vcs_info:bzr:*' use-simple true
1427 #
1428 #   Display the revision number in yellow for bzr and svn:
1429 #   % zstyle ':vcs_info:(svn|bzr):*' branchformat '%b%{'${fg[yellow]}'%}:%r'
1430 #
1431 # If you want colors, make sure you enclose the color codes in %{...%},
1432 # if you want to use the string provided by vcs_info() in prompts.
1433 #
1434 # Here is how to print the vcs infomation as a command:
1435 #   % alias vcsi='vcs_info command; vcs_info_lastmsg'
1436 #
1437 #   This way, you can even define different formats for output via
1438 #   vcs_info_lastmsg() in the ':vcs_info:command:*' namespace.
1439 #}}}
1440 #}}}
1441 # utilities
1442 VCS_INFO_adjust () { #{{{
1443     [[ -n ${vcs_comm[overwrite_name]} ]] && vcs=${vcs_comm[overwrite_name]}
1444     return 0
1445 }
1446 # }}}
1447 VCS_INFO_check_com () { #{{{
1448     (( ${+commands[$1]} )) && [[ -x ${commands[$1]} ]] && return 0
1449     return 1
1450 }
1451 # }}}
1452 VCS_INFO_formats () { # {{{
1453     setopt localoptions noksharrays
1454     local action=$1 branch=$2 base=$3
1455     local msg
1456     local -i i
1457
1458     if [[ -n ${action} ]] ; then
1459         zstyle -a ":vcs_info:${vcs}:${usercontext}" actionformats msgs
1460         (( ${#msgs} < 1 )) && msgs[1]=' (%s)-[%b|%a]-'
1461     else
1462         zstyle -a ":vcs_info:${vcs}:${usercontext}" formats msgs
1463         (( ${#msgs} < 1 )) && msgs[1]=' (%s)-[%b]-'
1464     fi
1465
1466     (( ${#msgs} > maxexports )) && msgs[$(( maxexports + 1 )),-1]=()
1467     for i in {1..${#msgs}} ; do
1468         zformat -f msg ${msgs[$i]}                      \
1469                         a:${action}                     \
1470                         b:${branch}                     \
1471                         r:${base:t}                     \
1472                         s:${vcs}                        \
1473                         R:${base}                       \
1474                         S:"$(VCS_INFO_reposub ${base})"
1475         msgs[$i]=${msg}
1476     done
1477     return 0
1478 }
1479 # }}}
1480 VCS_INFO_maxexports () { #{{{
1481     zstyle -s ":vcs_info:${vcs}:${usercontext}" "max-exports" maxexports || maxexports=2
1482     if [[ ${maxexports} != <-> ]] || (( maxexports < 1 )); then
1483         printf 'vcs_info(): expecting numeric arg >= 1 for max-exports (got %s).\n' ${maxexports}
1484         printf 'Defaulting to 2.\n'
1485         maxexports=2
1486     fi
1487 }
1488 # }}}
1489 VCS_INFO_nvcsformats () { #{{{
1490     setopt localoptions noksharrays
1491     local c v
1492
1493     if [[ $1 == 'preinit' ]] ; then
1494         c=default
1495         v=preinit
1496     fi
1497     zstyle -a ":vcs_info:${v:-$vcs}:${c:-$usercontext}" nvcsformats msgs
1498     (( ${#msgs} > maxexports )) && msgs[${maxexports},-1]=()
1499 }
1500 # }}}
1501 VCS_INFO_realpath () { #{{{
1502     # a portable 'readlink -f'
1503     # forcing a subshell, to ensure chpwd() is not removed
1504     # from the calling shell (if VCS_INFO_realpath() is called
1505     # manually).
1506     (
1507         (( ${+functions[chpwd]} )) && unfunction chpwd
1508         setopt chaselinks
1509         cd $1 2>/dev/null && pwd
1510     )
1511 }
1512 # }}}
1513 VCS_INFO_reposub () { #{{{
1514     setopt localoptions extendedglob
1515     local base=${1%%/##}
1516
1517     [[ ${PWD} == ${base}/* ]] || {
1518         printf '.'
1519         return 1
1520     }
1521     printf '%s' ${PWD#$base/}
1522     return 0
1523 }
1524 # }}}
1525 VCS_INFO_set () { #{{{
1526     setopt localoptions noksharrays
1527     local -i i j
1528
1529     if [[ $1 == '--clear' ]] ; then
1530         for i in {0..9} ; do
1531             unset VCS_INFO_message_${i}_
1532         done
1533     fi
1534     if [[ $1 == '--nvcs' ]] ; then
1535         [[ $2 == 'preinit' ]] && (( maxexports == 0 )) && (( maxexports = 1 ))
1536         for i in {0..$((maxexports - 1))} ; do
1537             typeset -gx VCS_INFO_message_${i}_=
1538         done
1539         VCS_INFO_nvcsformats $2
1540     fi
1541
1542     (( ${#msgs} - 1 < 0 )) && return 0
1543     for i in {0..$(( ${#msgs} - 1 ))} ; do
1544         (( j = i + 1 ))
1545         typeset -gx VCS_INFO_message_${i}_=${msgs[$j]}
1546     done
1547     return 0
1548 }
1549 # }}}
1550 # information gathering
1551 VCS_INFO_bzr_get_data () { # {{{
1552     setopt localoptions noksharrays
1553     local bzrbase bzrbr
1554     local -a bzrinfo
1555
1556     if zstyle -t ":vcs_info:${vcs}:${usercontext}" "use-simple" ; then
1557         bzrbase=${vcs_comm[basedir]}
1558         bzrinfo[2]=${bzrbase:t}
1559         if [[ -f ${bzrbase}/.bzr/branch/last-revision ]] ; then
1560             bzrinfo[1]=$(< ${bzrbase}/.bzr/branch/last-revision)
1561             bzrinfo[1]=${${bzrinfo[1]}%% *}
1562         fi
1563     else
1564         bzrbase=${${(M)${(f)"$( bzr info )"}:# ##branch\ root:*}/*: ##/}
1565         bzrinfo=( ${${${(M)${(f)"$( bzr version-info )"}:#(#s)(revno|branch-nick)*}/*: /}/*\//} )
1566         bzrbase="$(VCS_INFO_realpath ${bzrbase})"
1567     fi
1568
1569     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat bzrbr || bzrbr="%b:%r"
1570     zformat -f bzrbr "${bzrbr}" "b:${bzrinfo[2]}" "r:${bzrinfo[1]}"
1571     VCS_INFO_formats '' "${bzrbr}" "${bzrbase}"
1572     return 0
1573 }
1574 # }}}
1575 VCS_INFO_cdv_get_data () { # {{{
1576     local cdvbase
1577
1578     cdvbase=${vcs_comm[basedir]}
1579     VCS_INFO_formats '' "${cdvbase:t}" "${cdvbase}"
1580     return 0
1581 }
1582 # }}}
1583 VCS_INFO_cvs_get_data () { # {{{
1584     local cvsbranch cvsbase basename
1585
1586     cvsbase="."
1587     while [[ -d "${cvsbase}/../CVS" ]]; do
1588         cvsbase="${cvsbase}/.."
1589     done
1590     cvsbase="$(VCS_INFO_realpath ${cvsbase})"
1591     cvsbranch=$(< ./CVS/Repository)
1592     basename=${cvsbase:t}
1593     cvsbranch=${cvsbranch##${basename}/}
1594     [[ -z ${cvsbranch} ]] && cvsbranch=${basename}
1595     VCS_INFO_formats '' "${cvsbranch}" "${cvsbase}"
1596     return 0
1597 }
1598 # }}}
1599 VCS_INFO_darcs_get_data () { # {{{
1600     local darcsbase
1601
1602     darcsbase=${vcs_comm[basedir]}
1603     VCS_INFO_formats '' "${darcsbase:t}" "${darcsbase}"
1604     return 0
1605 }
1606 # }}}
1607 VCS_INFO_git_getaction () { #{{{
1608     local gitaction='' gitdir=$1
1609     local tmp
1610
1611     for tmp in "${gitdir}/rebase-apply" \
1612                "${gitdir}/rebase"       \
1613                "${gitdir}/../.dotest" ; do
1614         if [[ -d ${tmp} ]] ; then
1615             if   [[ -f "${tmp}/rebasing" ]] ; then
1616                 gitaction="rebase"
1617             elif [[ -f "${tmp}/applying" ]] ; then
1618                 gitaction="am"
1619             else
1620                 gitaction="am/rebase"
1621             fi
1622             printf '%s' ${gitaction}
1623             return 0
1624         fi
1625     done
1626
1627     for tmp in "${gitdir}/rebase-merge/interactive" \
1628                "${gitdir}/.dotest-merge/interactive" ; do
1629         if [[ -f "${tmp}" ]] ; then
1630             printf '%s' "rebase-i"
1631             return 0
1632         fi
1633     done
1634
1635     for tmp in "${gitdir}/rebase-merge" \
1636                "${gitdir}/.dotest-merge" ; do
1637         if [[ -d "${tmp}" ]] ; then
1638             printf '%s' "rebase-m"
1639             return 0
1640         fi
1641     done
1642
1643     if [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
1644         printf '%s' "merge"
1645         return 0
1646     fi
1647
1648     if [[ -f "${gitdir}/BISECT_LOG" ]] ; then
1649         printf '%s' "bisect"
1650         return 0
1651     fi
1652     return 1
1653 }
1654 # }}}
1655 VCS_INFO_git_getbranch () { #{{{
1656     local gitbranch gitdir=$1 tmp actiondir
1657     local gitsymref='git symbolic-ref HEAD'
1658
1659     actiondir=''
1660     for tmp in "${gitdir}/rebase-apply" \
1661                "${gitdir}/rebase"       \
1662                "${gitdir}/../.dotest"; do
1663         if [[ -d ${tmp} ]]; then
1664             actiondir=${tmp}
1665             break
1666         fi
1667     done
1668     if [[ -n ${actiondir} ]]; then
1669         gitbranch="$(${(z)gitsymref} 2> /dev/null)"
1670         [[ -z ${gitbranch} ]] && [[ -r ${actiondir}/head-name ]] \
1671             && gitbranch="$(< ${actiondir}/head-name)"
1672
1673     elif [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
1674         gitbranch="$(${(z)gitsymref} 2> /dev/null)"
1675         [[ -z ${gitbranch} ]] && gitbranch="$(< ${gitdir}/MERGE_HEAD)"
1676
1677     elif [[ -d "${gitdir}/rebase-merge" ]] ; then
1678         gitbranch="$(< ${gitdir}/rebase-merge/head-name)"
1679
1680     elif [[ -d "${gitdir}/.dotest-merge" ]] ; then
1681         gitbranch="$(< ${gitdir}/.dotest-merge/head-name)"
1682
1683     else
1684         gitbranch="$(${(z)gitsymref} 2> /dev/null)"
1685
1686         if [[ $? -ne 0 ]] ; then
1687             gitbranch="refs/tags/$(git describe --exact-match HEAD 2>/dev/null)"
1688
1689             if [[ $? -ne 0 ]] ; then
1690                 gitbranch="${${"$(< $gitdir/HEAD)"}[1,7]}..."
1691             fi
1692         fi
1693     fi
1694
1695     printf '%s' "${gitbranch##refs/[^/]##/}"
1696     return 0
1697 }
1698 # }}}
1699 VCS_INFO_git_get_data () { # {{{
1700     setopt localoptions extendedglob
1701     local gitdir gitbase gitbranch gitaction
1702
1703     gitdir=${vcs_comm[gitdir]}
1704     gitbranch="$(VCS_INFO_git_getbranch ${gitdir})"
1705
1706     if [[ -z ${gitdir} ]] || [[ -z ${gitbranch} ]] ; then
1707         return 1
1708     fi
1709
1710     VCS_INFO_adjust
1711     gitaction="$(VCS_INFO_git_getaction ${gitdir})"
1712     gitbase=${PWD%/${$( git rev-parse --show-prefix )%/##}}
1713     VCS_INFO_formats "${gitaction}" "${gitbranch}" "${gitbase}"
1714     return 0
1715 }
1716 # }}}
1717 VCS_INFO_hg_get_data () { # {{{
1718     local hgbranch hgbase file
1719
1720     hgbase=${vcs_comm[basedir]}
1721
1722     file="${hgbase}/.hg/branch"
1723     if [[ -r ${file} ]] ; then
1724         hgbranch=$(< ${file})
1725     else
1726         hgbranch='default'
1727     fi
1728
1729     VCS_INFO_formats '' "${hgbranch}" "${hgbase}"
1730     return 0
1731 }
1732 # }}}
1733 VCS_INFO_mtn_get_data () { # {{{
1734     local mtnbranch mtnbase
1735
1736     mtnbase=${vcs_comm[basedir]}
1737     mtnbranch=${${(M)${(f)"$( mtn status )"}:#(#s)Current branch:*}/*: /}
1738     VCS_INFO_formats '' "${mtnbranch}" "${mtnbase}"
1739     return 0
1740 }
1741 # }}}
1742 VCS_INFO_svk_get_data () { # {{{
1743     local svkbranch svkbase
1744
1745     svkbase=${vcs_comm[basedir]}
1746     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat svkbranch || svkbranch="%b:%r"
1747     zformat -f svkbranch "${svkbranch}" "b:${vcs_comm[branch]}" "r:${vcs_comm[revision]}"
1748     VCS_INFO_formats '' "${svkbranch}" "${svkbase}"
1749     return 0
1750 }
1751 # }}}
1752 VCS_INFO_svn_get_data () { # {{{
1753     setopt localoptions noksharrays
1754     local svnbase svnbranch
1755     local -a svninfo
1756
1757     svnbase="."
1758     while [[ -d "${svnbase}/../.svn" ]]; do
1759         svnbase="${svnbase}/.."
1760     done
1761     svnbase="$(VCS_INFO_realpath ${svnbase})"
1762     svninfo=( ${${${(M)${(f)"$( svn info )"}:#(#s)(URL|Revision)*}/*: /}/*\//} )
1763
1764     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat svnbranch || svnbranch="%b:%r"
1765     zformat -f svnbranch "${svnbranch}" "b:${svninfo[1]}" "r:${svninfo[2]}"
1766     VCS_INFO_formats '' "${svnbranch}" "${svnbase}"
1767     return 0
1768 }
1769 # }}}
1770 VCS_INFO_tla_get_data () { # {{{
1771     local tlabase tlabranch
1772
1773     tlabase="$(VCS_INFO_realpath ${vcs_comm[basedir]})"
1774     # tree-id gives us something like 'foo@example.com/demo--1.0--patch-4', so:
1775     tlabranch=${${"$( tla tree-id )"}/*\//}
1776     VCS_INFO_formats '' "${tlabranch}" "${tlabase}"
1777     return 0
1778 }
1779 # }}}
1780 # detection
1781 VCS_INFO_detect_by_dir() { #{{{
1782     local dirname=$1
1783     local basedir="." realbasedir
1784
1785     realbasedir="$(VCS_INFO_realpath ${basedir})"
1786     while [[ ${realbasedir} != '/' ]]; do
1787         [[ -r ${realbasedir} ]] || return 1
1788         if [[ -n ${vcs_comm[detect_need_file]} ]] ; then
1789             [[ -d ${basedir}/${dirname} ]] && \
1790             [[ -e ${basedir}/${dirname}/${vcs_comm[detect_need_file]} ]] && \
1791                 break
1792         else
1793             [[ -d ${basedir}/${dirname} ]] && break
1794         fi
1795
1796         basedir=${basedir}/..
1797         realbasedir="$(VCS_INFO_realpath ${basedir})"
1798     done
1799
1800     [[ ${realbasedir} == "/" ]] && return 1
1801     vcs_comm[basedir]=${realbasedir}
1802     return 0
1803 }
1804 # }}}
1805 VCS_INFO_bzr_detect() { #{{{
1806     VCS_INFO_check_com bzr || return 1
1807     vcs_comm[detect_need_file]=branch/format
1808     VCS_INFO_detect_by_dir '.bzr'
1809     return $?
1810 }
1811 # }}}
1812 VCS_INFO_cdv_detect() { #{{{
1813     VCS_INFO_check_com cdv || return 1
1814     vcs_comm[detect_need_file]=format
1815     VCS_INFO_detect_by_dir '.cdv'
1816     return $?
1817 }
1818 # }}}
1819 VCS_INFO_cvs_detect() { #{{{
1820     VCS_INFO_check_com cvs || return 1
1821     [[ -d "./CVS" ]] && [[ -r "./CVS/Repository" ]] && return 0
1822     return 1
1823 }
1824 # }}}
1825 VCS_INFO_darcs_detect() { #{{{
1826     VCS_INFO_check_com darcs || return 1
1827     vcs_comm[detect_need_file]=format
1828     VCS_INFO_detect_by_dir '_darcs'
1829     return $?
1830 }
1831 # }}}
1832 VCS_INFO_git_detect() { #{{{
1833     if VCS_INFO_check_com git && git rev-parse --is-inside-work-tree &> /dev/null ; then
1834         vcs_comm[gitdir]="$(git rev-parse --git-dir 2> /dev/null)" || return 1
1835         if   [[ -d ${vcs_comm[gitdir]}/svn ]]             ; then vcs_comm[overwrite_name]='git-svn'
1836         elif [[ -d ${vcs_comm[gitdir]}/refs/remotes/p4 ]] ; then vcs_comm[overwrite_name]='git-p4' ; fi
1837         return 0
1838     fi
1839     return 1
1840 }
1841 # }}}
1842 VCS_INFO_hg_detect() { #{{{
1843     VCS_INFO_check_com hg || return 1
1844     vcs_comm[detect_need_file]=store
1845     VCS_INFO_detect_by_dir '.hg'
1846     return $?
1847 }
1848 # }}}
1849 VCS_INFO_mtn_detect() { #{{{
1850     VCS_INFO_check_com mtn || return 1
1851     vcs_comm[detect_need_file]=revision
1852     VCS_INFO_detect_by_dir '_MTN'
1853     return $?
1854 }
1855 # }}}
1856 VCS_INFO_svk_detect() { #{{{
1857     setopt localoptions noksharrays extendedglob
1858     local -a info
1859     local -i fhash
1860     fhash=0
1861
1862     VCS_INFO_check_com svk || return 1
1863     [[ -f ~/.svk/config ]] || return 1
1864
1865     # This detection function is a bit different from the others.
1866     # We need to read svk's config file to detect a svk repository
1867     # in the first place. Therefore, we'll just proceed and read
1868     # the other information, too. This is more then any of the
1869     # other detections do but this takes only one file open for
1870     # svk at most. VCS_INFO_svk_get_data() get simpler, too. :-)
1871     while IFS= read -r line ; do
1872         if [[ -n ${vcs_comm[basedir]} ]] ; then
1873             line=${line## ##}
1874             [[ ${line} == depotpath:* ]] && vcs_comm[branch]=${line##*/}
1875             [[ ${line} == revision:* ]] && vcs_comm[revision]=${line##*[[:space:]]##}
1876             [[ -n ${vcs_comm[branch]} ]] && [[ -n ${vcs_comm[revision]} ]] && break
1877             continue
1878         fi
1879         (( fhash > 0 )) && [[ ${line} == '  '[^[:space:]]*:* ]] && break
1880         [[ ${line} == '  hash:'* ]] && fhash=1 && continue
1881         (( fhash == 0 )) && continue
1882         [[ ${PWD}/ == ${${line## ##}%:*}/* ]] && vcs_comm[basedir]=${${line## ##}%:*}
1883     done < ~/.svk/config
1884
1885     [[ -n ${vcs_comm[basedir]} ]]  && \
1886     [[ -n ${vcs_comm[branch]} ]]   && \
1887     [[ -n ${vcs_comm[revision]} ]] && return 0
1888     return 1
1889 }
1890 # }}}
1891 VCS_INFO_svn_detect() { #{{{
1892     VCS_INFO_check_com svn || return 1
1893     [[ -d ".svn" ]] && return 0
1894     return 1
1895 }
1896 # }}}
1897 VCS_INFO_tla_detect() { #{{{
1898     VCS_INFO_check_com tla || return 1
1899     vcs_comm[basedir]="$(tla tree-root 2> /dev/null)" && return 0
1900     return 1
1901 }
1902 # }}}
1903 # public API
1904 vcs_info_printsys () { # {{{
1905     vcs_info print_systems_
1906 }
1907 # }}}
1908 vcs_info_lastmsg () { # {{{
1909     emulate -L zsh
1910     local -i i
1911
1912     VCS_INFO_maxexports
1913     for i in {0..$((maxexports - 1))} ; do
1914         printf '$VCS_INFO_message_%d_: "' $i
1915         if zstyle -T ':vcs_info:formats:command' use-prompt-escapes ; then
1916             print -nP ${(P)${:-VCS_INFO_message_${i}_}}
1917         else
1918             print -n ${(P)${:-VCS_INFO_message_${i}_}}
1919         fi
1920         printf '"\n'
1921     done
1922 }
1923 # }}}
1924 vcs_info () { # {{{
1925     emulate -L zsh
1926     setopt extendedglob
1927
1928     [[ -r . ]] || return 1
1929
1930     local pat
1931     local -i found
1932     local -a VCSs disabled dps
1933     local -x vcs usercontext
1934     local -ix maxexports
1935     local -ax msgs
1936     local -Ax vcs_comm
1937
1938     vcs="init"
1939     VCSs=(git hg bzr darcs svk mtn svn cvs cdv tla)
1940     case $1 in
1941         (print_systems_)
1942             zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable" disabled
1943             print -l '# list of supported version control backends:' \
1944                      '# disabled systems are prefixed by a hash sign (#)'
1945             for vcs in ${VCSs} ; do
1946                 [[ -n ${(M)disabled:#${vcs}} ]] && printf '#'
1947                 printf '%s\n' ${vcs}
1948             done
1949             print -l '# flavours (cannot be used in the disable style; they' \
1950                      '# are disabled with their master [git-svn -> git]):'   \
1951                      git-{p4,svn}
1952             return 0
1953             ;;
1954         ('')
1955             [[ -z ${usercontext} ]] && usercontext=default
1956             ;;
1957         (*) [[ -z ${usercontext} ]] && usercontext=$1
1958             ;;
1959     esac
1960
1961     zstyle -T ":vcs_info:${vcs}:${usercontext}" "enable" || {
1962         [[ -n ${VCS_INFO_message_0_} ]] && VCS_INFO_set --clear
1963         return 0
1964     }
1965     zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable" disabled
1966
1967     zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable-patterns" dps
1968     for pat in ${dps} ; do
1969         if [[ ${PWD} == ${~pat} ]] ; then
1970             [[ -n ${vcs_info_msg_0_} ]] && VCS_INFO_set --clear
1971             return 0
1972         fi
1973     done
1974
1975     VCS_INFO_maxexports
1976
1977     (( found = 0 ))
1978     for vcs in ${VCSs} ; do
1979         [[ -n ${(M)disabled:#${vcs}} ]] && continue
1980         vcs_comm=()
1981         VCS_INFO_${vcs}_detect && (( found = 1 )) && break
1982     done
1983
1984     (( found == 0 )) && {
1985         VCS_INFO_set --nvcs
1986         return 0
1987     }
1988
1989     VCS_INFO_${vcs}_get_data || {
1990         VCS_INFO_set --nvcs
1991         return 1
1992     }
1993
1994     VCS_INFO_set
1995     return 0
1996 }
1997
1998 VCS_INFO_set --nvcs preinit
1999 # }}}
2000
2001 fi
2002
2003 # Change vcs_info formats for the grml prompt. The 2nd format sets up
2004 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
2005 # TODO: The included vcs_info() version still uses $VCS_INFO_message_N_.
2006 #       That needs to be the use of $VCS_INFO_message_N_ needs to be changed
2007 #       to $vcs_info_msg_N_ as soon as we use the included version.
2008 if [[ "$TERM" == dumb ]] ; then
2009     zstyle ':vcs_info:*' actionformats "(%s%)-[%b|%a] " "zsh: %r"
2010     zstyle ':vcs_info:*' formats       "(%s%)-[%b] "    "zsh: %r"
2011 else
2012     # these are the same, just with a lot of colours:
2013     zstyle ':vcs_info:*' actionformats "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOUR} " \
2014                                        "zsh: %r"
2015     zstyle ':vcs_info:*' formats       "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOUR}%} " \
2016                                        "zsh: %r"
2017     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YELLOW}%r"
2018 fi
2019
2020 if [[ -o restricted ]]; then
2021     zstyle ':vcs_info:*' enable false
2022 fi
2023
2024 # }}}
2025
2026 # command not found handling {{{
2027
2028 (( ${COMMAND_NOT_FOUND} == 1 )) &&
2029 function command_not_found_handler() {
2030     emulate -L zsh
2031     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
2032         ${GRML_ZSH_CNF_HANDLER} $1
2033     fi
2034     return 1
2035 }
2036
2037 # }}}
2038
2039 # {{{ set prompt
2040 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2041     promptinit # people should be able to use their favourite prompt
2042 else
2043     print 'Notice: no promptinit available :('
2044 fi
2045
2046 setopt prompt_subst
2047
2048 # make sure to use right prompt only when not running a command
2049 is41 && setopt transient_rprompt
2050
2051
2052 function ESC_print () {
2053     info_print $'\ek' $'\e\\' "$@"
2054 }
2055 function set_title () {
2056     info_print  $'\e]0;' $'\a' "$@"
2057 }
2058
2059 function info_print () {
2060     local esc_begin esc_end
2061     esc_begin="$1"
2062     esc_end="$2"
2063     shift 2
2064     printf '%s' ${esc_begin}
2065     printf '%s' "$*"
2066     printf '%s' "${esc_end}"
2067 }
2068
2069 # TODO: revise all these NO* variables and especially their documentation
2070 #       in zsh-help() below.
2071 is4 && [[ $NOPRECMD -eq 0 ]] && precmd () {
2072     [[ $NOPRECMD -gt 0 ]] && return 0
2073     # update VCS information
2074     vcs_info
2075
2076     if [[ $TERM == screen* ]] ; then
2077         if [[ -n ${VCS_INFO_message_1_} ]] ; then
2078             ESC_print ${VCS_INFO_message_1_}
2079         elif [[ -n ${vcs_info_msg_1_} ]] ; then
2080             ESC_print ${vcs_info_msg_1_}
2081         else
2082             ESC_print "zsh"
2083         fi
2084     fi
2085     # just use DONTSETRPROMPT=1 to be able to overwrite RPROMPT
2086     if [[ $DONTSETRPROMPT -eq 0 ]] ; then
2087         if [[ $BATTERY -gt 0 ]] ; then
2088             # update battery (dropped into $PERCENT) information
2089             battery
2090             RPROMPT="%(?..:() ${PERCENT}"
2091         else
2092             RPROMPT="%(?..:() "
2093         fi
2094     fi
2095     # adjust title of xterm
2096     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2097     [[ ${NOTITLE} -gt 0 ]] && return 0
2098     case $TERM in
2099         (xterm*|rxvt*)
2100             set_title ${(%):-"%n@%m: %~"}
2101             ;;
2102     esac
2103 }
2104
2105 # preexec() => a function running before every command
2106 is4 && [[ $NOPRECMD -eq 0 ]] && \
2107 preexec () {
2108     [[ $NOPRECMD -gt 0 ]] && return 0
2109 # set hostname if not running on host with name 'grml'
2110     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2111        NAME="@$HOSTNAME"
2112     fi
2113 # get the name of the program currently running and hostname of local machine
2114 # set screen window title if running in a screen
2115     if [[ "$TERM" == screen* ]] ; then
2116         # local CMD=${1[(wr)^(*=*|sudo|ssh|-*)]}       # don't use hostname
2117         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME" # use hostname
2118         ESC_print ${CMD}
2119     fi
2120 # adjust title of xterm
2121     [[ ${NOTITLE} -gt 0 ]] && return 0
2122     case $TERM in
2123         (xterm*|rxvt*)
2124             set_title "${(%):-"%n@%m:"}" "$1"
2125             ;;
2126     esac
2127 }
2128
2129 EXITCODE="%(?..%?%1v )"
2130 PS2='\`%_> '      # secondary prompt, printed when the shell needs more information to complete a command.
2131 PS3='?# '         # selection prompt used within a select loop.
2132 PS4='+%N:%i:%_> ' # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
2133
2134 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
2135 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
2136     debian_chroot=$(cat /etc/debian_chroot)
2137 fi
2138
2139 # don't use colors on dumb terminals (like emacs):
2140 if [[ "$TERM" == dumb ]] ; then
2141     PROMPT="${EXITCODE}${debian_chroot:+($debian_chroot)}%n@%m %40<...<%B%~%b%<< "
2142 else
2143     # only if $GRMLPROMPT is set (e.g. via 'GRMLPROMPT=1 zsh') use the extended prompt
2144     # set variable identifying the chroot you work in (used in the prompt below)
2145     if [[ $GRMLPROMPT -gt 0 ]] ; then
2146         PROMPT="${RED}${EXITCODE}${CYAN}[%j running job(s)] ${GREEN}{history#%!} ${RED}%(3L.+.) ${BLUE}%* %D
2147 ${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
2148     else
2149         # This assembles the primary prompt string
2150         if (( EUID != 0 )); then
2151             PROMPT="${RED}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
2152         else
2153             PROMPT="${BLUE}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${RED}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
2154         fi
2155     fi
2156 fi
2157
2158 if (( GRML_VCS_INFO )); then
2159     PROMPT="${PROMPT}"'${VCS_INFO_message_0_}'"%# "
2160 else
2161     PROMPT="${PROMPT}"'${vcs_info_msg_0_}'"%# "
2162 fi
2163
2164 # if we are inside a grml-chroot set a specific prompt theme
2165 if [[ -n "$GRML_CHROOT" ]] ; then
2166     PROMPT="%{$fg[red]%}(CHROOT) %{$fg_bold[red]%}%n%{$fg_no_bold[white]%}@%m %40<...<%B%~%b%<< %\# "
2167 fi
2168 # }}}
2169
2170 # {{{ 'hash' some often used directories
2171 #d# start
2172 hash -d deb=/var/cache/apt/archives
2173 hash -d doc=/usr/share/doc
2174 hash -d linux=/lib/modules/$(command uname -r)/build/
2175 hash -d log=/var/log
2176 hash -d slog=/var/log/syslog
2177 hash -d src=/usr/src
2178 hash -d templ=/usr/share/doc/grml-templates
2179 hash -d tt=/usr/share/doc/texttools-doc
2180 hash -d www=/var/www
2181 #d# end
2182 # }}}
2183
2184 # {{{ some aliases
2185 if check_com -c screen ; then
2186     if [[ $UID -eq 0 ]] ; then
2187         [[ -r /etc/grml/screenrc ]] && alias screen="${commands[screen]} -c /etc/grml/screenrc"
2188     elif [[ -r $HOME/.screenrc ]] ; then
2189         alias screen="${commands[screen]} -c $HOME/.screenrc"
2190     else
2191         if [[ -r /etc/grml/screenrc_grml ]]; then
2192             alias screen="${commands[screen]} -c /etc/grml/screenrc_grml"
2193         else
2194             [[ -r /etc/grml/screenrc ]] && alias screen="${commands[screen]} -c /etc/grml/screenrc"
2195         fi
2196     fi
2197 fi
2198
2199 # do we have GNU ls with color-support?
2200 if ls --help 2>/dev/null | grep -- --color= >/dev/null && [[ "$TERM" != dumb ]] ; then
2201     #a1# execute \kbd{@a@}:\quad ls with colors
2202     alias ls='ls -b -CF --color=auto'
2203     #a1# execute \kbd{@a@}:\quad list all files, with colors
2204     alias la='ls -la --color=auto'
2205     #a1# long colored list, without dotfiles (@a@)
2206     alias ll='ls -l --color=auto'
2207     #a1# long colored list, human readable sizes (@a@)
2208     alias lh='ls -hAl --color=auto'
2209     #a1# List files, append qualifier to filenames \\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2210     alias l='ls -lF --color=auto'
2211 else
2212     alias ls='ls -b -CF'
2213     alias la='ls -la'
2214     alias ll='ls -l'
2215     alias lh='ls -hAl'
2216     alias l='ls -lF'
2217 fi
2218
2219 alias mdstat='cat /proc/mdstat'
2220 alias ...='cd ../../'
2221
2222 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2223 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2224     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2225 fi
2226
2227 alias cp='nocorrect cp'         # no spelling correction on cp
2228 alias mkdir='nocorrect mkdir'   # no spelling correction on mkdir
2229 alias mv='nocorrect mv'         # no spelling correction on mv
2230 alias rm='nocorrect rm'         # no spelling correction on rm
2231
2232 #a1# Execute \kbd{rmdir}
2233 alias rd='rmdir'
2234 #a1# Execute \kbd{mkdir}
2235 alias md='mkdir'
2236
2237 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2238 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2239 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2240
2241 # make sure it is not assigned yet
2242 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2243 utf2iso() {
2244     if isutfenv ; then
2245         for ENV in $(env | command grep -i '.utf') ; do
2246             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2247         done
2248     fi
2249 }
2250
2251 # make sure it is not assigned yet
2252 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2253 iso2utf() {
2254     if ! isutfenv ; then
2255         for ENV in $(env | command grep -i '\.iso') ; do
2256             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2257         done
2258     fi
2259 }
2260
2261 # set up software synthesizer via speakup
2262 swspeak() {
2263     if [ -x /usr/sbin/swspeak-setup ] ; then
2264        setopt singlelinezle
2265        unsetopt prompt_cr
2266        export PS1="%m%# "
2267        /usr/sbin/swspeak-setup $@
2268      else # old version:
2269         if ! [[ -r /dev/softsynth ]] ; then
2270             flite -o play -t "Sorry, software synthesizer not available. Did you boot with swspeak bootoption?"
2271             return 1
2272         else
2273            setopt singlelinezle
2274            unsetopt prompt_cr
2275            export PS1="%m%# "
2276             nice -n -20 speechd-up
2277             sleep 2
2278             flite -o play -t "Finished setting up software synthesizer"
2279         fi
2280      fi
2281 }
2282
2283 # I like clean prompt, so provide simple way to get that
2284 check_com 0 || alias 0='return 0'
2285
2286 # for really lazy people like mika:
2287 check_com S &>/dev/null || alias S='screen'
2288 check_com s &>/dev/null || alias s='ssh'
2289
2290 # especially for roadwarriors using GNU screen and ssh:
2291 if ! check_com asc &>/dev/null ; then
2292   asc() { autossh -t "$@" 'screen -RdU' }
2293   compdef asc=ssh
2294 fi
2295
2296 # get top 10 shell commands:
2297 alias top10='print -l ${(o)history%% *} | uniq -c | sort -nr | head -n 10'
2298
2299 # truecrypt; use e.g. via 'truec /dev/ice /mnt/ice' or 'truec -i'
2300 if check_com -c truecrypt ; then
2301     if isutfenv ; then
2302         alias truec='truecrypt --mount-options "rw,sync,dirsync,users,uid=1000,gid=users,umask=077,utf8" '
2303     else
2304         alias truec='truecrypt --mount-options "rw,sync,dirsync,users,uid=1000,gid=users,umask=077" '
2305     fi
2306 fi
2307
2308 #f1# Hints for the use of zsh on grml
2309 zsh-help() {
2310     print "$bg[white]$fg[black]
2311 zsh-help - hints for use of zsh on grml
2312 =======================================$reset_color"
2313
2314     print '
2315 Main configuration of zsh happens in /etc/zsh/zshrc.
2316 That file is part of the package grml-etc-core, if you want to
2317 use them on a non-grml-system just get the tar.gz from
2318 http://deb.grml.org/ or (preferably) get it from the git repository:
2319
2320   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2321
2322 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2323 The file is still there, but it is empty for backwards compatibility.
2324
2325 For your own changes use these two files:
2326     $HOME/.zshrc.pre
2327     $HOME/.zshrc.local
2328
2329 The former is sourced very early in our zshrc, the latter is sourced
2330 very lately.
2331
2332 System wide configuration without touching configuration files of grml
2333 can take place in /etc/zsh/zshrc.local.
2334
2335 Normally, the root user (EUID == 0) does not get the whole grml setup.
2336 If you want to force the whole setup for that user, too, set
2337 GRML_ALWAYS_LOAD_ALL=1 in .zshrc.pre in root'\''s home directory.
2338
2339 For information regarding zsh start at http://grml.org/zsh/
2340
2341 Take a look at grml'\''s zsh refcard:
2342 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2343
2344 Check out the main zsh refcard:
2345 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2346
2347 And of course visit the zsh-lovers:
2348 % man zsh-lovers
2349
2350 You can adjust some options through environment variables when
2351 invoking zsh without having to edit configuration files.
2352 Basically meant for bash users who are not used to the power of
2353 the zsh yet. :)
2354
2355   "NOCOR=1    zsh" => deactivate automatic correction
2356   "NOMENU=1   zsh" => do not use auto menu completion (note: use ctrl-d for completion instead!)
2357   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2358   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2359                       preexec() and precmd() completely
2360   "BATTERY=1  zsh" => activate battery status (via acpi) on right side of prompt
2361   "COMMAND_NOT_FOUND=1 zsh"
2362                    => Enable a handler if an external command was not found
2363                       The command called in the handler can be altered by setting
2364                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2365                       "/usr/share/command-not-found/command-not-found"
2366
2367 A value greater than 0 is enables a feature; a value equal to zero
2368 disables it. If you like one or the other of these settings, you can
2369 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2370 zshrc.'
2371
2372     print "
2373 $bg[white]$fg[black]
2374 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2375 Enjoy your grml system with the zsh!$reset_color"
2376 }
2377
2378 # debian stuff
2379 if [[ -r /etc/debian_version ]] ; then
2380     #a3# Execute \kbd{apt-cache search}
2381     alias acs='apt-cache search'
2382     #a3# Execute \kbd{apt-cache show}
2383     alias acsh='apt-cache show'
2384     #a3# Execute \kbd{apt-cache policy}
2385     alias acp='apt-cache policy'
2386     #a3# Execute \kbd{apt-get dist-upgrade}
2387     salias adg="apt-get dist-upgrade"
2388     #a3# Execute \kbd{apt-get install}
2389     salias agi="apt-get install"
2390     #a3# Execute \kbd{aptitude install}
2391     salias ati="aptitude install"
2392     #a3# Execute \kbd{apt-get upgrade}
2393     salias ag="apt-get upgrade"
2394     #a3# Execute \kbd{apt-get update}
2395     salias au="apt-get update"
2396     #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2397     salias -a up="aptitude update ; aptitude safe-upgrade"
2398     #a3# Execute \kbd{dpkg-buildpackage}
2399     alias dbp='dpkg-buildpackage'
2400     #a3# Execute \kbd{grep-excuses}
2401     alias ge='grep-excuses'
2402
2403     # debian upgrade
2404     #f3# Execute \kbd{apt-get update \&\& }\\&\quad \kbd{apt-get dist-upgrade}
2405     upgrade() {
2406         emulate -L zsh
2407         if [[ -z $1 ]] ; then
2408             $SUDO apt-get update
2409             $SUDO apt-get -u upgrade
2410         else
2411             ssh $1 $SUDO apt-get update
2412             # ask before the upgrade
2413             local dummy
2414             ssh $1 $SUDO apt-get --no-act upgrade
2415             echo -n 'Process the upgrade?'
2416             read -q dummy
2417             if [[ $dummy == "y" ]] ; then
2418                 ssh $1 $SUDO apt-get -u upgrade --yes
2419             fi
2420         fi
2421     }
2422
2423     # get a root shell as normal user in live-cd mode:
2424     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2425        alias su="sudo su"
2426      fi
2427
2428     #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog}
2429     salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2430     #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog}
2431     salias tlog="tail -f /var/log/syslog"    # follow the syslog
2432 fi
2433
2434 # sort installed Debian-packages by size
2435 if check_com -c grep-status ; then
2436     #a3# List installed Debian-packages sorted by size
2437     alias debs-by-size='grep-status -FStatus -sInstalled-Size,Package -n "install ok installed" | paste -sd "  \n" | sort -rn'
2438 fi
2439
2440 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2441 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2442     if check_com -c wodim; then
2443         cdrecord() {
2444             cat <<EOMESS
2445 cdrecord is not provided under its original name by Debian anymore.
2446 See #377109 in the BTS of Debian for more details.
2447
2448 Please use the wodim binary instead
2449 EOMESS
2450             return 1
2451         }
2452     fi
2453 fi
2454
2455 # get_tw_cli has been renamed into get_3ware
2456 if check_com -c get_3ware ; then
2457     get_tw_cli() {
2458         echo 'Warning: get_tw_cli has been renamed into get_3ware. Invoking get_3ware for you.'>&2
2459         get_3ware
2460     }
2461 fi
2462
2463 # I hate lacking backward compatibility, so provide an alternative therefore
2464 if ! check_com -c apache2-ssl-certificate ; then
2465
2466     apache2-ssl-certificate() {
2467
2468     print 'Debian does not ship apache2-ssl-certificate anymore (see #398520). :('
2469     print 'You might want to take a look at Debian the package ssl-cert as well.'
2470     print 'To generate a certificate for use with apache2 follow the instructions:'
2471
2472     echo '
2473
2474 export RANDFILE=/dev/random
2475 mkdir /etc/apache2/ssl/
2476 openssl req $@ -new -x509 -days 365 -nodes -out /etc/apache2/ssl/apache.pem -keyout /etc/apache2/ssl/apache.pem
2477 chmod 600 /etc/apache2/ssl/apache.pem
2478
2479 Run "grml-tips ssl-certificate" if you need further instructions.
2480 '
2481     }
2482 fi
2483 # }}}
2484
2485 # {{{ Use hard limits, except for a smaller stack and no core dumps
2486 unlimit
2487 is425 && limit stack 8192
2488 isgrmlcd && limit core 0 # important for a live-cd-system
2489 limit -s
2490 # }}}
2491
2492 # {{{ completion system
2493
2494 # called later (via is4 && grmlcomp)
2495 # note: use 'zstyle' for getting current settings
2496 #         press ^Xh (control-x h) for getting tags in context; ^X? (control-x ?) to run complete_debug with trace output
2497 grmlcomp() {
2498     # TODO: This could use some additional information
2499
2500     # allow one error for every three characters typed in approximate completer
2501     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
2502
2503     # don't complete backup files as executables
2504     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
2505
2506     # start menu completion only if it could find no unambiguous initial string
2507     zstyle ':completion:*:correct:*'       insert-unambiguous true
2508     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
2509     zstyle ':completion:*:correct:*'       original true
2510
2511     # activate color-completion
2512     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
2513
2514     # format on completion
2515     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
2516
2517     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
2518     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
2519
2520     # insert all expansions for expand completer
2521     zstyle ':completion:*:expand:*'        tag-order all-expansions
2522     zstyle ':completion:*:history-words'   list false
2523
2524     # activate menu
2525     zstyle ':completion:*:history-words'   menu yes
2526
2527     # ignore duplicate entries
2528     zstyle ':completion:*:history-words'   remove-all-dups yes
2529     zstyle ':completion:*:history-words'   stop yes
2530
2531     # match uppercase from lowercase
2532     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
2533
2534     # separate matches into groups
2535     zstyle ':completion:*:matches'         group 'yes'
2536     zstyle ':completion:*'                 group-name ''
2537
2538     if [[ "$NOMENU" -eq 0 ]] ; then
2539         # if there are more than 5 options allow selecting from a menu
2540         zstyle ':completion:*'               menu select=5
2541     else
2542         # don't use any menus at all
2543         setopt no_auto_menu
2544     fi
2545
2546     zstyle ':completion:*:messages'        format '%d'
2547     zstyle ':completion:*:options'         auto-description '%d'
2548
2549     # describe options in full
2550     zstyle ':completion:*:options'         description 'yes'
2551
2552     # on processes completion complete all user processes
2553     zstyle ':completion:*:processes'       command 'ps -au$USER'
2554
2555     # offer indexes before parameters in subscripts
2556     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
2557
2558     # provide verbose completion information
2559     zstyle ':completion:*'                 verbose true
2560
2561     # recent (as of Dec 2007) zsh versions are able to provide descriptions
2562     # for commands (read: 1st word in the line) that it will list for the user
2563     # to choose from. The following disables that, because it's not exactly fast.
2564     zstyle ':completion:*:-command-:*:'    verbose false
2565
2566     # set format for warnings
2567     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
2568
2569     # define files to ignore for zcompile
2570     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
2571     zstyle ':completion:correct:'          prompt 'correct to: %e'
2572
2573     # Ignore completion functions for commands you don't have:
2574     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
2575
2576     # Provide more processes in completion of programs like killall:
2577     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
2578
2579     # complete manual by their section
2580     zstyle ':completion:*:manuals'    separate-sections true
2581     zstyle ':completion:*:manuals.*'  insert-sections   true
2582     zstyle ':completion:*:man:*'      menu yes select
2583
2584     # provide .. as a completion
2585     zstyle ':completion:*' special-dirs ..
2586
2587     # run rehash on completion so new installed program are found automatically:
2588     _force_rehash() {
2589         (( CURRENT == 1 )) && rehash
2590         return 1
2591     }
2592
2593     ## correction
2594     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
2595     if [[ "$NOCOR" -gt 0 ]] ; then
2596         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
2597         setopt nocorrect
2598     else
2599         # try to be smart about when to use what completer...
2600         setopt correct
2601         zstyle -e ':completion:*' completer '
2602             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
2603                 _last_try="$HISTNO$BUFFER$CURSOR"
2604                 reply=(_complete _match _ignored _prefix _files)
2605             else
2606                 if [[ $words[1] == (rm|mv) ]] ; then
2607                     reply=(_complete _files)
2608                 else
2609                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
2610                 fi
2611             fi'
2612     fi
2613
2614     # command for process lists, the local web server details and host completion
2615     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
2616
2617     # caching
2618     [[ -d $ZSHDIR/cache ]] && zstyle ':completion:*' use-cache yes && \
2619                             zstyle ':completion::complete:*' cache-path $ZSHDIR/cache/
2620
2621     # host completion /* add brackets as vim can't parse zsh's complex cmdlines 8-) {{{ */
2622     if is42 ; then
2623         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
2624         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
2625     else
2626         _ssh_hosts=()
2627         _etc_hosts=()
2628     fi
2629     hosts=(
2630         $(hostname)
2631         "$_ssh_hosts[@]"
2632         "$_etc_hosts[@]"
2633         grml.org
2634         localhost
2635     )
2636     zstyle ':completion:*:hosts' hosts $hosts
2637     # TODO: so, why is this here?
2638     #  zstyle '*' hosts $hosts
2639
2640     # use generic completion system for programs not yet defined; (_gnu_generic works
2641     # with commands that provide a --help option with "standard" gnu-like output.)
2642     for compcom in cp deborphan df feh fetchipac head hnb ipacsum mv \
2643                    pal stow tail uname ; do
2644         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
2645     done; unset compcom
2646
2647     # see upgrade function in this file
2648     compdef _hosts upgrade
2649 }
2650 # }}}
2651
2652 # {{{ grmlstuff
2653 grmlstuff() {
2654 # people should use 'grml-x'!
2655     if check_com -c 915resolution; then
2656         855resolution() {
2657             echo "Please use 915resolution as resolution modifying tool for Intel \
2658 graphic chipset."
2659             return -1
2660         }
2661     fi
2662
2663     #a1# Output version of running grml
2664     alias grml-version='cat /etc/grml_version'
2665
2666     if check_com -c rebuildfstab ; then
2667         #a1# Rebuild /etc/fstab
2668         alias grml-rebuildfstab='rebuildfstab -v -r -config'
2669     fi
2670
2671     if check_com -c grml-debootstrap ; then
2672         debian2hd() {
2673             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2674             return 1
2675         }
2676     fi
2677 }
2678 # }}}
2679
2680 # {{{ now run the functions
2681 isgrml && checkhome
2682 is4    && isgrml    && grmlstuff
2683 is4    && grmlcomp
2684 # }}}
2685
2686 # {{{ keephack
2687 is4 && xsource "/etc/zsh/keephack"
2688 # }}}
2689
2690 # {{{ wonderful idea of using "e" glob qualifier by Peter Stephenson
2691 # You use it as follows:
2692 # $ NTREF=/reference/file
2693 # $ ls -l *(e:nt:)
2694 # This lists all the files in the current directory newer than the reference file.
2695 # You can also specify the reference file inline; note quotes:
2696 # $ ls -l *(e:'nt ~/.zshenv':)
2697 is4 && nt() {
2698     if [[ -n $1 ]] ; then
2699         local NTREF=${~1}
2700     fi
2701     [[ $REPLY -nt $NTREF ]]
2702 }
2703 # }}}
2704
2705 # shell functions {{{
2706
2707 #f1# Provide csh compatibility
2708 setenv()  { typeset -x "${1}${1:+=}${(@)argv[2,$#]}" }  # csh compatibility
2709
2710 #f1# Reload an autoloadable function
2711 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2712 compdef _functions freload
2713
2714 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
2715 sll() {
2716     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
2717     for file in "$@" ; do
2718         while [[ -h "$file" ]] ; do
2719             ls -l $file
2720             file=$(readlink "$file")
2721         done
2722     done
2723 }
2724
2725 # fast manual access
2726 if check_com qma ; then
2727     #f1# View the zsh manual
2728     manzsh()  { qma zshall "$1" }
2729     compdef _man qma
2730 else
2731     manzsh()  { /usr/bin/man zshall |  vim -c "se ft=man| se hlsearch" +/"$1" - ; }
2732 fi
2733
2734 # TODO: Is it supported to use pager settings like this?
2735 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2736 # with respect to wordsplitting. (ie. ${=PAGER})
2737 if check_com -c $PAGER ; then
2738     #f1# View Debian's changelog of a given package
2739     dchange() {
2740         emulate -L zsh
2741         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
2742             $PAGER /usr/share/doc/$1/changelog.Debian.gz
2743         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2744             $PAGER /usr/share/doc/$1/changelog.gz
2745         else
2746             if check_com -c aptitude ; then
2747                 echo "No changelog for package $1 found, using aptitude to retrieve it."
2748                 if isgrml ; then
2749                     aptitude -t unstable changelog $1
2750                 else
2751                     aptitude changelog $1
2752                 fi
2753             else
2754                 echo "No changelog for package $1 found, sorry."
2755                 return 1
2756             fi
2757         fi
2758     }
2759     _dchange() { _files -W /usr/share/doc -/ }
2760     compdef _dchange dchange
2761
2762     #f1# View Debian's NEWS of a given package
2763     dnews() {
2764         emulate -L zsh
2765         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2766             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2767         else
2768             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2769                 $PAGER /usr/share/doc/$1/NEWS.gz
2770             else
2771                 echo "No NEWS file for package $1 found, sorry."
2772                 return 1
2773             fi
2774         fi
2775     }
2776     _dnews() { _files -W /usr/share/doc -/ }
2777     compdef _dnews dnews
2778
2779     #f1# View upstream's changelog of a given package
2780     uchange() {
2781         emulate -L zsh
2782         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2783             $PAGER /usr/share/doc/$1/changelog.gz
2784         else
2785             echo "No changelog for package $1 found, sorry."
2786             return 1
2787         fi
2788     }
2789     _uchange() { _files -W /usr/share/doc -/ }
2790     compdef _uchange uchange
2791 fi
2792
2793 # zsh profiling
2794 profile() {
2795     ZSH_PROFILE_RC=1 $SHELL "$@"
2796 }
2797
2798 #f1# Edit an alias via zle
2799 edalias() {
2800     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2801 }
2802 compdef _aliases edalias
2803
2804 #f1# Edit a function via zle
2805 edfunc() {
2806     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2807 }
2808 compdef _functions edfunc
2809
2810 # use it e.g. via 'Restart apache2'
2811 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
2812 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
2813 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
2814 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
2815 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
2816 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2817     __start_stop() {
2818         local action_="${1:l}"  # e.g Start/Stop/Restart
2819         local service_="$2"
2820         local param_="$3"
2821
2822         local service_target_="$(readlink /etc/init.d/$service_)"
2823         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2824             # runit
2825             case "${action_}" in
2826                 start) if [[ ! -e /etc/service/$service_ ]]; then
2827                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2828                        else
2829                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2830                        fi ;;
2831                 # there is no reload in runits sysv emulation
2832                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2833                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2834             esac
2835         else
2836             # sysvinit
2837             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2838         fi
2839     }
2840
2841     for i in Start Restart Stop Force-Reload Reload ; do
2842         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
2843     done
2844 fi
2845
2846 #f1# Provides useful information on globbing
2847 H-Glob() {
2848     echo -e "
2849     /      directories
2850     .      plain files
2851     @      symbolic links
2852     =      sockets
2853     p      named pipes (FIFOs)
2854     *      executable plain files (0100)
2855     %      device files (character or block special)
2856     %b     block special files
2857     %c     character special files
2858     r      owner-readable files (0400)
2859     w      owner-writable files (0200)
2860     x      owner-executable files (0100)
2861     A      group-readable files (0040)
2862     I      group-writable files (0020)
2863     E      group-executable files (0010)
2864     R      world-readable files (0004)
2865     W      world-writable files (0002)
2866     X      world-executable files (0001)
2867     s      setuid files (04000)
2868     S      setgid files (02000)
2869     t      files with the sticky bit (01000)
2870
2871   print *(m-1)          # Files modified up to a day ago
2872   print *(a1)           # Files accessed a day ago
2873   print *(@)            # Just symlinks
2874   print *(Lk+50)        # Files bigger than 50 kilobytes
2875   print *(Lk-50)        # Files smaller than 50 kilobytes
2876   print **/*.c          # All *.c files recursively starting in \$PWD
2877   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2878   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2879   print *~*.*           # All Files that do not contain a dot
2880   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2881   print -l *(.c|.h)     # Lists *.c and *.h
2882   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2883   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2884 }
2885 alias help-zshglob=H-Glob
2886
2887 check_com -c qma && alias ?='qma zshall'
2888
2889 # grep for running process, like: 'any vim'
2890 any() {
2891     emulate -L zsh
2892     unsetopt KSH_ARRAYS
2893     if [[ -z "$1" ]] ; then
2894         echo "any - grep for process(es) by keyword" >&2
2895         echo "Usage: any <keyword>" >&2 ; return 1
2896     else
2897         ps xauwww | grep --color=auto "[${1[1]}]${1[2,-1]}"
2898     fi
2899 }
2900
2901
2902 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2903 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2904 [[ -r /proc/1/maps ]] && \
2905 deswap() {
2906     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2907     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2908     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2909 }
2910
2911 # print hex value of a number
2912 hex() {
2913     emulate -L zsh
2914     [[ -n "$1" ]] && printf "%x\n" $1 || { print 'Usage: hex <number-to-convert>' ; return 1 }
2915 }
2916
2917 # calculate (or eval at all ;-)) with perl => p[erl-]eval
2918 # hint: also take a look at zcalc -> 'autoload zcalc' -> 'man zshmodules | less -p MATHFUNC'
2919 peval() {
2920     [[ -n "$1" ]] && CALC="$*" || print "Usage: calc [expression]"
2921     perl -e "print eval($CALC),\"\n\";"
2922 }
2923 functions peval &>/dev/null && alias calc=peval
2924
2925 # brltty seems to have problems with utf8 environment and/or font Uni3-Terminus16 under
2926 # certain circumstances, so work around it, no matter which environment we have
2927 brltty() {
2928     if [[ -z "$DISPLAY" ]] ; then
2929         consolechars -f /usr/share/consolefonts/default8x16.psf.gz
2930         command brltty "$@"
2931     else
2932         command brltty "$@"
2933     fi
2934 }
2935
2936 # just press 'asdf' keys to toggle between dvorak and us keyboard layout
2937 aoeu() {
2938     echo -n 'Switching to us keyboard layout: '
2939     [[ -z "$DISPLAY" ]] && $SUDO loadkeys us &>/dev/null || setxkbmap us &>/dev/null
2940     echo 'Done'
2941 }
2942 asdf() {
2943     echo -n 'Switching to dvorak keyboard layout: '
2944     [[ -z "$DISPLAY" ]] && $SUDO loadkeys dvorak &>/dev/null || setxkbmap dvorak &>/dev/null
2945     echo 'Done'
2946 }
2947 # just press 'asdf' key to toggle from neon layout to us keyboard layout
2948 uiae() {
2949     echo -n 'Switching to us keyboard layout: '
2950     setxkbmap us && echo 'Done' || echo 'Failed'
2951 }
2952
2953 # set up an ipv6 tunnel
2954 ipv6-tunnel() {
2955     emulate -L zsh
2956     case $1 in
2957         start)
2958             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
2959                 print 'ipv6 tunnel already set up, nothing to be done.'
2960                 print 'execute: "ifconfig sit1 down ; ifconfig sit0 down" to remove ipv6-tunnel.' ; return 1
2961             else
2962                 [[ -n "$PUBLIC_IP" ]] || \
2963                     local PUBLIC_IP=$(ifconfig $(route -n | awk '/^0\.0\.0\.0/{print $8; exit}') | \
2964                                       awk '/inet addr:/ {print $2}' | tr -d 'addr:')
2965
2966                 [[ -n "$PUBLIC_IP" ]] || { print 'No $PUBLIC_IP set and could not determine default one.' ; return 1 }
2967                 local IPV6ADDR=$(printf "2002:%02x%02x:%02x%02x:1::1" $(print ${PUBLIC_IP//./ }))
2968                 print -n "Setting up ipv6 tunnel $IPV6ADDR via ${PUBLIC_IP}: "
2969                 ifconfig sit0 tunnel ::192.88.99.1 up
2970                 ifconfig sit1 add "$IPV6ADDR" && print done || print failed
2971             fi
2972             ;;
2973         status)
2974             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
2975                 print 'ipv6 tunnel available' ; return 0
2976             else
2977                 print 'ipv6 tunnel not available' ; return 1
2978             fi
2979             ;;
2980         stop)
2981             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
2982                 print -n 'Stopping ipv6 tunnel (sit0 + sit1): '
2983                 ifconfig sit1 down ; ifconfig sit0 down && print done || print failed
2984             else
2985                 print 'No ipv6 tunnel found, nothing to be done.' ; return 1
2986             fi
2987             ;;
2988         *)
2989             print "Usage: ipv6-tunnel [start|stop|status]">&2 ; return 1
2990             ;;
2991     esac
2992 }
2993
2994 # run dhclient for wireless device
2995 iwclient() {
2996     sudo dhclient "$(wavemon -d | awk '/device/{print $3}')"
2997 }
2998
2999 # spawn a minimally set up mksh - useful if you want to umount /usr/.
3000 minimal-shell() {
3001     emulate -L zsh
3002     local shell="/bin/mksh"
3003
3004     if [[ ! -x ${shell} ]]; then
3005         printf '`%s'\'' not available, giving up.\n' ${shell} >&2
3006         return 1
3007     fi
3008
3009     exec env -i ENV="/etc/minimal-shellrc" HOME="$HOME" TERM="$TERM" ${shell}
3010 }
3011
3012 # a wrapper for vim, that deals with title setting
3013 #   VIM_OPTIONS
3014 #       set this array to a set of options to vim you always want
3015 #       to have set when calling vim (in .zshrc.local), like:
3016 #           VIM_OPTIONS=( -p )
3017 #       This will cause vim to send every file given on the
3018 #       commandline to be send to it's own tab (needs vim7).
3019 vim() {
3020     VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3021 }
3022
3023 # make a backup of a file
3024 bk() {
3025     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
3026 }
3027
3028 #f1# grep for patterns in grml's zsh setup
3029 zg() {
3030 #{{{
3031     LANG=C perl -e '
3032
3033 sub usage {
3034     print "usage: zg -[anr] <pattern>\n";
3035     print " Search for patterns in grml'\''s zshrc.\n";
3036     print " zg takes no or exactly one option plus a non empty pattern.\n\n";
3037     print "   options:\n";
3038     print "     --  no options (use if your pattern starts in with a dash.\n";
3039     print "     -a  search for the pattern in all code regions\n";
3040     print "     -n  search for the pattern in non-root code only\n";
3041     print "     -r  search in code for everyone (also root) only\n\n";
3042     print "   The default is -a for non-root users and -r for root.\n\n";
3043     print " If you installed the zshrc to a non-default locations (ie *NOT*\n";
3044     print " in /etc/zsh/zshrc) do: export GRML_ZSHRC=\$HOME/.zshrc\n";
3045     print " ...in case you copied the file to that location.\n\n";
3046     exit 1;
3047 }
3048
3049 if ($ENV{GRML_ZSHRC} ne "") {
3050     $RC = $ENV{GRML_ZSHRC};
3051 } else {
3052     $RC = "/etc/zsh/zshrc";
3053 }
3054
3055 usage if ($#ARGV < 0 || $#ARGV > 1);
3056 if ($> == 0) { $mode = "allonly"; }
3057 else { $mode = "all"; }
3058
3059 $opt = $ARGV[0];
3060 if ($opt eq "--")     { shift; }
3061 elsif ($opt eq "-a")  { $mode = "all"; shift; }
3062 elsif ($opt eq "-n")  { $mode = "nonroot"; shift; }
3063 elsif ($opt eq "-r" ) { $mode = "allonly"; shift; }
3064 elsif ($opt =~ m/^-/ || $#ARGV > 0) { usage(); }
3065
3066 $pattern = $ARGV[0];
3067 usage() if ($pattern eq "");
3068
3069 open FH, "<$RC" or die "zg: Could not open $RC: $!\n";
3070 while ($line = <FH>) {
3071     chomp $line;
3072     if ($line =~ m/^#:grep:marker:for:mika:/) { $markerfound = 1; next; }
3073     next if ($mode eq "nonroot" && markerfound == 0);
3074     break if ($mode eq "allonly" && markerfound == 1);
3075     print $line, "\n" if ($line =~ /$pattern/);
3076 }
3077 close FH;
3078 exit 0;
3079
3080     ' -- "$@"
3081 #}}}
3082     return $?
3083 }
3084
3085 ssl_hashes=( sha512 sha256 sha1 md5 )
3086
3087 for sh in ${ssl_hashes}; do
3088     eval 'ssl-cert-'${sh}'() {
3089         emulate -L zsh
3090         if [[ -z $1 ]] ; then
3091             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
3092             return 1
3093         fi
3094         openssl x509 -noout -fingerprint -'${sh}' -in $1
3095     }'
3096 done; unset sh
3097
3098 ssl-cert-fingerprints() {
3099     emulate -L zsh
3100     local i
3101     if [[ -z $1 ]] ; then
3102         printf 'usage: ssl-cert-fingerprints <file>\n'
3103         return 1
3104     fi
3105     for i in ${ssl_hashes}
3106         do ssl-cert-$i $1;
3107     done
3108 }
3109
3110 ssl-cert-info() {
3111     emulate -L zsh
3112     if [[ -z $1 ]] ; then
3113         printf 'usage: ssl-cert-info <file>\n'
3114         return 1
3115     fi
3116     openssl x509 -noout -text -in $1
3117     ssl-cert-fingerprints $1
3118 }
3119
3120 # }}}
3121
3122 # {{{ make sure our environment is clean regarding colors
3123 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
3124 # }}}
3125
3126 # "persistent history" {{{
3127 # just write important commands you always need to ~/.important_commands
3128 if [[ -r ~/.important_commands ]] ; then
3129     fc -R ~/.important_commands
3130 fi
3131 # }}}
3132
3133 # load the lookup subsystem if it's available on the system
3134 zrcautoload lookupinit && lookupinit
3135
3136 #:grep:marker:for:mika: :-)
3137 ### non-root (EUID != 0) code below
3138 ###
3139
3140 if (( GRML_ALWAYS_LOAD_ALL == 0 )) && (( $EUID == 0 )) ; then
3141     zrclocal
3142     return 0
3143 fi
3144
3145 # variables {{{
3146
3147 # set terminal property (used e.g. by msgid-chooser)
3148 export COLORTERM="yes"
3149
3150 # set default browser
3151 if [[ -z "$BROWSER" ]] ; then
3152     if [[ -n "$DISPLAY" ]] ; then
3153         #v# If X11 is running
3154         check_com -c firefox && export BROWSER=firefox
3155     else
3156         #v# If no X11 is running
3157         check_com -c w3m && export BROWSER=w3m
3158     fi
3159 fi
3160
3161 #m# v QTDIR \kbd{/usr/share/qt[34]}\quad [for non-root only]
3162 [[ -d /usr/share/qt3 ]] && export QTDIR=/usr/share/qt3
3163 [[ -d /usr/share/qt4 ]] && export QTDIR=/usr/share/qt4
3164
3165 # support running 'jikes *.java && jamvm HelloWorld' OOTB:
3166 #v# [for non-root only]
3167 [[ -f /usr/share/classpath/glibj.zip ]] && export JIKESPATH=/usr/share/classpath/glibj.zip
3168 # }}}
3169
3170 # aliases {{{
3171
3172 # Xterm resizing-fu.
3173 # Based on http://svn.kitenet.net/trunk/home-full/.zshrc?rev=11710&view=log (by Joey Hess)
3174 alias hide='echo -en "\033]50;nil2\007"'
3175 alias tiny='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-80-*-*-c-*-iso8859-15\007"'
3176 alias small='echo -en "\033]50;6x10\007"'
3177 alias medium='echo -en "\033]50;-misc-fixed-medium-r-normal--13-120-75-75-c-80-iso8859-15\007"'
3178 alias default='echo -e "\033]50;-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-15\007"'
3179 alias large='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-150-*-*-c-*-iso8859-15\007"'
3180 alias huge='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-210-*-*-c-*-iso8859-15\007"'
3181 alias smartfont='echo -en "\033]50;-artwiz-smoothansi-*-*-*-*-*-*-*-*-*-*-*-*\007"'
3182 alias semifont='echo -en "\033]50;-misc-fixed-medium-r-semicondensed-*-*-120-*-*-*-*-iso8859-15\007"'
3183
3184 # general
3185 #a2# Execute \kbd{du -sch}
3186 alias da='du -sch'
3187 #a2# Execute \kbd{jobs -l}
3188 alias j='jobs -l'
3189
3190 # compile stuff
3191 #a2# Execute \kbd{./configure}
3192 alias CO="./configure"
3193 #a2# Execute \kbd{./configure --help}
3194 alias CH="./configure --help"
3195
3196 # listing stuff
3197 #a2# Execute \kbd{ls -lSrah}
3198 alias dir="ls -lSrah"
3199 #a2# Only show dot-directories
3200 alias lad='ls -d .*(/)'                # only show dot-directories
3201 #a2# Only show dot-files
3202 alias lsa='ls -a .*(.)'                # only show dot-files
3203 #a2# Only files with setgid/setuid/sticky flag
3204 alias lss='ls -l *(s,S,t)'             # only files with setgid/setuid/sticky flag
3205 #a2# Only show 1st ten symlinks
3206 alias lsl='ls -l *(@)'                 # only symlinks
3207 #a2# Display only executables
3208 alias lsx='ls -l *(*)'                 # only executables
3209 #a2# Display world-{readable,writable,executable} files
3210 alias lsw='ls -ld *(R,W,X.^ND/)'       # world-{readable,writable,executable} files
3211 #a2# Display the ten biggest files
3212 alias lsbig="ls -flh *(.OL[1,10])"     # display the biggest files
3213 #a2# Only show directories
3214 alias lsd='ls -d *(/)'                 # only show directories
3215 #a2# Only show empty directories
3216 alias lse='ls -d *(/^F)'               # only show empty directories
3217 #a2# Display the ten newest files
3218 alias lsnew="ls -rtlh *(D.om[1,10])"   # display the newest files
3219 #a2# Display the ten oldest files
3220 alias lsold="ls -rtlh *(D.Om[1,10])"   # display the oldest files
3221 #a2# Display the ten smallest files
3222 alias lssmall="ls -Srl *(.oL[1,10])"   # display the smallest files
3223
3224 # chmod
3225 #a2# Execute \kbd{chmod 600}
3226 alias rw-='chmod 600'
3227 #a2# Execute \kbd{chmod 700}
3228 alias rwx='chmod 700'
3229 #m# a2 r-{}- Execute \kbd{chmod 644}
3230 alias r--='chmod 644'
3231 #a2# Execute \kbd{chmod 755}
3232 alias r-x='chmod 755'
3233
3234 # some useful aliases
3235 #a2# Execute \kbd{mkdir -o}
3236 alias md='mkdir -p'
3237
3238 # console stuff
3239 #a2# Execute \kbd{mplayer -vo fbdev}
3240 alias cmplayer='mplayer -vo fbdev'
3241 #a2# Execute \kbd{mplayer -vo fbdev -fs -zoom}
3242 alias fbmplayer='mplayer -vo fbdev -fs -zoom'
3243 #a2# Execute \kbd{links2 -driver fb}
3244 alias fblinks='links2 -driver fb'
3245
3246 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3247 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3248 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3249
3250 # simple webserver
3251 check_com -c python && alias http="python -m SimpleHTTPServer"
3252
3253 # Use 'g' instead of 'git':
3254 check_com g || alias g='git'
3255
3256 # work around non utf8 capable software in utf environment via $LANG and luit
3257 if check_com isutfenv && check_com luit ; then
3258     if check_com -c mrxvt ; then
3259         isutfenv && [[ -n "$LANG" ]] && \
3260             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3261     fi
3262
3263     if check_com -c aterm ; then
3264         isutfenv && [[ -n "$LANG" ]] && \
3265             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3266     fi
3267
3268     if check_com -c centericq ; then
3269         isutfenv && [[ -n "$LANG" ]] && \
3270             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3271     fi
3272 fi
3273 # }}}
3274
3275 # useful functions {{{
3276
3277 # searching
3278 #f4# Search for newspostings from authors
3279 agoogle() { ${=BROWSER} "http://groups.google.com/groups?as_uauthors=$*" ; }
3280 #f4# Search Debian Bug Tracking System
3281 debbug()  {
3282     emulate -L zsh
3283     setopt extendedglob
3284     if [[ $# -eq 1 ]]; then
3285         case "$1" in
3286             ([0-9]##)
3287             ${=BROWSER} "http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=$1"
3288             ;;
3289             (*@*)
3290             ${=BROWSER} "http://bugs.debian.org/cgi-bin/pkgreport.cgi?submitter=$1"
3291             ;;
3292             (*)
3293             ${=BROWSER} "http://bugs.debian.org/$*"
3294             ;;
3295         esac
3296     else
3297         print "$0 needs one argument"
3298         return 1
3299     fi
3300 }
3301 #f4# Search Debian Bug Tracking System in mbox format
3302 debbugm() {
3303     emulate -L zsh
3304     bts show --mbox $1
3305 }
3306 #f4# Search DMOZ
3307 dmoz()    {
3308     emulate -L zsh
3309     ${=BROWSER} http://search.dmoz.org/cgi-bin/search\?search=${1// /_}
3310 }
3311 #f4# Search German   Wiktionary
3312 dwicti()  {
3313     emulate -L zsh
3314     ${=BROWSER} http://de.wiktionary.org/wiki/${(C)1// /_}
3315 }
3316 #f4# Search English  Wiktionary
3317 ewicti()  {
3318     emulate -L zsh
3319     ${=BROWSER} http://en.wiktionary.org/wiki/${(C)1// /_}
3320 }
3321 #f4# Search Google Groups
3322 ggogle()  {
3323     emulate -L zsh
3324     ${=BROWSER} "http://groups.google.com/groups?q=$*"
3325 }
3326 #f4# Search Google
3327 google()  {
3328     emulate -L zsh
3329     ${=BROWSER} "http://www.google.com/search?&num=100&q=$*"
3330 }
3331 #f4# Search Google Groups for MsgID
3332 mggogle() {
3333     emulate -L zsh
3334     ${=BROWSER} "http://groups.google.com/groups?selm=$*"
3335 }
3336 #f4# Search Netcraft
3337 netcraft(){
3338     emulate -L zsh
3339     ${=BROWSER} "http://toolbar.netcraft.com/site_report?url=$1"
3340 }
3341 #f4# Use German Wikipedia's full text search
3342 swiki()   {
3343     emulate -L zsh
3344     ${=BROWSER} http://de.wikipedia.org/wiki/Spezial:Search/${(C)1}
3345 }
3346 #f4# search \kbd{dict.leo.org}
3347 oleo()    {
3348     emulate -L zsh
3349     ${=BROWSER} "http://dict.leo.org/?search=$*"
3350 }
3351 #f4# Search German   Wikipedia
3352 wikide()  {
3353     emulate -L zsh
3354     ${=BROWSER} http://de.wikipedia.org/wiki/"${(C)*}"
3355 }
3356 #f4# Search English  Wikipedia
3357 wikien()  {
3358     emulate -L zsh
3359     ${=BROWSER} http://en.wikipedia.org/wiki/"${(C)*}"
3360 }
3361 #f4# Search official debs
3362 wodeb()   {
3363     emulate -L zsh
3364     ${=BROWSER} "http://packages.debian.org/search?keywords=$1&searchon=contents&suite=${2:=unstable}&section=all"
3365 }
3366
3367 #m# f4 gex() Exact search via Google
3368 check_com google && gex () {
3369     google "\"[ $1]\" $*"
3370 }
3371
3372 # misc
3373 #f5# Backup \kbd{file {\rm to} file\_timestamp}
3374 bk() {
3375     emulate -L zsh
3376     cp -b $1 $1_`date --iso-8601=m`
3377 }
3378 #f5# Copied diff
3379 cdiff() {
3380     emulate -L zsh
3381     diff -crd "$@" | egrep -v "^Only in |^Binary files "
3382 }
3383 #f5# cd to directoy and list files
3384 cl() {
3385     emulate -L zsh
3386     cd $1 && ls -a
3387 }
3388 #f5# Cvs add
3389 cvsa() {
3390     emulate -L zsh
3391     cvs add $* && cvs com -m 'initial checkin' $*
3392 }
3393 #f5# Cvs diff
3394 cvsd() {
3395     emulate -L zsh
3396     cvs diff -N $* |& $PAGER
3397 }
3398 #f5# Cvs log
3399 cvsl() {
3400     emulate -L zsh
3401     cvs log $* |& $PAGER
3402 }
3403 #f5# Cvs update
3404 cvsq() {
3405     emulate -L zsh
3406     cvs -nq update
3407 }
3408 #f5# Rcs2log
3409 cvsr() {
3410     emulate -L zsh
3411     rcs2log $* | $PAGER
3412 }
3413 #f5# Cvs status
3414 cvss() {
3415     emulate -L zsh
3416     cvs status -v $*
3417 }
3418 #f5# Disassemble source files using gcc and as
3419 disassemble(){
3420     emulate -L zsh
3421     gcc -pipe -S -o - -O -g $* | as -aldh -o /dev/null
3422 }
3423 #f5# Firefox remote control - open given URL
3424 fir() {
3425     if [ -e /etc/debian_version ]; then
3426         firefox -a iceweasel -remote "openURL($1)" || firefox ${1}&
3427     else
3428         firefox -a firefox -remote "openURL($1)" || firefox ${1}&
3429     fi
3430 }
3431 #f5# Create Directoy and \kbd{cd} to it
3432 mcd() {
3433     mkdir -p "$@" && cd "$@"
3434 }
3435 #f5# Unified diff to timestamped outputfile
3436 mdiff() {
3437     diff -udrP "$1" "$2" > diff.`date "+%Y-%m-%d"`."$1"
3438 }
3439 #f5# Memory overview
3440 memusage() {
3441     ps aux | awk '{if (NR > 1) print $5; if (NR > 2) print "+"} END { print "p" }' | dc
3442 }
3443 #f5# Show contents of gzipped tar file
3444 shtar() {
3445     emulate -L zsh
3446     gunzip -c $1 | tar -tf - -- | $PAGER
3447 }
3448 #f5# Show contents of zip file
3449 shzip() {
3450     emulate -L zsh
3451     unzip -l $1 | $PAGER
3452 }
3453 #f5# Unified diff
3454 udiff() {
3455     emulate -L zsh
3456     diff -urd $* | egrep -v "^Only in |^Binary files "
3457 }
3458 #f5# (Mis)use \kbd{vim} as \kbd{less}
3459 viless() {
3460     emulate -L zsh
3461     vim --cmd 'let no_plugin_maps = 1' -c "so \$VIMRUNTIME/macros/less.vim" "${@:--}"
3462 }
3463
3464 # Function Usage: uopen $URL/$file
3465 #f5# Download a file and display it locally
3466 uopen() {
3467     emulate -L zsh
3468     if ! [[ -n "$1" ]] ; then
3469         print "Usage: uopen \$URL/\$file">&2
3470         return 1
3471     else
3472         FILE=$1
3473         MIME=$(curl --head $FILE | grep Content-Type | cut -d ' ' -f 2 | cut -d\; -f 1)
3474         MIME=${MIME%$'\r'}
3475         curl $FILE | see ${MIME}:-
3476     fi
3477 }
3478
3479 # Function Usage: doc packagename
3480 #f5# \kbd{cd} to /usr/share/doc/\textit{package}
3481 doc() {
3482     emulate -L zsh
3483     cd /usr/share/doc/$1 && ls
3484 }
3485 _doc() { _files -W /usr/share/doc -/ }
3486 check_com compdef && compdef _doc doc
3487
3488 #f5# Make screenshot
3489 sshot() {
3490     [[ ! -d ~/shots  ]] && mkdir ~/shots
3491     #cd ~/shots ; sleep 5 ; import -window root -depth 8 -quality 80 `date "+%Y-%m-%d--%H:%M:%S"`.png
3492     cd ~/shots ; sleep 5; import -window root shot_`date --iso-8601=m`.jpg
3493 }
3494
3495 # list images only
3496 limg() {
3497     local -a images
3498     images=( *.{jpg,gif,png}(.N) )
3499
3500     if [[ $#images -eq 0 ]] ; then
3501         print "No image files found"
3502     else
3503         ls "$images[@]"
3504     fi
3505 }
3506
3507 #f5# Create PDF file from source code
3508 makereadable() {
3509     emulate -L zsh
3510     output=$1
3511     shift
3512     a2ps --medium A4dj -E -o $output $*
3513     ps2pdf $output
3514 }
3515
3516 # zsh with perl-regex - use it e.g. via:
3517 # regcheck '\s\d\.\d{3}\.\d{3} Euro' ' 1.000.000 Euro'
3518 #f5# Checks whether a regex matches or not.\\&\quad Example: \kbd{regcheck '.\{3\} EUR' '500 EUR'}
3519 regcheck() {
3520     emulate -L zsh
3521     zmodload -i zsh/pcre
3522     pcre_compile $1 && \
3523     pcre_match $2 && echo "regex matches" || echo "regex does not match"
3524 }
3525
3526 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
3527 accessed() {
3528     emulate -L zsh
3529     print -l -- *(a-${1:-1})
3530 }
3531
3532 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
3533 changed() {
3534     emulate -L zsh
3535     print -l -- *(c-${1:-1})
3536 }
3537
3538 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
3539 modified() {
3540     emulate -L zsh
3541     print -l -- *(m-${1:-1})
3542 }
3543 # modified() was named new() in earlier versions, add an alias for backwards compatibility
3544 check_com new || alias new=modified
3545
3546 #f5# Grep in history
3547 greph() {
3548     emulate -L zsh
3549     history 0 | grep $1
3550 }
3551 # use colors when GNU grep with color-support
3552 #a2# Execute \kbd{grep -{}-color=auto}
3553 (grep --help 2>/dev/null |grep -- --color) >/dev/null && alias grep='grep --color=auto'
3554 #a2# Execute \kbd{grep -i -{}-color=auto}
3555 alias GREP='grep -i --color=auto'
3556
3557 #f5# Watch manpages in a stretched style
3558 man2() { PAGER='dash -c "sed G | /usr/bin/less"' command man "$@" ; }
3559
3560 # usage example: 'lcheck strcpy'
3561 #f5# Find out which libs define a symbol
3562 lcheck() {
3563     if [[ -n "$1" ]] ; then
3564         nm -go /usr/lib/lib*.a 2>/dev/null | grep ":[[:xdigit:]]\{8\} . .*$1"
3565     else
3566         echo "Usage: lcheck <function>" >&2
3567     fi
3568 }
3569
3570 #f5# Clean up directory - remove well known tempfiles
3571 purge() {
3572     FILES=(*~(N) .*~(N) \#*\#(N) *.o(N) a.out(N) *.core(N) *.cmo(N) *.cmi(N) .*.swp(N))
3573     NBFILES=${#FILES}
3574     if [[ $NBFILES > 0 ]] ; then
3575         print $FILES
3576         local ans
3577         echo -n "Remove these files? [y/n] "
3578         read -q ans
3579         if [[ $ans == "y" ]] ; then
3580             rm ${FILES}
3581             echo ">> $PWD purged, $NBFILES files removed"
3582         else
3583             echo "Ok. .. then not.."
3584         fi
3585     fi
3586 }
3587
3588 #f5# show labels and uuids of disk devices
3589 if is439 && [[ -d /dev/disk/by-id/ ]]; then
3590     lsdisk() {
3591         emulate -L zsh
3592         setopt extendedglob
3593         local -a -U disks
3594         disks=( /dev/disk/by-id/*(@:A) )
3595         for dev in "$disks[@]"; do
3596             print ${fg_bold[red]}${dev}${reset_color} /dev/disk/by-label/*(@e/'[[ ${REPLY:A} == $dev ]] && REPLY=${fg[blue]}LABEL=${REPLY:t}${reset_color}'/N) /dev/disk/by-uuid/*(@e/'[[ ${REPLY:A} == $dev ]] && REPLY=${fg[green]}UUID=${REPLY:t}${reset_color}'/N)
3597             print -f "  %s\n" /dev/disk/by-id/*(@e/'[[ ${REPLY:A} == $dev ]]'/N:t)
3598         done
3599     }
3600 fi
3601
3602 # Translate DE<=>EN
3603 # 'translate' looks up fot a word in a file with language-to-language
3604 # translations (field separator should be " : "). A typical wordlist looks
3605 # like at follows:
3606 #  | english-word : german-transmission
3607 # It's also only possible to translate english to german but not reciprocal.
3608 # Use the following oneliner to turn back the sort order:
3609 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3610 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3611 #f5# Translates a word
3612 trans() {
3613     emulate -L zsh
3614     case "$1" in
3615         -[dD]*)
3616             translate -l de-en $2
3617             ;;
3618         -[eE]*)
3619             translate -l en-de $2
3620             ;;
3621         *)
3622             echo "Usage: $0 { -D | -E }"
3623             echo "         -D == German to English"
3624             echo "         -E == English to German"
3625     esac
3626 }
3627
3628 #f5# List all occurrences of programm in current PATH
3629 plap() {
3630     emulate -L zsh
3631     if [[ $# = 0 ]] ; then
3632         echo "Usage:    $0 program"
3633         echo "Example:  $0 zsh"
3634         echo "Lists all occurrences of program in the current PATH."
3635     else
3636         ls -l ${^path}/*$1*(*N)
3637     fi
3638 }
3639
3640 # Found in the mailinglistarchive from Zsh (IIRC ~1996)
3641 #f5# Select items for specific command(s) from history
3642 selhist() {
3643     emulate -L zsh
3644     local TAB=$'\t';
3645     (( $# < 1 )) && {
3646         echo "Usage: $0 command"
3647         return 1
3648     };
3649     cmd=(${(f)"$(grep -w $1 $HISTFILE | sort | uniq | pr -tn)"})
3650     print -l $cmd | less -F
3651     echo -n "enter number of desired command [1 - $(( ${#cmd[@]} - 1 ))]: "
3652     local answer
3653     read answer
3654     print -z "${cmd[$answer]#*$TAB}"
3655 }
3656
3657 # Use vim to convert plaintext to HTML
3658 #f5# Transform files to html with highlighting
3659 2html() {
3660     emulate -L zsh
3661     vim -u NONE -n -c ':syntax on' -c ':so $VIMRUNTIME/syntax/2html.vim' -c ':wqa' $1 &>/dev/null
3662 }
3663
3664 # Usage: simple-extract <file>
3665 #f5# Smart archive extractor
3666 simple-extract () {
3667     emulate -L zsh
3668     if [[ -f $1 ]] ; then
3669         case $1 in
3670             *.tar.bz2)  bzip2 -v -d $1      ;;
3671             *.tar.gz)   tar -xvzf $1        ;;
3672             *.rar)      unrar $1            ;;
3673             *.deb)      ar -x $1            ;;
3674             *.bz2)      bzip2 -d $1         ;;
3675             *.lzh)      lha x $1            ;;
3676             *.gz)       gunzip -d $1        ;;
3677             *.tar)      tar -xvf $1         ;;
3678             *.tgz)      gunzip -d $1        ;;
3679             *.tbz2)     tar -jxvf $1        ;;
3680             *.zip)      unzip $1            ;;
3681             *.Z)        uncompress $1       ;;
3682             *)          echo "'$1' Error. Please go away" ;;
3683         esac
3684     else
3685         echo "'$1' is not a valid file"
3686     fi
3687 }
3688
3689 # Usage: smartcompress <file> (<type>)
3690 #f5# Smart archive creator
3691 smartcompress() {
3692     emulate -L zsh
3693     if [[ -n $2 ]] ; then
3694         case $2 in
3695             tgz | tar.gz)   tar -zcvf$1.$2 $1 ;;
3696             tbz2 | tar.bz2) tar -jcvf$1.$2 $1 ;;
3697             tar.Z)          tar -Zcvf$1.$2 $1 ;;
3698             tar)            tar -cvf$1.$2  $1 ;;
3699             gz | gzip)      gzip           $1 ;;
3700             bz2 | bzip2)    bzip2          $1 ;;
3701             *)
3702                 echo "Error: $2 is not a valid compression type"
3703                 ;;
3704         esac
3705     else
3706         smartcompress $1 tar.gz
3707     fi
3708 }
3709
3710 # Usage: show-archive <archive>
3711 #f5# List an archive's content
3712 show-archive() {
3713     emulate -L zsh
3714     if [[ -f $1 ]] ; then
3715         case $1 in
3716             *.tar.gz)      gunzip -c $1 | tar -tf - -- ;;
3717             *.tar)         tar -tf $1 ;;
3718             *.tgz)         tar -ztf $1 ;;
3719             *.zip)         unzip -l $1 ;;
3720             *.bz2)         bzless $1 ;;
3721             *.deb)         dpkg-deb --fsys-tarfile $1 | tar -tf - -- ;;
3722             *)             echo "'$1' Error. Please go away" ;;
3723         esac
3724     else
3725         echo "'$1' is not a valid archive"
3726     fi
3727 }
3728
3729 # It's shameless stolen from <http://www.vim.org/tips/tip.php?tip_id=167>
3730 #f5# Use \kbd{vim} as your manpage reader
3731 vman() {
3732     emulate -L zsh
3733     if (( ${#argv} == 0 )); then
3734         printf 'usage: vman <topic>\n'
3735         return 1
3736     fi
3737     man "$@" | col -b | view -c 'set ft=man nomod nolist' -
3738 }
3739
3740 # function readme() { $PAGER -- (#ia3)readme* }
3741 #f5# View all README-like files in current directory in pager
3742 readme() {
3743     emulate -L zsh
3744     local files
3745     files=(./(#i)*(read*me|lue*m(in|)ut)*(ND))
3746     if (($#files)) ; then
3747         $PAGER $files
3748     else
3749         print 'No README files.'
3750     fi
3751 }
3752
3753 # function ansi-colors()
3754 #f5# Display ANSI colors
3755 ansi-colors() {
3756     typeset esc="\033[" line1 line2
3757     echo " _ _ _40 _ _ _41_ _ _ _42 _ _ 43_ _ _ 44_ _ _45 _ _ _ 46_ _ _ 47_ _ _ 49_ _"
3758     for fore in 30 31 32 33 34 35 36 37; do
3759         line1="$fore "
3760         line2="   "
3761         for back in 40 41 42 43 44 45 46 47 49; do
3762             line1="${line1}${esc}${back};${fore}m Normal ${esc}0m"
3763             line2="${line2}${esc}${back};${fore};1m Bold   ${esc}0m"
3764         done
3765         echo -e "$line1\n$line2"
3766     done
3767 }
3768
3769 #f5# Find all files in \$PATH with setuid bit set
3770 suidfind() { ls -latg $path | grep '^...s' }
3771
3772 # TODO: So, this is the third incarnation of this function!?
3773 #f5# Reload given functions
3774 refunc() {
3775     for func in $argv ; do
3776         unfunction $func
3777         autoload $func
3778     done
3779 }
3780
3781 # a small check to see which DIR is located on which server/partition.
3782 # stolen and modified from Sven's zshrc.forall
3783 #f5# Report diskusage of a directory
3784 dirspace() {
3785     emulate -L zsh
3786     if [[ -n "$1" ]] ; then
3787         for dir in "$@" ; do
3788             if [[ -d "$dir" ]] ; then
3789                 ( cd $dir; echo "-<$dir>"; du -shx .; echo);
3790             else
3791                 echo "warning: $dir does not exist" >&2
3792             fi
3793         done
3794     else
3795         for dir in $path; do
3796             if [[ -d "$dir" ]] ; then
3797                 ( cd $dir; echo "-<$dir>"; du -shx .; echo);
3798             else
3799                 echo "warning: $dir does not exist" >&2
3800             fi
3801         done
3802     fi
3803 }
3804
3805 # % slow_print `cat /etc/passwd`
3806 #f5# Slowly print out parameters
3807 slow_print() {
3808     for argument in "$@" ; do
3809         for ((i = 1; i <= ${#1} ;i++)) ; do
3810             print -n "${argument[i]}"
3811             sleep 0.08
3812         done
3813         print -n " "
3814     done
3815     print ""
3816 }
3817
3818 #f5# Show some status info
3819 status() {
3820     print
3821     print "Date..: "$(date "+%Y-%m-%d %H:%M:%S")
3822     print "Shell.: Zsh $ZSH_VERSION (PID = $$, $SHLVL nests)"
3823     print "Term..: $TTY ($TERM), ${BAUD:+$BAUD bauds, }$COLUMNS x $LINES chars"
3824     print "Login.: $LOGNAME (UID = $EUID) on $HOST"
3825     print "System: $(cat /etc/[A-Za-z]*[_-][rv]e[lr]*)"
3826     print "Uptime:$(uptime)"
3827     print
3828 }
3829
3830 # Rip an audio CD
3831 #f5# Rip an audio CD
3832 audiorip() {
3833     mkdir -p ~/ripps
3834     cd ~/ripps
3835     cdrdao read-cd --device $DEVICE --driver generic-mmc audiocd.toc
3836     cdrdao read-cddb --device $DEVICE --driver generic-mmc audiocd.toc
3837     echo " * Would you like to burn the cd now? (yes/no)"
3838     read input
3839     if [[ "$input" = "yes" ]] ; then
3840         echo " ! Burning Audio CD"
3841         audioburn
3842         echo " * done."
3843     else
3844         echo " ! Invalid response."
3845     fi
3846 }
3847
3848 # and burn it
3849 #f5# Burn an audio CD (in combination with audiorip)
3850 audioburn() {
3851     cd ~/ripps
3852     cdrdao write --device $DEVICE --driver generic-mmc audiocd.toc
3853     echo " * Should I remove the temporary files? (yes/no)"
3854     read input
3855     if [[ "$input" = "yes" ]] ; then
3856         echo " ! Removing Temporary Files."
3857         cd ~
3858         rm -rf ~/ripps
3859         echo " * done."
3860     else
3861         echo " ! Invalid response."
3862     fi
3863 }
3864
3865 #f5# Make an audio CD from all mp3 files
3866 mkaudiocd() {
3867     # TODO: do the renaming more zshish, possibly with zmv()
3868     emulate -L zsh
3869     cd ~/ripps
3870     for i in *.[Mm][Pp]3; do mv "$i" `echo $i | tr '[A-Z]' '[a-z]'`; done
3871     for i in *.mp3; do mv "$i" `echo $i | tr ' ' '_'`; done
3872     for i in *.mp3; do mpg123 -w `basename $i .mp3`.wav $i; done
3873     normalize -m *.wav
3874     for i in *.wav; do sox $i.wav -r 44100 $i.wav resample; done
3875 }
3876
3877 #f5# Create an ISO image. You are prompted for\\&\quad volume name, filename and directory
3878 mkiso() {
3879     emulate -L zsh
3880     echo " * Volume name "
3881     read volume
3882     echo " * ISO Name (ie. tmp.iso)"
3883     read iso
3884     echo " * Directory or File"
3885     read files
3886     mkisofs -o ~/$iso -A $volume -allow-multidot -J -R -iso-level 3 -V $volume -R $files
3887 }
3888
3889 #f5# Simple thumbnails generator
3890 genthumbs() {
3891     rm -rf thumb-* index.html
3892     echo "
3893 <html>
3894   <head>
3895     <title>Images</title>
3896   </head>
3897   <body>" > index.html
3898     for f in *.(gif|jpeg|jpg|png) ; do
3899         convert -size 100x200 "$f" -resize 100x200 thumb-"$f"
3900         echo "    <a href=\"$f\"><img src=\"thumb-$f\"></a>" >> index.html
3901     done
3902     echo "
3903   </body>
3904 </html>" >> index.html
3905 }
3906
3907 #f5# Set all ulimit parameters to \kbd{unlimited}
3908 allulimit() {
3909     ulimit -c unlimited
3910     ulimit -d unlimited
3911     ulimit -f unlimited
3912     ulimit -l unlimited
3913     ulimit -n unlimited
3914     ulimit -s unlimited
3915     ulimit -t unlimited
3916 }
3917
3918 # 2mp3 transcodes flac and ogg to mp3 with bitrate of 192 while preserving basic tags
3919 if check_com lame; then
3920     2mp3_192() {
3921         emulate -L zsh
3922         setopt extendedglob
3923         unsetopt ksharrays
3924
3925         local -a DECODE id3tags
3926         local -A tagmap
3927         local tagdata
3928         local RC=0
3929         tagmap=("(#l)title" --tt "(#l)artist" --ta "(#l)tracknumber" --tn "(#l)genre" --tg "(#l)album" --tl)
3930
3931         if [[ ${@[(i)*.ogg]} -le ${#@} ]] && ! check_com oggdec; then
3932             echo "ERROR: please install oggdec" >&2
3933             return 1
3934         fi
3935         if [[ ${@[(i)*.flac]} -le ${#@} ]] && ! check_com flac; then
3936             echo "ERROR: please install flac" >&2
3937             return 1
3938         fi
3939
3940         for af in "$@"; do
3941             id3tags=()
3942             case "$af" in
3943                 (*.flac)
3944                     DECODE=(flac -d -c "$af")
3945                     tagdata="$(metaflac --export-tags-to=- "$af")"
3946                     ;;
3947                 (*.ogg)
3948                     DECODE=(oggdec -Q -o - "$af")
3949                     tagdata="$(ogginfo "$af")"
3950                     ;;
3951                 (*) continue ;;
3952             esac
3953             for line (${(f)tagdata}) \
3954                 [[ "$line" == (#s)[[:space:]]#(#b)([^=]##)=(*)(#e) && -n $tagmap[(k)$match[1]] ]] && \
3955                 id3tags+=($tagmap[(k)$match[1]] "$match[2]")
3956             [[ ${#id3tags} -gt 0 ]] && id3tags=(--add-id3v2 --ignore-tag-errors $id3tags)
3957             $DECODE[*] | lame -b 192 -v -h --replaygain-fast  "${id3tags[@]}" - "${af:r}.mp3" || {RC=$?; print "Error transcoding" "${af}"; }
3958         done
3959         # return 0 if no error or exit code if at least one error happened
3960         return $RC
3961     }
3962     alias ogg2mp3_192 2mp3_192
3963 fi
3964
3965 #f5# RFC 2396 URL encoding in Z-Shell
3966 urlencode() {
3967     emulate -L zsh
3968     setopt extendedglob
3969     input=( ${(s::)1} )
3970     print ${(j::)input/(#b)([^A-Za-z0-9_.!~*\'\(\)-])/%${(l:2::0:)$(([##16]#match))}}
3971 }
3972
3973 # http://strcat.de/blog/index.php?/archives/335-Software-sauber-deinstallieren...html
3974 #f5# Log 'make install' output
3975 mmake() {
3976     emulate -L zsh
3977     [[ ! -d ~/.errorlogs ]] && mkdir ~/.errorlogs
3978     make -n install > ~/.errorlogs/${PWD##*/}-makelog
3979 }
3980
3981 #f5# Indent source code
3982 smart-indent() {
3983     indent -npro -kr -i8 -ts8 -sob -l80 -ss -ncs "$@"
3984 }
3985
3986 # highlight important stuff in diff output, usage example: hg diff | hidiff
3987 #m# a2 hidiff \kbd{histring} oneliner for diffs
3988 check_com -c histring && \
3989     alias hidiff="histring -fE '^Comparing files .*|^diff .*' | histring -c yellow -fE '^\-.*' | histring -c green -fE '^\+.*'"
3990
3991 # rename pictures based on information found in exif headers
3992 #f5# Rename pictures based on information found in exif headers
3993 exirename() {
3994     emulate -L zsh
3995     if [[ $# -lt 1 ]] ; then
3996         echo 'Usage: jpgrename $FILES' >& 2
3997         return 1
3998     else
3999         echo -n 'Checking for jhead with version newer than 1.9: '
4000         jhead_version=`jhead -h | grep 'used by most Digital Cameras.  v.*' | awk '{print $6}' | tr -d v`
4001         if [[ $jhead_version > '1.9' ]]; then
4002             echo 'success - now running jhead.'
4003             jhead -n%Y-%m-%d_%Hh%M_%f $*
4004         else
4005             echo 'failed - exiting.'
4006         fi
4007     fi
4008 }
4009
4010 # get_ic() - queries imap servers for capabilities; real simple. no imaps
4011 ic_get() {
4012     emulate -L zsh
4013     local port
4014     if [[ ! -z $1 ]] ; then
4015         port=${2:-143}
4016         print "querying imap server on $1:${port}...\n";
4017         print "a1 capability\na2 logout\n" | nc $1 ${port}
4018     else
4019         print "usage:\n  $0 <imap-server> [port]"
4020     fi
4021 }
4022
4023 # creates a Maildir/ with its {new,cur,tmp} subdirs
4024 mkmaildir() {
4025     emulate -L zsh
4026     local root subdir
4027     root=${MAILDIR_ROOT:-${HOME}/Mail}
4028     if [[ -z ${1} ]] ; then print "Usage:\n $0 <dirname>" ; return 1 ; fi
4029     subdir=${1}
4030     mkdir -p ${root}/${subdir}/{cur,new,tmp}
4031 }
4032
4033 #f5# Change the xterm title from within GNU-screen
4034 xtrename() {
4035     emulate -L zsh
4036     if [[ $1 != "-f" ]] ; then
4037         if [[ -z ${DISPLAY} ]] ; then
4038             printf 'xtrename only makes sense in X11.\n'
4039             return 1
4040         fi
4041     else
4042         shift
4043     fi
4044     if [[ -z $1 ]] ; then
4045         printf 'usage: xtrename [-f] "title for xterm"\n'
4046         printf '  renames the title of xterm from _within_ screen.\n'
4047         printf '  also works without screen.\n'
4048         printf '  will not work if DISPLAY is unset, use -f to override.\n'
4049         return 0
4050     fi
4051     print -n "\eP\e]0;${1}\C-G\e\\"
4052     return 0
4053 }
4054
4055 # hl() highlighted less
4056 # http://ft.bewatermyfriend.org/comp/data/zsh/zfunct.html
4057 if check_com -c highlight ; then
4058     function hl() {
4059     emulate -L zsh
4060         local theme lang
4061         theme=${HL_THEME:-""}
4062         case ${1} in
4063             (-l|--list)
4064                 ( printf 'available languages (syntax parameter):\n\n' ;
4065                     highlight --list-langs ; ) | less -SMr
4066                 ;;
4067             (-t|--themes)
4068                 ( printf 'available themes (style parameter):\n\n' ;
4069                     highlight --list-themes ; ) | less -SMr
4070                 ;;
4071             (-h|--help)
4072                 printf 'usage: hl <syntax[:theme]> <file>\n'
4073                 printf '    available options: --list (-l), --themes (-t), --help (-h)\n\n'
4074                 printf '  Example: hl c main.c\n'
4075                 ;;
4076             (*)
4077                 if [[ -z ${2} ]] || (( ${#argv} > 2 )) ; then
4078                     printf 'usage: hl <syntax[:theme]> <file>\n'
4079                     printf '    available options: --list (-l), --themes (-t), --help (-h)\n'
4080                     (( ${#argv} > 2 )) && printf '  Too many arguments.\n'
4081                     return 1
4082                 fi
4083                 lang=${1%:*}
4084                 [[ ${1} == *:* ]] && [[ -n ${1#*:} ]] && theme=${1#*:}
4085                 if [[ -n ${theme} ]] ; then
4086                     highlight --xterm256 --syntax ${lang} --style ${theme} ${2} | less -SMr
4087                 else
4088                     highlight --ansi --syntax ${lang} ${2} | less -SMr
4089                 fi
4090                 ;;
4091         esac
4092         return 0
4093     }
4094     # ... and a proper completion for hl()
4095     # needs 'highlight' as well, so it fits fine in here.
4096     function _hl_genarg()  {
4097         local expl
4098         if [[ -prefix 1 *: ]] ; then
4099             local themes
4100             themes=(${${${(f)"$(LC_ALL=C highlight --list-themes)"}/ #/}:#*(Installed|Use name)*})
4101             compset -P 1 '*:'
4102             _wanted -C list themes expl theme compadd ${themes}
4103         else
4104             local langs
4105             langs=(${${${(f)"$(LC_ALL=C highlight --list-langs)"}/ #/}:#*(Installed|Use name)*})
4106             _wanted -C list languages expl languages compadd -S ':' -q ${langs}
4107         fi
4108     }
4109     function _hl_complete() {
4110         _arguments -s '1: :_hl_genarg' '2:files:_path_files'
4111     }
4112     compdef _hl_complete hl
4113 fi
4114
4115 # TODO:
4116 # Rewrite this by either using tinyurl.com's API
4117 # or using another shortening service to comply with
4118 # tinyurl.com's policy.
4119 #
4120 # Create small urls via http://tinyurl.com using wget(1).
4121 #function zurl() {
4122 #    emulate -L zsh
4123 #    [[ -z $1 ]] && { print "USAGE: zurl <URL>" ; return 1 }
4124 #
4125 #    local PN url tiny grabber search result preview
4126 #    PN=$0
4127 #    url=$1
4128 ##   Check existence of given URL with the help of ping(1).
4129 ##   N.B. ping(1) only works without an eventual given protocol.
4130 #    ping -c 1 ${${url#(ftp|http)://}%%/*} >& /dev/null || \
4131 #        read -q "?Given host ${${url#http://*/}%/*} is not reachable by pinging. Proceed anyway? [y|n] "
4132 #
4133 #    if (( $? == 0 )) ; then
4134 ##           Prepend 'http://' to given URL where necessary for later output.
4135 #            [[ ${url} != http(s|)://* ]] && url='http://'${url}
4136 #            tiny='http://tinyurl.com/create.php?url='
4137 #            if check_com -c wget ; then
4138 #                grabber='wget -O- -o/dev/null'
4139 #            else
4140 #                print "wget is not available, but mandatory for ${PN}. Aborting."
4141 #            fi
4142 ##           Looking for i.e.`copy('http://tinyurl.com/7efkze')' in TinyURL's HTML code.
4143 #            search='copy\(?http://tinyurl.com/[[:alnum:]]##*'
4144 #            result=${(M)${${${(f)"$(${=grabber} ${tiny}${url})"}[(fr)${search}*]}//[()\';]/}%%http:*}
4145 ##           TinyURL provides the rather new feature preview for more confidence. <http://tinyurl.com/preview.php>
4146 #            preview='http://preview.'${result#http://}
4147 #
4148 #            printf '%s\n\n' "${PN} - Shrinking long URLs via webservice TinyURL <http://tinyurl.com>."
4149 #            printf '%s\t%s\n\n' 'Given URL:' ${url}
4150 #            printf '%s\t%s\n\t\t%s\n' 'TinyURL:' ${result} ${preview}
4151 #    else
4152 #        return 1
4153 #    fi
4154 #}
4155
4156 #f2# Print a specific line of file(s).
4157 linenr () {
4158 # {{{
4159     emulate -L zsh
4160     if [ $# -lt 2 ] ; then
4161        print "Usage: linenr <number>[,<number>] <file>" ; return 1
4162     elif [ $# -eq 2 ] ; then
4163          local number=$1
4164          local file=$2
4165          command ed -s $file <<< "${number}n"
4166     else
4167          local number=$1
4168          shift
4169          for file in "$@" ; do
4170              if [ ! -d $file ] ; then
4171                 echo "${file}:"
4172                 command ed -s $file <<< "${number}n" 2> /dev/null
4173              else
4174                 continue
4175              fi
4176          done | less
4177     fi
4178 # }}}
4179 }
4180
4181 #f2# Find history events by search pattern and list them by date.
4182 whatwhen()  {
4183 # {{{
4184     emulate -L zsh
4185     local usage help ident format_l format_s first_char remain first last
4186     usage='USAGE: whatwhen [options] <searchstring> <search range>'
4187     help='Use `whatwhen -h'\'' for further explanations.'
4188     ident=${(l,${#${:-Usage: }},, ,)}
4189     format_l="${ident}%s\t\t\t%s\n"
4190     format_s="${format_l//(\\t)##/\\t}"
4191     # Make the first char of the word to search for case
4192     # insensitive; e.g. [aA]
4193     first_char=[${(L)1[1]}${(U)1[1]}]
4194     remain=${1[2,-1]}
4195     # Default search range is `-100'.
4196     first=${2:-\-100}
4197     # Optional, just used for `<first> <last>' given.
4198     last=$3
4199     case $1 in
4200         ("")
4201             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
4202             printf '%s\n%s\n\n' ${usage} ${help} && return 1
4203         ;;
4204         (-h)
4205             printf '%s\n\n' ${usage}
4206             print 'OPTIONS:'
4207             printf $format_l '-h' 'show help text'
4208             print '\f'
4209             print 'SEARCH RANGE:'
4210             printf $format_l "'0'" 'the whole history,'
4211             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
4212             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
4213             printf '\n%s\n' 'EXAMPLES:'
4214             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
4215             printf $format_l 'whatwhen zsh -250'
4216             printf $format_l 'whatwhen foo 1 99'
4217         ;;
4218         (\?)
4219             printf '%s\n%s\n\n' ${usage} ${help} && return 1
4220         ;;
4221         (*)
4222             # -l list results on stout rather than invoking $EDITOR.
4223             # -i Print dates as in YYYY-MM-DD.
4224             # -m Search for a - quoted - pattern within the history.
4225             fc -li -m "*${first_char}${remain}*" $first $last
4226         ;;
4227     esac
4228 # }}}
4229 }
4230
4231 # change fluxbox keys from 'Alt-#' to 'Alt-F#' and vice versa
4232 fluxkey-change() {
4233     emulate -L zsh
4234     [[ -n "$FLUXKEYS" ]] || local FLUXKEYS="$HOME/.fluxbox/keys"
4235     if ! [[ -r "$FLUXKEYS" ]] ; then
4236         echo "Sorry, \$FLUXKEYS file $FLUXKEYS could not be read - nothing to be done."
4237         return 1
4238     else
4239         if grep -q 'Mod1 F[0-9] :Workspace [0-9]' $FLUXKEYS ; then
4240             echo -n 'Switching to Alt-# mode in ~/.fluxbox/keys: '
4241             sed -i -e 's|^\(Mod[0-9]\+[: space :]\+\)F\([0-9]\+[: space :]\+:Workspace.*\)|\1\2|' $FLUXKEYS && echo done || echo failed
4242         elif grep -q 'Mod1 [0-9] :Workspace [0-9]' $FLUXKEYS ; then
4243             echo -n 'Switching to Alt-F# mode in ~/.fluxbox/keys: '
4244             sed -i -e 's|^\(Mod[0-9]\+[: space :]\+\)\([0-9]\+[: space :]\+:Workspace.*\)|\1F\2|' $FLUXKEYS && echo done || echo failed
4245         else
4246             echo 'Sorry, do not know what to do.'
4247             return 1
4248         fi
4249     fi
4250 }
4251
4252 # retrieve weather information on the console
4253 # Usage example: 'weather LOWG'
4254 weather() {
4255     emulate -L zsh
4256     [[ -n "$1" ]] || {
4257         print 'Usage: weather <station_id>' >&2
4258         print 'List of stations: http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code'>&2
4259         return 1
4260     }
4261
4262     local VERBOSE="yes"    # TODO: Make this a command line switch
4263
4264     local ODIR=`pwd`
4265     local PLACE="${1:u}"
4266     local DIR="${HOME}/.weather"
4267     local LOG="${DIR}/log"
4268
4269     [[ -d ${DIR} ]] || {
4270         print -n "Creating ${DIR}: "
4271         mkdir ${DIR}
4272         print 'done'
4273     }
4274
4275     print "Retrieving information for ${PLACE}:"
4276     print
4277     cd ${DIR} && wget -T 10 --no-verbose --output-file=$LOG --timestamping http://weather.noaa.gov/pub/data/observations/metar/decoded/$PLACE.TXT
4278
4279     if [[ $? -eq 0 ]] ; then
4280         if [[ -n "$VERBOSE" ]] ; then
4281             cat ${PLACE}.TXT
4282         else
4283             DATE=$(grep 'UTC' ${PLACE}.TXT | sed 's#.* /##')
4284             TEMPERATURE=$(awk '/Temperature/ { print $4" degree Celcius / " $2" degree Fahrenheit" }' ${PLACE}.TXT | tr -d '(')
4285             echo "date: $DATE"
4286             echo "temp:  $TEMPERATURE"
4287         fi
4288     else
4289         print "There was an error retrieving the weather information for $PLACE" >&2
4290         cat $LOG
4291         cd $ODIR
4292         return 1
4293     fi
4294     cd $ODIR
4295 }
4296 # }}}
4297
4298 # mercurial related stuff {{{
4299 if check_com -c hg ; then
4300     # gnu like diff for mercurial
4301     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
4302     #f5# GNU like diff for mercurial
4303     hgdi() {
4304         emulate -L zsh
4305         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
4306     }
4307
4308     # build debian package
4309     #a2# Alias for \kbd{hg-buildpackage}
4310     alias hbp='hg-buildpackage'
4311
4312     # execute commands on the versioned patch-queue from the current repos
4313     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
4314
4315     # diffstat for specific version of a mercurial repository
4316     #   hgstat      => display diffstat between last revision and tip
4317     #   hgstat 1234 => display diffstat between revision 1234 and tip
4318     #f5# Diffstat for specific version of a mercurial repos
4319     hgstat() {
4320         emulate -L zsh
4321         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
4322     }
4323
4324 fi # end of check whether we have the 'hg'-executable
4325
4326 # }}}
4327
4328 # some useful commands often hard to remember - let's grep for them {{{
4329 # actually use our zg() function now. :)
4330
4331 # Work around ion/xterm resize bug.
4332 #if [[ "$SHLVL" -eq 1 ]]; then
4333 #       if check_com -c resize ; then
4334 #               eval `resize </dev/null`
4335 #       fi
4336 #fi
4337
4338 # enable jackd:
4339 #  /usr/bin/jackd -dalsa -dhw:0 -r48000 -p1024 -n2
4340 # now play audio file:
4341 #  alsaplayer -o jack foobar.mp3
4342
4343 # send files via netcat
4344 # on sending side:
4345 #  send() {j=$*; tar cpz ${j/%${!#}/}|nc -w 1 ${!#} 51330;}
4346 #  send dir* $HOST
4347 #  alias receive='nc -vlp 51330 | tar xzvp'
4348
4349 # debian stuff:
4350 # dh_make -e foo@localhost -f $1
4351 # dpkg-buildpackage -rfakeroot
4352 # lintian *.deb
4353 # dpkg-scanpackages ./ /dev/null | gzip > Packages.gz
4354 # dpkg-scansources . | gzip > Sources.gz
4355 # grep-dctrl --field Maintainer $* /var/lib/apt/lists/*
4356
4357 # other stuff:
4358 # convert -geometry 200x200 -interlace LINE -verbose
4359 # ldapsearch -x -b "OU=Bedienstete,O=tug" -h ldap.tugraz.at sn=$1
4360 # ps -ao user,pcpu,start,command
4361 # gpg --keyserver blackhole.pca.dfn.de --recv-keys
4362 # xterm -bg black -fg yellow -fn -misc-fixed-medium-r-normal--14-140-75-75-c-90-iso8859-15 -ah
4363 # nc -vz $1 1-1024   # portscan via netcat
4364 # wget --mirror --no-parent --convert-links
4365 # pal -d `date +%d`
4366 # autoload -U tetris; zle -N tetris; bindkey '...' ; echo "press ... for playing tennis"
4367 #
4368 # modify console cursor
4369 # see http://www.tldp.org/HOWTO/Framebuffer-HOWTO-5.html
4370 # print $'\e[?96;0;64c'
4371 # }}}
4372
4373 # grml-small cleanups {{{
4374
4375 # The following is used to remove zsh-config-items that do not work
4376 # in grml-small by default.
4377 # If you do not want these adjustments (for whatever reason), set
4378 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
4379 # sources if it is there).
4380
4381 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
4382
4383     unset abk[V]
4384     unalias    'V'      &> /dev/null
4385     unfunction vman     &> /dev/null
4386     unfunction viless   &> /dev/null
4387     unfunction 2html    &> /dev/null
4388
4389     # manpages are not in grmlsmall
4390     unfunction manzsh   &> /dev/null
4391     unfunction man2     &> /dev/null
4392
4393 fi
4394
4395 #}}}
4396
4397 zrclocal
4398
4399 ## genrefcard.pl settings {{{
4400
4401 ### doc strings for external functions from files
4402 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
4403
4404 ### example: split functions-search 8,16,24,32
4405 #@# split functions-search 8
4406
4407 ## }}}
4408
4409 ## END OF FILE #################################################################
4410 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
4411 # Local variables:
4412 # mode: sh
4413 # End: