etc/zsh/zshrc

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