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