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