etc/zsh/zshrc

   1 # Filename:      /etc/zsh/zshrc
   2 # Purpose:       config file for zsh (z shell)
   3 # Authors:       grml-team (grml.org), (c) Michael Prokop <mika@grml.org>
   4 # Bug-Reports:   see http://grml.org/bugs/
   5 # License:       This file is licensed under the GPL v2.
   6 ################################################################################
   7 # This file is sourced only for interactive shells. It
   8 # should contain commands to set up aliases, functions,
   9 # options, key bindings, etc.
  10 #
  11 # Global Order: zshenv, zprofile, zshrc, zlogin
  12 ################################################################################
  13
  14 # USAGE
  15 # If you are using this file as your ~/.zshrc file, please use ~/.zshrc.pre
  16 # and ~/.zshrc.local for your own customisations. The former file is read
  17 # before ~/.zshrc, the latter is read after it. Also, consider reading the
  18 # refcard and the reference manual for this setup, both available from:
  19 #     <http://grml.org/zsh/>
  20
  21 # Contributing:
  22 # If you want to help to improve grml's zsh setup, clone the grml-etc-core
  23 # repository from git.grml.org:
  24 #   git clone git://git.grml.org/grml-etc-core.git
  25 #
  26 # Make your changes, commit them; use 'git format-patch' to create a series
  27 # of patches and send those to the following address via 'git send-email':
  28 #   grml-etc-core@grml.org
  29 #
  30 # Doing so makes sure the right people get your patches for review and
  31 # possibly inclusion.
  32
  33 # zsh-refcard-tag documentation:
  34 #   You may notice strange looking comments in this file.
  35 #   These are there for a purpose. grml's zsh-refcard can now be
  36 #   automatically generated from the contents of the actual configuration
  37 #   file. However, we need a little extra information on which comments
  38 #   and what lines of code to take into account (and for what purpose).
  39 #
  40 # Here is what they mean:
  41 #
  42 # List of tags (comment types) used:
  43 #   #a#     Next line contains an important alias, that should
  44 #           be included in the grml-zsh-refcard.
  45 #           (placement tag: @@INSERT-aliases@@)
  46 #   #f#     Next line contains the beginning of an important function.
  47 #           (placement tag: @@INSERT-functions@@)
  48 #   #v#     Next line contains an important variable.
  49 #           (placement tag: @@INSERT-variables@@)
  50 #   #k#     Next line contains an important keybinding.
  51 #           (placement tag: @@INSERT-keybindings@@)
  52 #   #d#     Hashed directories list generation:
  53 #               start   denotes the start of a list of 'hash -d'
  54 #                       definitions.
  55 #               end     denotes its end.
  56 #           (placement tag: @@INSERT-hasheddirs@@)
  57 #   #A#     Abbreviation expansion list generation:
  58 #               start   denotes the beginning of abbreviations.
  59 #               end     denotes their end.
  60 #           Lines within this section that end in '#d .*' provide
  61 #           extra documentation to be included in the refcard.
  62 #           (placement tag: @@INSERT-abbrev@@)
  63 #   #m#     This tag allows you to manually generate refcard entries
  64 #           for code lines that are hard/impossible to parse.
  65 #               Example:
  66 #                   #m# k ESC-h Call the run-help function
  67 #               That would add a refcard entry in the keybindings table
  68 #               for 'ESC-h' with the given comment.
  69 #           So the syntax is: #m# <section> <argument> <comment>
  70 #   #o#     This tag lets you insert entries to the 'other' hash.
  71 #           Generally, this should not be used. It is there for
  72 #           things that cannot be done easily in another way.
  73 #           (placement tag: @@INSERT-other-foobar@@)
  74 #
  75 #   All of these tags (except for m and o) take two arguments, the first
  76 #   within the tag, the other after the tag:
  77 #
  78 #   #<tag><section># <comment>
  79 #
  80 #   Where <section> is really just a number, which are defined by the
  81 #   @secmap array on top of 'genrefcard.pl'. The reason for numbers
  82 #   instead of names is, that for the reader, the tag should not differ
  83 #   much from a regular comment. For zsh, it is a regular comment indeed.
  84 #   The numbers have got the following meanings:
  85 #         0 -> "default"
  86 #         1 -> "system"
  87 #         2 -> "user"
  88 #         3 -> "debian"
  89 #         4 -> "search"
  90 #         5 -> "shortcuts"
  91 #         6 -> "services"
  92 #
  93 #   So, the following will add an entry to the 'functions' table in the
  94 #   'system' section, with a (hopefully) descriptive comment:
  95 #       #f1# Edit an alias via zle
  96 #       edalias() {
  97 #
  98 #   It will then show up in the @@INSERT-aliases-system@@ replacement tag
  99 #   that can be found in 'grml-zsh-refcard.tex.in'.
 100 #   If the section number is omitted, the 'default' section is assumed.
 101 #   Furthermore, in 'grml-zsh-refcard.tex.in' @@INSERT-aliases@@ is
 102 #   exactly the same as @@INSERT-aliases-default@@. If you want a list of
 103 #   *all* aliases, for example, use @@INSERT-aliases-all@@.
 104
 105 # zsh profiling
 106 # just execute 'ZSH_PROFILE_RC=1 zsh' and run 'zprof' to get the details
 107 if [[ $ZSH_PROFILE_RC -gt 0 ]] ; then
 108     zmodload zsh/zprof
 109 fi
 110
 111 # load .zshrc.pre to give the user the chance to overwrite the defaults
 112 [[ -r ${ZDOTDIR:-${HOME}}/.zshrc.pre ]] && source ${ZDOTDIR:-${HOME}}/.zshrc.pre
 113
 114 # check for version/system
 115 # check for versions (compatibility reasons)
 116 is4(){
 117     [[ $ZSH_VERSION == <4->* ]] && return 0
 118     return 1
 119 }
 120
 121 is41(){
 122     [[ $ZSH_VERSION == 4.<1->* || $ZSH_VERSION == <5->* ]] && return 0
 123     return 1
 124 }
 125
 126 is42(){
 127     [[ $ZSH_VERSION == 4.<2->* || $ZSH_VERSION == <5->* ]] && return 0
 128     return 1
 129 }
 130
 131 is425(){
 132     [[ $ZSH_VERSION == 4.2.<5->* || $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 133     return 1
 134 }
 135
 136 is43(){
 137     [[ $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 138     return 1
 139 }
 140
 141 is433(){
 142     [[ $ZSH_VERSION == 4.3.<3->* || $ZSH_VERSION == 4.<4->* \
 143                                  || $ZSH_VERSION == <5->* ]] && return 0
 144     return 1
 145 }
 146
 147 is437(){
 148     [[ $ZSH_VERSION == 4.3.<7->* || $ZSH_VERSION == 4.<4->* \
 149                                  || $ZSH_VERSION == <5->* ]] && return 0
 150     return 1
 151 }
 152
 153 is439(){
 154     [[ $ZSH_VERSION == 4.3.<9->* || $ZSH_VERSION == 4.<4->* \
 155                                  || $ZSH_VERSION == <5->* ]] && return 0
 156     return 1
 157 }
 158
 159 #f1# Checks whether or not you're running grml
 160 isgrml(){
 161     [[ -f /etc/grml_version ]] && return 0
 162     return 1
 163 }
 164
 165 #f1# Checks whether or not you're running a grml cd
 166 isgrmlcd(){
 167     [[ -f /etc/grml_cd ]] && return 0
 168     return 1
 169 }
 170
 171 if isgrml ; then
 172 #f1# Checks whether or not you're running grml-small
 173     isgrmlsmall() {
 174         if [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]]; then
 175             return 0
 176         fi
 177         return 1
 178     }
 179 else
 180     isgrmlsmall() { return 1 }
 181 fi
 182
 183 isdarwin(){
 184     [[ $OSTYPE == darwin* ]] && return 0
 185     return 1
 186 }
 187
 188 isfreebsd(){
 189     [[ $OSTYPE == freebsd* ]] && return 0
 190     return 1
 191 }
 192
 193 #f1# are we running within an utf environment?
 194 isutfenv() {
 195     case "$LANG $CHARSET $LANGUAGE" in
 196         *utf*) return 0 ;;
 197         *UTF*) return 0 ;;
 198         *)     return 1 ;;
 199     esac
 200 }
 201
 202 # check for user, if not running as root set $SUDO to sudo
 203 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
 204
 205 # change directory to home on first invocation of zsh
 206 # important for rungetty -> autologin
 207 # Thanks go to Bart Schaefer!
 208 isgrml && checkhome() {
 209     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
 210         export ALREADY_DID_CD_HOME=$HOME
 211         cd
 212     fi
 213 }
 214
 215 # check for zsh v3.1.7+
 216
 217 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
 218      || ${ZSH_VERSION} == 3.<2->.<->*    \
 219      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
 220
 221     printf '-!-\n'
 222     printf '-!- In this configuration we try to make use of features, that only\n'
 223     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
 224     printf '-!- used with a wide range of zsh versions, while using fairly\n'
 225     printf '-!- advanced features in all supported versions.\n'
 226     printf '-!-\n'
 227     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
 228     printf '-!-\n'
 229     printf '-!- While this *may* work, it might as well fail.\n'
 230     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
 231     printf '-!-\n'
 232     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
 233     printf '-!- If it does today, you'\''ve been lucky.\n'
 234     printf '-!-\n'
 235     printf '-!- Ye been warned!\n'
 236     printf '-!-\n'
 237
 238     function zstyle() { : }
 239 fi
 240
 241 # autoload wrapper - use this one instead of autoload directly
 242 # We need to define this function as early as this, because autoloading
 243 # 'is-at-least()' needs it.
 244 function zrcautoload() {
 245     emulate -L zsh
 246     setopt extended_glob
 247     local fdir ffile
 248     local -i ffound
 249
 250     ffile=$1
 251     (( ffound = 0 ))
 252     for fdir in ${fpath} ; do
 253         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
 254     done
 255
 256     (( ffound == 0 )) && return 1
 257     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
 258         autoload -U ${ffile} || return 1
 259     else
 260         autoload ${ffile} || return 1
 261     fi
 262     return 0
 263 }
 264
 265 # Load is-at-least() for more precise version checks Note that this test will
 266 # *always* fail, if the is-at-least function could not be marked for
 267 # autoloading.
 268 zrcautoload is-at-least || is-at-least() { return 1 }
 269
 270 # set some important options (as early as possible)
 271
 272 # append history list to the history file; this is the default but we make sure
 273 # because it's required for share_history.
 274 setopt append_history
 275
 276 # import new commands from the history file also in other zsh-session
 277 is4 && setopt share_history
 278
 279 # save each command's beginning timestamp and the duration to the history file
 280 setopt extended_history
 281
 282 # If a new command line being added to the history list duplicates an older
 283 # one, the older command is removed from the list
 284 is4 && setopt histignorealldups
 285
 286 # remove command lines from the history list when the first character on the
 287 # line is a space
 288 setopt histignorespace
 289
 290 # if a command is issued that can't be executed as a normal command, and the
 291 # command is the name of a directory, perform the cd command to that directory.
 292 setopt auto_cd
 293
 294 # in order to use #, ~ and ^ for filename generation grep word
 295 # *~(*.gz|*.bz|*.bz2|*.zip|*.Z) -> searches for word not in compressed files
 296 # don't forget to quote '^', '~' and '#'!
 297 setopt extended_glob
 298
 299 # display PID when suspending processes as well
 300 setopt longlistjobs
 301
 302 # try to avoid the 'zsh: no matches found...'
 303 setopt nonomatch
 304
 305 # report the status of backgrounds jobs immediately
 306 setopt notify
 307
 308 # whenever a command completion is attempted, make sure the entire command path
 309 # is hashed first.
 310 setopt hash_list_all
 311
 312 # not just at the end
 313 setopt completeinword
 314
 315 # Don't send SIGHUP to background processes when the shell exits.
 316 setopt nohup
 317
 318 # make cd push the old directory onto the directory stack.
 319 setopt auto_pushd
 320
 321 # avoid "beep"ing
 322 setopt nobeep
 323
 324 # don't push the same dir twice.
 325 setopt pushd_ignore_dups
 326
 327 # * shouldn't match dotfiles. ever.
 328 setopt noglobdots
 329
 330 # use zsh style word splitting
 331 setopt noshwordsplit
 332
 333 # don't error out when unset parameters are used
 334 setopt unset
 335
 336 # setting some default values
 337 NOCOR=${NOCOR:-0}
 338 NOMENU=${NOMENU:-0}
 339 NOPRECMD=${NOPRECMD:-0}
 340 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
 341 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
 342 BATTERY=${BATTERY:-0}
 343 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
 344 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
 345
 346 typeset -ga ls_options
 347 typeset -ga grep_options
 348 if ls --help 2> /dev/null | grep -q GNU; then
 349     ls_options=( --color=auto )
 350 elif [[ $OSTYPE == freebsd* ]]; then
 351     ls_options=( -G )
 352 fi
 353 if grep --help 2> /dev/null | grep -q GNU || \
 354    [[ $OSTYPE == freebsd* ]]; then
 355     grep_options=( --color=auto )
 356 fi
 357
 358 # utility functions
 359 # this function checks if a command exists and returns either true
 360 # or false. This avoids using 'which' and 'whence', which will
 361 # avoid problems with aliases for which on certain weird systems. :-)
 362 # Usage: check_com [-c|-g] word
 363 #   -c  only checks for external commands
 364 #   -g  does the usual tests and also checks for global aliases
 365 check_com() {
 366     emulate -L zsh
 367     local -i comonly gatoo
 368
 369     if [[ $1 == '-c' ]] ; then
 370         (( comonly = 1 ))
 371         shift
 372     elif [[ $1 == '-g' ]] ; then
 373         (( gatoo = 1 ))
 374     else
 375         (( comonly = 0 ))
 376         (( gatoo = 0 ))
 377     fi
 378
 379     if (( ${#argv} != 1 )) ; then
 380         printf 'usage: check_com [-c] <command>\n' >&2
 381         return 1
 382     fi
 383
 384     if (( comonly > 0 )) ; then
 385         [[ -n ${commands[$1]}  ]] && return 0
 386         return 1
 387     fi
 388
 389     if   [[ -n ${commands[$1]}    ]] \
 390       || [[ -n ${functions[$1]}   ]] \
 391       || [[ -n ${aliases[$1]}     ]] \
 392       || [[ -n ${reswords[(r)$1]} ]] ; then
 393
 394         return 0
 395     fi
 396
 397     if (( gatoo > 0 )) && [[ -n ${galiases[$1]} ]] ; then
 398         return 0
 399     fi
 400
 401     return 1
 402 }
 403
 404 # creates an alias and precedes the command with
 405 # sudo if $EUID is not zero.
 406 salias() {
 407     emulate -L zsh
 408     local only=0 ; local multi=0
 409     while [[ $1 == -* ]] ; do
 410         case $1 in
 411             (-o) only=1 ;;
 412             (-a) multi=1 ;;
 413             (--) shift ; break ;;
 414             (-h)
 415                 printf 'usage: salias [-h|-o|-a] <alias-expression>\n'
 416                 printf '  -h      shows this help text.\n'
 417                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
 418                 printf '          be careful using this option.\n'
 419                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
 420                 return 0
 421                 ;;
 422             (*) printf "unkown option: '%s'\n" "$1" ; return 1 ;;
 423         esac
 424         shift
 425     done
 426
 427     if (( ${#argv} > 1 )) ; then
 428         printf 'Too many arguments %s\n' "${#argv}"
 429         return 1
 430     fi
 431
 432     key="${1%%\=*}" ;  val="${1#*\=}"
 433     if (( EUID == 0 )) && (( only == 0 )); then
 434         alias -- "${key}=${val}"
 435     elif (( EUID > 0 )) ; then
 436         (( multi > 0 )) && val="${val// ; / ; sudo }"
 437         alias -- "${key}=sudo ${val}"
 438     fi
 439
 440     return 0
 441 }
 442
 443 # a "print -l ${(u)foo}"-workaround for pre-4.2.0 shells
 444 # usage: uprint foo
 445 #   Where foo is the *name* of the parameter you want printed.
 446 #   Note that foo is no typo; $foo would be wrong here!
 447 if ! is42 ; then
 448     uprint () {
 449         emulate -L zsh
 450         local -a u
 451         local w
 452         local parameter=$1
 453
 454         if [[ -z ${parameter} ]] ; then
 455             printf 'usage: uprint <parameter>\n'
 456             return 1
 457         fi
 458
 459         for w in ${(P)parameter} ; do
 460             [[ -z ${(M)u:#$w} ]] && u=( $u $w )
 461         done
 462
 463         builtin print -l $u
 464     }
 465 fi
 466
 467 # Check if we can read given files and source those we can.
 468 xsource() {
 469     if (( ${#argv} < 1 )) ; then
 470         printf 'usage: xsource FILE(s)...\n' >&2
 471         return 1
 472     fi
 473
 474     while (( ${#argv} > 0 )) ; do
 475         [[ -r "$1" ]] && source "$1"
 476         shift
 477     done
 478     return 0
 479 }
 480
 481 # Check if we can read a given file and 'cat(1)' it.
 482 xcat() {
 483     emulate -L zsh
 484     if (( ${#argv} != 1 )) ; then
 485         printf 'usage: xcat FILE\n' >&2
 486         return 1
 487     fi
 488
 489     [[ -r $1 ]] && cat $1
 490     return 0
 491 }
 492
 493 # Remove these functions again, they are of use only in these
 494 # setup files. This should be called at the end of .zshrc.
 495 xunfunction() {
 496     emulate -L zsh
 497     local -a funcs
 498     funcs=(salias xcat xsource xunfunction zrcautoload
 499                                            zrcautozle
 500                                            zrcbindkey
 501                                            zrcgotkeymap
 502                                            zrcgotwidget)
 503     for func in $funcs ; do
 504         [[ -n ${functions[$func]} ]] \
 505             && unfunction $func
 506     done
 507     return 0
 508 }
 509
 510 # this allows us to stay in sync with grml's zshrc and put own
 511 # modifications in ~/.zshrc.local
 512 zrclocal() {
 513     xsource "/etc/zsh/zshrc.local"
 514     xsource "${ZDOTDIR:-${HOME}}/.zshrc.local"
 515     return 0
 516 }
 517
 518 # locale setup
 519 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
 520     xsource "/etc/default/locale"
 521 fi
 522
 523 for var in LANG LC_ALL LC_MESSAGES ; do
 524     [[ -n ${(P)var} ]] && export $var
 525 done
 526
 527 xsource "/etc/sysconfig/keyboard"
 528
 529 TZ=$(xcat /etc/timezone)
 530
 531 # set some variables
 532 if check_com -c vim ; then
 533 #v#
 534     export EDITOR=${EDITOR:-vim}
 535 else
 536     export EDITOR=${EDITOR:-vi}
 537 fi
 538
 539 #v#
 540 export PAGER=${PAGER:-less}
 541
 542 #v#
 543 export MAIL=${MAIL:-/var/mail/$USER}
 544
 545 # if we don't set $SHELL then aterm, rxvt,.. will use /bin/sh or /bin/bash :-/
 546 export SHELL='/bin/zsh'
 547
 548 # color setup for ls:
 549 check_com -c dircolors && eval $(dircolors -b)
 550 # color setup for ls on OS X / FreeBSD:
 551 isdarwin && export CLICOLOR=1
 552 isfreebsd && export CLICOLOR=1
 553
 554 # do MacPorts setup on darwin
 555 if isdarwin && [[ -d /opt/local ]]; then
 556     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
 557     # zshenv.
 558     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
 559     MANPATH="/opt/local/share/man:$MANPATH"
 560 fi
 561 # do Fink setup on darwin
 562 isdarwin && xsource /sw/bin/init.sh
 563
 564 # load our function and completion directories
 565 for fdir in /usr/share/grml/zsh/completion /usr/share/grml/zsh/functions; do
 566     fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
 567     if [[ ${fdir} == '/usr/share/grml/zsh/functions' ]] ; then
 568         for func in ${fdir}/**/[^_]*[^~](N.) ; do
 569             zrcautoload ${func:t}
 570         done
 571     fi
 572 done
 573 unset fdir func
 574
 575 # support colors in less
 576 export LESS_TERMCAP_mb=$'\E[01;31m'
 577 export LESS_TERMCAP_md=$'\E[01;31m'
 578 export LESS_TERMCAP_me=$'\E[0m'
 579 export LESS_TERMCAP_se=$'\E[0m'
 580 export LESS_TERMCAP_so=$'\E[01;44;33m'
 581 export LESS_TERMCAP_ue=$'\E[0m'
 582 export LESS_TERMCAP_us=$'\E[01;32m'
 583
 584 # mailchecks
 585 MAILCHECK=30
 586
 587 # report about cpu-/system-/user-time of command if running longer than
 588 # 5 seconds
 589 REPORTTIME=5
 590
 591 # watch for everyone but me and root
 592 watch=(notme root)
 593
 594 # automatically remove duplicates from these arrays
 595 typeset -U path cdpath fpath manpath
 596
 597 # Load a few modules
 598 is4 && \
 599 for mod in parameter complist deltochar mathfunc ; do
 600     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
 601 done
 602
 603 # autoload zsh modules when they are referenced
 604 if is4 ; then
 605     zmodload -a  zsh/stat    zstat
 606     zmodload -a  zsh/zpty    zpty
 607     zmodload -ap zsh/mapfile mapfile
 608 fi
 609
 610 # completion system
 611 if zrcautoload compinit ; then
 612     compinit || print 'Notice: no compinit available :('
 613 else
 614     print 'Notice: no compinit available :('
 615     function compdef { }
 616 fi
 617
 618 # completion system
 619
 620 # called later (via is4 && grmlcomp)
 621 # note: use 'zstyle' for getting current settings
 622 #         press ^xh (control-x h) for getting tags in context; ^x? (control-x ?) to run complete_debug with trace output
 623 grmlcomp() {
 624     # TODO: This could use some additional information
 625
 626     # Make sure the completion system is initialised
 627     (( ${+_comps} )) || return 1
 628
 629     # allow one error for every three characters typed in approximate completer
 630     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
 631
 632     # don't complete backup files as executables
 633     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
 634
 635     # start menu completion only if it could find no unambiguous initial string
 636     zstyle ':completion:*:correct:*'       insert-unambiguous true
 637     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
 638     zstyle ':completion:*:correct:*'       original true
 639
 640     # activate color-completion
 641     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
 642
 643     # format on completion
 644     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
 645
 646     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
 647     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
 648
 649     # insert all expansions for expand completer
 650     zstyle ':completion:*:expand:*'        tag-order all-expansions
 651     zstyle ':completion:*:history-words'   list false
 652
 653     # activate menu
 654     zstyle ':completion:*:history-words'   menu yes
 655
 656     # ignore duplicate entries
 657     zstyle ':completion:*:history-words'   remove-all-dups yes
 658     zstyle ':completion:*:history-words'   stop yes
 659
 660     # match uppercase from lowercase
 661     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
 662
 663     # separate matches into groups
 664     zstyle ':completion:*:matches'         group 'yes'
 665     zstyle ':completion:*'                 group-name ''
 666
 667     if [[ "$NOMENU" -eq 0 ]] ; then
 668         # if there are more than 5 options allow selecting from a menu
 669         zstyle ':completion:*'               menu select=5
 670     else
 671         # don't use any menus at all
 672         setopt no_auto_menu
 673     fi
 674
 675     zstyle ':completion:*:messages'        format '%d'
 676     zstyle ':completion:*:options'         auto-description '%d'
 677
 678     # describe options in full
 679     zstyle ':completion:*:options'         description 'yes'
 680
 681     # on processes completion complete all user processes
 682     zstyle ':completion:*:processes'       command 'ps -au$USER'
 683
 684     # offer indexes before parameters in subscripts
 685     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
 686
 687     # provide verbose completion information
 688     zstyle ':completion:*'                 verbose true
 689
 690     # recent (as of Dec 2007) zsh versions are able to provide descriptions
 691     # for commands (read: 1st word in the line) that it will list for the user
 692     # to choose from. The following disables that, because it's not exactly fast.
 693     zstyle ':completion:*:-command-:*:'    verbose false
 694
 695     # set format for warnings
 696     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
 697
 698     # define files to ignore for zcompile
 699     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
 700     zstyle ':completion:correct:'          prompt 'correct to: %e'
 701
 702     # Ignore completion functions for commands you don't have:
 703     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
 704
 705     # Provide more processes in completion of programs like killall:
 706     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
 707
 708     # complete manual by their section
 709     zstyle ':completion:*:manuals'    separate-sections true
 710     zstyle ':completion:*:manuals.*'  insert-sections   true
 711     zstyle ':completion:*:man:*'      menu yes select
 712
 713     # Search path for sudo completion
 714     zstyle ':completion:*:sudo:*' command-path /usr/local/sbin \
 715                                                /usr/local/bin  \
 716                                                /usr/sbin       \
 717                                                /usr/bin        \
 718                                                /sbin           \
 719                                                /bin            \
 720                                                /usr/X11R6/bin
 721
 722     # provide .. as a completion
 723     zstyle ':completion:*' special-dirs ..
 724
 725     # run rehash on completion so new installed program are found automatically:
 726     _force_rehash() {
 727         (( CURRENT == 1 )) && rehash
 728         return 1
 729     }
 730
 731     ## correction
 732     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
 733     if [[ "$NOCOR" -gt 0 ]] ; then
 734         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
 735         setopt nocorrect
 736     else
 737         # try to be smart about when to use what completer...
 738         setopt correct
 739         zstyle -e ':completion:*' completer '
 740             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
 741                 _last_try="$HISTNO$BUFFER$CURSOR"
 742                 reply=(_complete _match _ignored _prefix _files)
 743             else
 744                 if [[ $words[1] == (rm|mv) ]] ; then
 745                     reply=(_complete _files)
 746                 else
 747                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
 748                 fi
 749             fi'
 750     fi
 751
 752     # command for process lists, the local web server details and host completion
 753     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
 754
 755     # caching
 756     [[ -d $ZSHDIR/cache ]] && zstyle ':completion:*' use-cache yes && \
 757                             zstyle ':completion::complete:*' cache-path $ZSHDIR/cache/
 758
 759     # host completion
 760     if is42 ; then
 761         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
 762         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
 763     else
 764         _ssh_hosts=()
 765         _etc_hosts=()
 766     fi
 767     hosts=(
 768         $(hostname)
 769         "$_ssh_hosts[@]"
 770         "$_etc_hosts[@]"
 771         localhost
 772     )
 773     zstyle ':completion:*:hosts' hosts $hosts
 774     # TODO: so, why is this here?
 775     #  zstyle '*' hosts $hosts
 776
 777     # use generic completion system for programs not yet defined; (_gnu_generic works
 778     # with commands that provide a --help option with "standard" gnu-like output.)
 779     for compcom in cp deborphan df feh fetchipac head hnb ipacsum mv \
 780                    pal stow tail uname ; do
 781         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
 782     done; unset compcom
 783
 784     # see upgrade function in this file
 785     compdef _hosts upgrade
 786 }
 787
 788 # Keyboard setup: The following is the same code, we wrote for debian's setup.
 789 # It ensures the terminal is in the right mode, when zle is active, so the
 790 # values from $terminfo are valid. Therefore, this setup should work on all
 791 # systems, that have support for `terminfo'. It also requires the zsh in use to
 792 # have the `zsh/terminfo' module built.
 793 #
 794 # If you are customising your `zle-line-init()' or `zle-line-finish()'
 795 # functions, make sure you call the following utility functions in there:
 796 #
 797 #     - zle-line-init():      zle-smkx
 798 #     - zle-line-finish():    zle-rmkx
 799
 800 # Use emacs-like key bindings by default:
 801 bindkey -e
 802
 803 # Custom widgets:
 804
 805 ## beginning-of-line OR beginning-of-buffer OR beginning of history
 806 ## by: Bart Schaefer <schaefer@brasslantern.com>, Bernhard Tittelbach
 807 beginning-or-end-of-somewhere() {
 808     local hno=$HISTNO
 809     if [[ ( "${LBUFFER[-1]}" == $'\n' && "${WIDGET}" == beginning-of* ) || \
 810       ( "${RBUFFER[1]}" == $'\n' && "${WIDGET}" == end-of* ) ]]; then
 811         zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 812     else
 813         zle .${WIDGET:s/somewhere/line-hist/} "$@"
 814         if (( HISTNO != hno )); then
 815             zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 816         fi
 817     fi
 818 }
 819 zle -N beginning-of-somewhere beginning-or-end-of-somewhere
 820 zle -N end-of-somewhere beginning-or-end-of-somewhere
 821
 822 ## toggle the ,. abbreviation feature on/off
 823 # NOABBREVIATION: default abbreviation-state
 824 #                 0 - enabled (default)
 825 #                 1 - disabled
 826 NOABBREVIATION=${NOABBREVIATION:-0}
 827
 828 grml_toggle_abbrev() {
 829     if (( ${NOABBREVIATION} > 0 )) ; then
 830         NOABBREVIATION=0
 831     else
 832         NOABBREVIATION=1
 833     fi
 834 }
 835 zle -N grml_toggle_abbrev
 836
 837 # add a command line to the shells history without executing it
 838 commit-to-history() {
 839     print -s ${(z)BUFFER}
 840     zle send-break
 841 }
 842 zle -N commit-to-history
 843
 844 # only slash should be considered as a word separator:
 845 slash-backward-kill-word() {
 846     local WORDCHARS="${WORDCHARS:s@/@}"
 847     # zle backward-word
 848     zle backward-kill-word
 849 }
 850 zle -N slash-backward-kill-word
 851
 852 # a generic accept-line wrapper
 853
 854 # This widget can prevent unwanted autocorrections from command-name
 855 # to _command-name, rehash automatically on enter and call any number
 856 # of builtin and user-defined widgets in different contexts.
 857 #
 858 # For a broader description, see:
 859 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
 860 #
 861 # The code is imported from the file 'zsh/functions/accept-line' from
 862 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
 863 # distributed under the same terms as zsh itself.
 864
 865 # A newly added command will may not be found or will cause false
 866 # correction attempts, if you got auto-correction set. By setting the
 867 # following style, we force accept-line() to rehash, if it cannot
 868 # find the first word on the command line in the $command[] hash.
 869 zstyle ':acceptline:*' rehash true
 870
 871 function Accept-Line() {
 872     setopt localoptions noksharrays
 873     local -a subs
 874     local -xi aldone
 875     local sub
 876     local alcontext=${1:-$alcontext}
 877
 878     zstyle -a ":acceptline:${alcontext}" actions subs
 879
 880     (( ${#subs} < 1 )) && return 0
 881
 882     (( aldone = 0 ))
 883     for sub in ${subs} ; do
 884         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
 885         zle ${sub}
 886
 887         (( aldone > 0 )) && break
 888     done
 889 }
 890
 891 function Accept-Line-getdefault() {
 892     emulate -L zsh
 893     local default_action
 894
 895     zstyle -s ":acceptline:${alcontext}" default_action default_action
 896     case ${default_action} in
 897         ((accept-line|))
 898             printf ".accept-line"
 899             ;;
 900         (*)
 901             printf ${default_action}
 902             ;;
 903     esac
 904 }
 905
 906 function Accept-Line-HandleContext() {
 907     zle Accept-Line
 908
 909     default_action=$(Accept-Line-getdefault)
 910     zstyle -T ":acceptline:${alcontext}" call_default \
 911         && zle ${default_action}
 912 }
 913
 914 function accept-line() {
 915     setopt localoptions noksharrays
 916     local -ax cmdline
 917     local -x alcontext
 918     local buf com fname format msg default_action
 919
 920     alcontext='default'
 921     buf="${BUFFER}"
 922     cmdline=(${(z)BUFFER})
 923     com="${cmdline[1]}"
 924     fname="_${com}"
 925
 926     Accept-Line 'preprocess'
 927
 928     zstyle -t ":acceptline:${alcontext}" rehash \
 929         && [[ -z ${commands[$com]} ]]           \
 930         && rehash
 931
 932     if    [[ -n ${com}               ]] \
 933        && [[ -n ${reswords[(r)$com]} ]] \
 934        || [[ -n ${aliases[$com]}     ]] \
 935        || [[ -n ${functions[$com]}   ]] \
 936        || [[ -n ${builtins[$com]}    ]] \
 937        || [[ -n ${commands[$com]}    ]] ; then
 938
 939         # there is something sensible to execute, just do it.
 940         alcontext='normal'
 941         Accept-Line-HandleContext
 942
 943         return
 944     fi
 945
 946     if    [[ -o correct              ]] \
 947        || [[ -o correctall           ]] \
 948        && [[ -n ${functions[$fname]} ]] ; then
 949
 950         # nothing there to execute but there is a function called
 951         # _command_name; a completion widget. Makes no sense to
 952         # call it on the commandline, but the correct{,all} options
 953         # will ask for it nevertheless, so warn the user.
 954         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
 955             # Okay, we warned the user before, he called us again,
 956             # so have it his way.
 957             alcontext='force'
 958             Accept-Line-HandleContext
 959
 960             return
 961         fi
 962
 963         if zstyle -t ":acceptline:${alcontext}" nocompwarn ; then
 964             alcontext='normal'
 965             Accept-Line-HandleContext
 966         else
 967             # prepare warning message for the user, configurable via zstyle.
 968             zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
 969
 970             if [[ -z ${msg} ]] ; then
 971                 msg="%c will not execute and completion %f exists."
 972             fi
 973
 974             zformat -f msg "${msg}" "c:${com}" "f:${fname}"
 975
 976             zle -M -- "${msg}"
 977         fi
 978         return
 979     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
 980         # If we are here, the commandline contains something that is not
 981         # executable, which is neither subject to _command_name correction
 982         # and is not empty. might be a variable assignment
 983         alcontext='misc'
 984         Accept-Line-HandleContext
 985
 986         return
 987     fi
 988
 989     # If we got this far, the commandline only contains whitespace, or is empty.
 990     alcontext='empty'
 991     Accept-Line-HandleContext
 992 }
 993
 994 zle -N accept-line
 995 zle -N Accept-Line
 996 zle -N Accept-Line-HandleContext
 997
 998 # power completion - abbreviation expansion
 999 # power completion / abbreviation expansion / buffer expansion
1000 # see http://zshwiki.org/home/examples/zleiab for details
1001 # less risky than the global aliases but powerful as well
1002 # just type the abbreviation key and afterwards ',.' to expand it
1003 declare -A abk
1004 setopt extendedglob
1005 setopt interactivecomments
1006 abk=(
1007 #   key   # value                  (#d additional doc string)
1008 #A# start
1009     '...'  '../..'
1010     '....' '../../..'
1011     'BG'   '& exit'
1012     'C'    '| wc -l'
1013     'G'    '|& grep '${grep_options:+"${grep_options[*]}"}
1014     'H'    '| head'
1015     'Hl'   ' --help |& less -r'    #d (Display help in pager)
1016     'L'    '| less'
1017     'LL'   '|& less -r'
1018     'M'    '| most'
1019     'N'    '&>/dev/null'           #d (No Output)
1020     'R'    '| tr A-z N-za-m'       #d (ROT13)
1021     'SL'   '| sort | less'
1022     'S'    '| sort -u'
1023     'T'    '| tail'
1024     'V'    '|& vim -'
1025 #A# end
1026     'co'   './configure && make && sudo make install'
1027 )
1028
1029 zleiab() {
1030     emulate -L zsh
1031     setopt extendedglob
1032     local MATCH
1033
1034     if (( NOABBREVIATION > 0 )) ; then
1035         LBUFFER="${LBUFFER},."
1036         return 0
1037     fi
1038
1039     LBUFFER=${LBUFFER%%(#m)[.\-+:|_a-zA-Z0-9]#}
1040     LBUFFER+=${abk[$MATCH]:-$MATCH}
1041 }
1042
1043 zle -N zleiab
1044
1045 help-show-abk()
1046 {
1047   zle -M "$(print "Type ,. after these abbreviations to expand them:"; print -a -C 2 ${(kv)abk})"
1048 }
1049
1050 zle -N help-show-abk
1051
1052 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
1053 insert-datestamp() { LBUFFER+=${(%):-'%D{%Y-%m-%d}'}; }
1054 zle -N insert-datestamp
1055
1056 # press esc-m for inserting last typed word again (thanks to caphuso!)
1057 insert-last-typed-word() { zle insert-last-word -- 0 -1 };
1058 zle -N insert-last-typed-word;
1059
1060 function grml-zsh-fg() {
1061   if (( ${#jobstates} )); then
1062     zle .push-input
1063     [[ -o hist_ignore_space ]] && BUFFER=' ' || BUFFER=''
1064     BUFFER="${BUFFER}fg"
1065     zle .accept-line
1066   else
1067     zle -M 'No background jobs. Doing nothing.'
1068   fi
1069 }
1070 zle -N grml-zsh-fg
1071
1072 # run command line as user root via sudo:
1073 sudo-command-line() {
1074     [[ -z $BUFFER ]] && zle up-history
1075     if [[ $BUFFER != sudo\ * ]]; then
1076         BUFFER="sudo $BUFFER"
1077         CURSOR=$(( CURSOR+5 ))
1078     fi
1079 }
1080 zle -N sudo-command-line
1081
1082 ### jump behind the first word on the cmdline.
1083 ### useful to add options.
1084 function jump_after_first_word() {
1085     local words
1086     words=(${(z)BUFFER})
1087
1088     if (( ${#words} <= 1 )) ; then
1089         CURSOR=${#BUFFER}
1090     else
1091         CURSOR=${#${words[1]}}
1092     fi
1093 }
1094 zle -N jump_after_first_word
1095
1096 #f5# Create directory under cursor or the selected area
1097 inplaceMkDirs() {
1098     # Press ctrl-xM to create the directory under the cursor or the selected area.
1099     # To select an area press ctrl-@ or ctrl-space and use the cursor.
1100     # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
1101     # directory does not exist yet -> press ctrl-XM and problem solved
1102     local PATHTOMKDIR
1103     if ((REGION_ACTIVE==1)); then
1104         local F=$MARK T=$CURSOR
1105         if [[ $F -gt $T ]]; then
1106             F=${CURSOR}
1107             T=${MARK}
1108         fi
1109         # get marked area from buffer and eliminate whitespace
1110         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
1111         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
1112     else
1113         local bufwords iword
1114         bufwords=(${(z)LBUFFER})
1115         iword=${#bufwords}
1116         bufwords=(${(z)BUFFER})
1117         PATHTOMKDIR="${(Q)bufwords[iword]}"
1118     fi
1119     [[ -z "${PATHTOMKDIR}" ]] && return 1
1120     PATHTOMKDIR=${~PATHTOMKDIR}
1121     if [[ -e "${PATHTOMKDIR}" ]]; then
1122         zle -M " path already exists, doing nothing"
1123     else
1124         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
1125         zle end-of-line
1126     fi
1127 }
1128
1129 #k# mkdir -p <dir> from string under cursor or marked area
1130 zle -N inplaceMkDirs
1131
1132 #v1# set number of lines to display per page
1133 HELP_LINES_PER_PAGE=20
1134 #v1# set location of help-zle cache file
1135 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
1136 # helper function for help-zle, actually generates the help text
1137 help_zle_parse_keybindings()
1138 {
1139     emulate -L zsh
1140     setopt extendedglob
1141     unsetopt ksharrays  #indexing starts at 1
1142
1143     #v1# choose files that help-zle will parse for keybindings
1144     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
1145
1146     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
1147         local load_cache=0
1148         for f ($HELPZLE_KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
1149         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
1150     fi
1151
1152     #fill with default keybindings, possibly to be overwriten in a file later
1153     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
1154     local -A help_zle_keybindings
1155     help_zle_keybindings['<Ctrl>@']="set MARK"
1156     help_zle_keybindings['<Ctrl>x<Ctrl>j']="vi-join lines"
1157     help_zle_keybindings['<Ctrl>x<Ctrl>b']="jump to matching brace"
1158     help_zle_keybindings['<Ctrl>x<Ctrl>u']="undo"
1159     help_zle_keybindings['<Ctrl>_']="undo"
1160     help_zle_keybindings['<Ctrl>x<Ctrl>f<c>']="find <c> in cmdline"
1161     help_zle_keybindings['<Ctrl>a']="goto beginning of line"
1162     help_zle_keybindings['<Ctrl>e']="goto end of line"
1163     help_zle_keybindings['<Ctrl>t']="transpose charaters"
1164     help_zle_keybindings['<Alt>t']="transpose words"
1165     help_zle_keybindings['<Alt>s']="spellcheck word"
1166     help_zle_keybindings['<Ctrl>k']="backward kill buffer"
1167     help_zle_keybindings['<Ctrl>u']="forward kill buffer"
1168     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
1169     help_zle_keybindings["<Alt>'"]="quote line"
1170     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
1171     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
1172     help_zle_keybindings['<Alt>u']="make next word Uppercase"
1173     help_zle_keybindings['<Alt>l']="make next word lowercase"
1174     help_zle_keybindings['<Ctrl>xd']="preview expansion under cursor"
1175     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
1176     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
1177     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
1178     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
1179     help_zle_keybindings['<Ctrl>v']="insert next keypress symbol literally (e.g. for bindkey)"
1180     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
1181     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
1182     help_zle_keybindings['<Alt>h']="show help/manpage for current command"
1183
1184     #init global variables
1185     unset help_zle_lines help_zle_sln
1186     typeset -g -a help_zle_lines
1187     typeset -g help_zle_sln=1
1188
1189     local k v
1190     local lastkeybind_desc contents     #last description starting with #k# that we found
1191     local num_lines_elapsed=0            #number of lines between last description and keybinding
1192     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
1193     for f in $HELPZLE_KEYBINDING_FILES; do
1194         [[ -r "$f" ]] || continue   #not readable ? skip it
1195         contents="$(<$f)"
1196         for cline in "${(f)contents}"; do
1197             #zsh pattern: matches lines like: #k# ..............
1198             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
1199                 lastkeybind_desc="$match[*]"
1200                 num_lines_elapsed=0
1201             #zsh pattern: matches lines that set a keybinding using bindkey or compdef -k
1202             #             ignores lines that are commentend out
1203             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
1204             elif [[ "$cline" == [^#]#(bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
1205                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
1206                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
1207                     #substitute keybinding string with something readable
1208                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
1209                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
1210                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
1211                     help_zle_keybindings[${k}]=$lastkeybind_desc
1212                 fi
1213                 lastkeybind_desc=""
1214             else
1215               ((num_lines_elapsed++))
1216             fi
1217         done
1218     done
1219     unset contents
1220     #calculate length of keybinding column
1221     local kstrlen=0
1222     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
1223     #convert the assoc array into preformated lines, which we are able to sort
1224     for k v in ${(kv)help_zle_keybindings[@]}; do
1225         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
1226         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
1227     done
1228     #sort lines alphabetically
1229     help_zle_lines=("${(i)help_zle_lines[@]}")
1230     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
1231     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
1232     zcompile $HELP_ZLE_CACHE_FILE
1233 }
1234 typeset -g help_zle_sln
1235 typeset -g -a help_zle_lines
1236
1237 # Provides (partially autogenerated) help on keybindings and the zsh line editor
1238 help-zle()
1239 {
1240     emulate -L zsh
1241     unsetopt ksharrays  #indexing starts at 1
1242     #help lines already generated ? no ? then do it
1243     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
1244     #already displayed all lines ? go back to the start
1245     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
1246     local sln=$help_zle_sln
1247     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
1248     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
1249     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
1250 }
1251 zle -N help-zle
1252
1253 ## complete word from currently visible Screen or Tmux buffer.
1254 if check_com -c screen || check_com -c tmux; then
1255     _complete_screen_display() {
1256         [[ "$TERM" != "screen" ]] && return 1
1257
1258         local TMPFILE=$(mktemp)
1259         local -U -a _screen_display_wordlist
1260         trap "rm -f $TMPFILE" EXIT
1261
1262         # fill array with contents from screen hardcopy
1263         if ((${+TMUX})); then
1264             #works, but crashes tmux below version 1.4
1265             #luckily tmux -V option to ask for version, was also added in 1.4
1266             tmux -V &>/dev/null || return
1267             tmux -q capture-pane \; save-buffer -b 0 $TMPFILE \; delete-buffer -b 0
1268         else
1269             screen -X hardcopy $TMPFILE
1270             # screen sucks, it dumps in latin1, apparently always. so recode it
1271             # to system charset
1272             check_com recode && recode latin1 $TMPFILE
1273         fi
1274         _screen_display_wordlist=( ${(QQ)$(<$TMPFILE)} )
1275         # remove PREFIX to be completed from that array
1276         _screen_display_wordlist[${_screen_display_wordlist[(i)$PREFIX]}]=""
1277         compadd -a _screen_display_wordlist
1278     }
1279     #m# k CTRL-x\,\,\,S Complete word from GNU screen buffer
1280     bindkey -r "^xS"
1281     compdef -k _complete_screen_display complete-word '^xS'
1282 fi
1283
1284 # Load a few more functions and tie them to widgets, so they can be bound:
1285
1286 function zrcautozle() {
1287     emulate -L zsh
1288     local fnc=$1
1289     zrcautoload $fnc && zle -N $fnc
1290 }
1291
1292 function zrcgotwidget() {
1293     (( ${+widgets[$1]} ))
1294 }
1295
1296 function zrcgotkeymap() {
1297     [[ -n ${(M)keymaps:#$1} ]]
1298 }
1299
1300 zrcautozle insert-files
1301 zrcautozle edit-command-line
1302 zrcautozle insert-unicode-char
1303 if zrcautoload history-search-end; then
1304     zle -N history-beginning-search-backward-end history-search-end
1305     zle -N history-beginning-search-forward-end  history-search-end
1306 fi
1307 zle -C hist-complete complete-word _generic
1308 zstyle ':completion:hist-complete:*' completer _history
1309
1310 # The actual terminal setup hooks and bindkey-calls:
1311
1312 # An array to note missing features to ease diagnosis in case of problems.
1313 typeset -ga grml_missing_features
1314
1315 function zrcbindkey() {
1316     if (( ARGC )) && zrcgotwidget ${argv[-1]}; then
1317         bindkey "$@"
1318     fi
1319 }
1320
1321 function bind2maps () {
1322     local i sequence widget
1323     local -a maps
1324
1325     while [[ "$1" != "--" ]]; do
1326         maps+=( "$1" )
1327         shift
1328     done
1329     shift
1330
1331     sequence="${key[$1]}"
1332     widget="$2"
1333
1334     [[ -z "$sequence" ]] && return 1
1335
1336     for i in "${maps[@]}"; do
1337         zrcbindkey -M "$i" "$sequence" "$widget"
1338     done
1339 }
1340
1341 if (( ${+terminfo[smkx]} )) && (( ${+terminfo[rmkx]} )); then
1342     function zle-smkx () {
1343         printf '%s' ${terminfo[smkx]}
1344     }
1345     function zle-rmkx () {
1346         printf '%s' ${terminfo[rmkx]}
1347     }
1348     function zle-line-init () {
1349         zle-smkx
1350     }
1351     function zle-line-finish () {
1352         zle-rmkx
1353     }
1354     zle -N zle-line-init
1355     zle -N zle-line-finish
1356 else
1357     for i in {s,r}mkx; do
1358         (( ${+terminfo[$i]} )) || grml_missing_features+=($i)
1359     done
1360     unset i
1361 fi
1362
1363 typeset -A key
1364 key=(
1365     Home     "${terminfo[khome]}"
1366     End      "${terminfo[kend]}"
1367     Insert   "${terminfo[kich1]}"
1368     Delete   "${terminfo[kdch1]}"
1369     Up       "${terminfo[kcuu1]}"
1370     Down     "${terminfo[kcud1]}"
1371     Left     "${terminfo[kcub1]}"
1372     Right    "${terminfo[kcuf1]}"
1373     PageUp   "${terminfo[kpp]}"
1374     PageDown "${terminfo[knp]}"
1375     BackTab  "${terminfo[kcbt]}"
1376 )
1377
1378 bind2maps emacs             -- Home   beginning-of-somewhere
1379 bind2maps       viins vicmd -- Home   vi-beginning-of-line
1380 bind2maps emacs             -- End    end-of-somewhere
1381 bind2maps       viins vicmd -- End    vi-end-of-line
1382 bind2maps emacs viins       -- Insert overwrite-mode
1383 bind2maps             vicmd -- Insert vi-insert
1384 bind2maps emacs             -- Delete delete-char
1385 bind2maps       viins vicmd -- Delete vi-delete-char
1386 bind2maps emacs viins vicmd -- Up     up-line-or-search
1387 bind2maps emacs viins vicmd -- Down   down-line-or-search
1388 bind2maps emacs             -- Left   backward-char
1389 bind2maps       viins vicmd -- Left   vi-backward-char
1390 bind2maps emacs             -- Right  forward-char
1391 bind2maps       viins vicmd -- Right  vi-forward-char
1392 bind2maps       viins vicmd -- Right  vi-forward-char
1393
1394 if zrcgotkeymap menuselect; then
1395     #m# k Shift-tab Perform backwards menu completion
1396     bind2maps menuselect -- BackTab reverse-menu-complete
1397
1398     #k# menu selection: pick item but stay in the menu
1399     zrcbindkey -M menuselect '\e^M' accept-and-menu-complete
1400     # also use + and INSERT since it's easier to press repeatedly
1401     zrcbindkey -M menuselect "+" accept-and-menu-complete
1402     zrcbindkey -M menuselect "^[[2~" accept-and-menu-complete
1403
1404     # accept a completion and try to complete again by using menu
1405     # completion; very useful with completing directories
1406     # by using 'undo' one's got a simple file browser
1407     zrcbindkey -M menuselect '^o' accept-and-infer-next-history
1408 fi
1409
1410 #k# Display list of abbreviations that expand when followed by ,.
1411 zrcbindkey ",." zleiab
1412 zrcbindkey '^xb' help-show-abk
1413 zrcbindkey '^xM' inplaceMkDirs
1414 #k# display help for keybindings and ZLE
1415 zrcbindkey '^xz' help-zle
1416
1417 #k# Insert files and test globbing
1418 zrcbindkey "^xf" insert-files # C-x-f
1419
1420 #k# Edit the current line in \kbd{\$EDITOR}
1421 zrcbindkey '\ee' edit-command-line
1422
1423 ## use Ctrl-left-arrow and Ctrl-right-arrow for jumping to word-beginnings on the CL
1424 zrcbindkey "\e[5C" forward-word
1425 zrcbindkey "\e[5D" backward-word
1426 zrcbindkey "\e[1;5C" forward-word
1427 zrcbindkey "\e[1;5D" backward-word
1428 ## the same for alt-left-arrow and alt-right-arrow
1429 zrcbindkey '^[[1;3C' forward-word
1430 zrcbindkey '^[[1;3D' backward-word
1431
1432 #k# search history backward for entry beginning with typed text
1433 zrcbindkey '^xp'   history-beginning-search-backward-end
1434 #k# search history forward for entry beginning with typed text
1435 zrcbindkey '^xP'   history-beginning-search-forward-end
1436 #k# search history backward for entry beginning with typed text
1437 zrcbindkey "\e[5~" history-beginning-search-backward-end # PageUp
1438 #k# search history forward for entry beginning with typed text
1439 zrcbindkey "\e[6~" history-beginning-search-forward-end  # PageDown
1440
1441 # insert unicode character
1442 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
1443 # See for example http://unicode.org/charts/ for unicode characters code
1444 #k# Insert Unicode character
1445 zrcbindkey '^xi' insert-unicode-char
1446
1447 #k# Toggle abbreviation expansion on/off
1448 zrcbindkey '^xA' grml_toggle_abbrev
1449 zrcbindkey "^x^h" commit-to-history
1450
1451 #k# Kill left-side word or everything up to next slash
1452 zrcbindkey '\ev' slash-backward-kill-word
1453 #k# Kill left-side word or everything up to next slash
1454 zrcbindkey '\e^h' slash-backward-kill-word
1455 #k# Kill left-side word or everything up to next slash
1456 zrcbindkey '\e^?' slash-backward-kill-word
1457
1458 # use the new *-pattern-* widgets for incremental history search
1459 if zrcgotwidget history-incremental-pattern-search-backward; then
1460     zrcbindkey '^r' history-incremental-pattern-search-backward
1461     zrcbindkey '^s' history-incremental-pattern-search-forward
1462 fi
1463
1464 # Do history expansion on space:
1465 zrcbindkey ' ' magic-space
1466 #k# Trigger menu-complete
1467 zrcbindkey '\ei' menu-complete  # menu completion via esc-i
1468 #k# Insert a timestamp on the command line (yyyy-mm-dd)
1469 zrcbindkey '^ed' insert-datestamp
1470 #k# Insert last typed word
1471 zrcbindkey "\em" insert-last-typed-word
1472 #k# A smart shortcut for \kbd{fg<enter>}
1473 zrcbindkey '^z' grml-zsh-fg
1474 #k# prepend the current command with "sudo"
1475 zrcbindkey "^os" sudo-command-line
1476 #k# jump to after first word (for adding options)
1477 zrcbindkey '^x1' jump_after_first_word
1478 #k# complete word from history with menu
1479 zrcbindkey "^x^x" hist-complete
1480
1481 # autoloading
1482
1483 zrcautoload zmv
1484 zrcautoload zed
1485
1486 # we don't want to quote/espace URLs on our own...
1487 # if autoload -U url-quote-magic ; then
1488 #    zle -N self-insert url-quote-magic
1489 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
1490 # else
1491 #    print 'Notice: no url-quote-magic available :('
1492 # fi
1493 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
1494
1495 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
1496 alias run-help >&/dev/null && unalias run-help
1497 for rh in run-help{,-git,-svk,-svn}; do
1498     zrcautoload $rh
1499 done; unset rh
1500
1501 # command not found handling
1502
1503 (( ${COMMAND_NOT_FOUND} == 1 )) &&
1504 function command_not_found_handler() {
1505     emulate -L zsh
1506     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
1507         ${GRML_ZSH_CNF_HANDLER} $1
1508     fi
1509     return 1
1510 }
1511
1512 # history
1513
1514 ZSHDIR=${ZDOTDIR:-${HOME}/.zsh}
1515
1516 #v#
1517 HISTFILE=${ZDOTDIR:-${HOME}}/.zsh_history
1518 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
1519 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
1520
1521 # dirstack handling
1522
1523 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
1524 DIRSTACKFILE=${DIRSTACKFILE:-${ZDOTDIR:-${HOME}}/.zdirs}
1525
1526 if [[ -f ${DIRSTACKFILE} ]] && [[ ${#dirstack[*]} -eq 0 ]] ; then
1527     dirstack=( ${(f)"$(< $DIRSTACKFILE)"} )
1528     # "cd -" won't work after login by just setting $OLDPWD, so
1529     [[ -d $dirstack[1] ]] && cd $dirstack[1] && cd $OLDPWD
1530 fi
1531
1532 chpwd() {
1533     local -ax my_stack
1534     my_stack=( ${PWD} ${dirstack} )
1535     if is42 ; then
1536         builtin print -l ${(u)my_stack} >! ${DIRSTACKFILE}
1537     else
1538         uprint my_stack >! ${DIRSTACKFILE}
1539     fi
1540 }
1541
1542 # directory based profiles
1543
1544 if is433 ; then
1545
1546 # chpwd_profiles(): Directory Profiles, Quickstart:
1547 #
1548 # In .zshrc.local:
1549 #
1550 #   zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1551 #   zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1552 #   chpwd_profiles
1553 #
1554 # For details see the `grmlzshrc.5' manual page.
1555 function chpwd_profiles() {
1556     local profile context
1557     local -i reexecute
1558
1559     context=":chpwd:profiles:$PWD"
1560     zstyle -s "$context" profile profile || profile='default'
1561     zstyle -T "$context" re-execute && reexecute=1 || reexecute=0
1562
1563     if (( ${+parameters[CHPWD_PROFILE]} == 0 )); then
1564         typeset -g CHPWD_PROFILE
1565         local CHPWD_PROFILES_INIT=1
1566         (( ${+functions[chpwd_profiles_init]} )) && chpwd_profiles_init
1567     elif [[ $profile != $CHPWD_PROFILE ]]; then
1568         (( ${+functions[chpwd_leave_profile_$CHPWD_PROFILE]} )) \
1569             && chpwd_leave_profile_${CHPWD_PROFILE}
1570     fi
1571     if (( reexecute )) || [[ $profile != $CHPWD_PROFILE ]]; then
1572         (( ${+functions[chpwd_profile_$profile]} )) && chpwd_profile_${profile}
1573     fi
1574
1575     CHPWD_PROFILE="${profile}"
1576     return 0
1577 }
1578
1579 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1580
1581 fi # is433
1582
1583 # Prompt setup for grml:
1584
1585 # set colors for use in prompts (modern zshs allow for the use of %F{red}foo%f
1586 # in prompts to get a red "foo" embedded, but it's good to keep these for
1587 # backwards compatibility).
1588 if zrcautoload colors && colors 2>/dev/null ; then
1589     BLUE="%{${fg[blue]}%}"
1590     RED="%{${fg_bold[red]}%}"
1591     GREEN="%{${fg[green]}%}"
1592     CYAN="%{${fg[cyan]}%}"
1593     MAGENTA="%{${fg[magenta]}%}"
1594     YELLOW="%{${fg[yellow]}%}"
1595     WHITE="%{${fg[white]}%}"
1596     NO_COLOR="%{${reset_color}%}"
1597 else
1598     BLUE=$'%{\e[1;34m%}'
1599     RED=$'%{\e[1;31m%}'
1600     GREEN=$'%{\e[1;32m%}'
1601     CYAN=$'%{\e[1;36m%}'
1602     WHITE=$'%{\e[1;37m%}'
1603     MAGENTA=$'%{\e[1;35m%}'
1604     YELLOW=$'%{\e[1;33m%}'
1605     NO_COLOR=$'%{\e[0m%}'
1606 fi
1607
1608 # First, the easy ones: PS2..4:
1609
1610 # secondary prompt, printed when the shell needs more information to complete a
1611 # command.
1612 PS2='\`%_> '
1613 # selection prompt used within a select loop.
1614 PS3='?# '
1615 # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
1616 PS4='+%N:%i:%_> '
1617
1618 # Some additional features to use with our prompt:
1619 #
1620 #    - battery status
1621 #    - debian_chroot
1622 #    - vcs_info setup and version specific fixes
1623
1624 # display battery status on right side of prompt via running 'BATTERY=1 zsh'
1625 if [[ $BATTERY -gt 0 ]] ; then
1626     if ! check_com -c acpi ; then
1627         BATTERY=0
1628     fi
1629 fi
1630
1631 battery() {
1632 if [[ $BATTERY -gt 0 ]] ; then
1633     PERCENT="${${"$(acpi 2>/dev/null)"}/(#b)[[:space:]]#Battery <->: [^0-9]##, (<->)%*/${match[1]}}"
1634     if [[ -z "$PERCENT" ]] ; then
1635         PERCENT='acpi not present'
1636     else
1637         if [[ "$PERCENT" -lt 20 ]] ; then
1638             PERCENT="warning: ${PERCENT}%%"
1639         else
1640             PERCENT="${PERCENT}%%"
1641         fi
1642     fi
1643 fi
1644 }
1645
1646 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
1647 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
1648     debian_chroot=$(</etc/debian_chroot)
1649 fi
1650
1651 # gather version control information for inclusion in a prompt
1652
1653 if zrcautoload vcs_info; then
1654     # `vcs_info' in zsh versions 4.3.10 and below have a broken `_realpath'
1655     # function, which can cause a lot of trouble with our directory-based
1656     # profiles. So:
1657     if [[ ${ZSH_VERSION} == 4.3.<-10> ]] ; then
1658         function VCS_INFO_realpath () {
1659             setopt localoptions NO_shwordsplit chaselinks
1660             ( builtin cd -q $1 2> /dev/null && pwd; )
1661         }
1662     fi
1663
1664     zstyle ':vcs_info:*' max-exports 2
1665
1666     if [[ -o restricted ]]; then
1667         zstyle ':vcs_info:*' enable NONE
1668     fi
1669 fi
1670
1671 # Change vcs_info formats for the grml prompt. The 2nd format sets up
1672 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
1673 # TODO: The included vcs_info() version still uses $VCS_INFO_message_N_.
1674 #       That needs to be the use of $VCS_INFO_message_N_ needs to be changed
1675 #       to $vcs_info_msg_N_ as soon as we use the included version.
1676 if [[ "$TERM" == dumb ]] ; then
1677     zstyle ':vcs_info:*' actionformats "(%s%)-[%b|%a] " "zsh: %r"
1678     zstyle ':vcs_info:*' formats       "(%s%)-[%b] "    "zsh: %r"
1679 else
1680     # these are the same, just with a lot of colors:
1681     zstyle ':vcs_info:*' actionformats "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOR} " \
1682                                        "zsh: %r"
1683     zstyle ':vcs_info:*' formats       "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOR}%} " \
1684                                        "zsh: %r"
1685     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YELLOW}%r"
1686 fi
1687
1688 # Now for the fun part: The grml prompt themes in `promptsys' mode of operation
1689
1690 # This actually defines three prompts:
1691 #
1692 #    - grml
1693 #    - grml-large
1694 #    - grml-chroot
1695 #
1696 # They all share the same code and only differ with respect to which items they
1697 # contain. The main source of documentation is the `prompt_grml_help' function
1698 # below, which gets called when the user does this: prompt -h grml
1699
1700 function prompt_grml_help () {
1701     cat <<__EOF0__
1702   prompt grml
1703
1704     This is the prompt as used by the grml-live system <http://grml.org>. It is
1705     a rather simple one-line prompt, that by default looks something like this:
1706
1707         <user>@<host> <current-working-directory>[ <vcs_info-data>]%
1708
1709     The prompt itself integrates with zsh's prompt themes system (as you are
1710     witnessing right now) and is configurable to a certain degree. In
1711     particular, these aspects are customisable:
1712
1713         - The items used in the prompt (e.g. you can remove \`user' from
1714           the list of activated items, which will cause the user name to
1715           be omitted from the prompt string).
1716
1717         - The attributes used with the items are customisable via strings
1718           used before and after the actual item.
1719
1720     The available items are: at, battery, change-root, date, grml-chroot,
1721     history, host, jobs, newline, path, percent, rc, rc-always, sad-smiley,
1722     shell-level, time, user, vcs
1723
1724     The actual configuration is done via zsh's \`zstyle' mechanism. The
1725     context, that is used while looking up styles is:
1726
1727         ':prompt:grml:<left-or-right>:<subcontext>'
1728
1729     Here <left-or-right> is either \`left' or \`right', signifying whether the
1730     style should affect the left or the right prompt. <subcontext> is either
1731     \`setup' or 'items:<item>', where \`<item>' is one of the available items.
1732
1733     The styles:
1734
1735         - use-rprompt (boolean): If \`true' (the default), print a sad smiley
1736           in $RPROMPT if the last command a returned non-successful error code.
1737           (This in only valid if <left-or-right> is "right"; ignored otherwise)
1738
1739         - items (list): The list of items used in the prompt. If \`vcs' is
1740           present in the list, the theme's code invokes \`vcs_info'
1741           accordingly. Default (left): rc change-root user at host path vcs
1742           percent; Default (right): sad-smiley
1743
1744     Available styles in 'items:<item>' are: pre, post. These are strings that
1745     are inserted before (pre) and after (post) the item in question. Thus, the
1746     following would cause the user name to be printed in red instead of the
1747     default blue:
1748
1749         zstyle ':prompt:grml:*:items:user' pre '%F{red}'
1750
1751     Note, that the \`post' style may remain at its default value, because its
1752     default value is '%f', which turns the foreground text attribute off (which
1753     is exactly, what is still required with the new \`pre' value).
1754 __EOF0__
1755 }
1756
1757 function prompt_grml-chroot_help () {
1758     cat <<__EOF0__
1759   prompt grml-chroot
1760
1761     This is a variation of the grml prompt, see: prompt -h grml
1762
1763     The main difference is the default value of the \`items' style. The rest
1764     behaves exactly the same. Here are the defaults for \`grml-chroot':
1765
1766         - left: grml-chroot user at host path percent
1767         - right: (empty list)
1768 __EOF0__
1769 }
1770
1771 function prompt_grml-large_help () {
1772     cat <<__EOF0__
1773   prompt grml-large
1774
1775     This is a variation of the grml prompt, see: prompt -h grml
1776
1777     The main difference is the default value of the \`items' style. In
1778     particular, this theme uses _two_ lines instead of one with the plain
1779     \`grml' theme. The rest behaves exactly the same. Here are the defaults
1780     for \`grml-large':
1781
1782         - left: rc jobs history shell-level change-root time date newline user
1783                 at host path vcs percent
1784         - right: sad-smiley
1785 __EOF0__
1786 }
1787
1788 function grml_prompt_setup () {
1789     emulate -L zsh
1790     autoload -Uz vcs_info
1791     autoload -Uz add-zsh-hook
1792     add-zsh-hook precmd prompt_$1_precmd
1793 }
1794
1795 function prompt_grml_setup () {
1796     grml_prompt_setup grml
1797 }
1798
1799 function prompt_grml-chroot_setup () {
1800     grml_prompt_setup grml-chroot
1801 }
1802
1803 function prompt_grml-large_setup () {
1804     grml_prompt_setup grml-large
1805 }
1806
1807 # These maps define default tokens and pre-/post-decoration for items to be
1808 # used within the themes. All defaults may be customised in a context sensitive
1809 # matter by using zsh's `zstyle' mechanism.
1810 typeset -gA grml_prompt_pre_default \
1811             grml_prompt_post_default \
1812             grml_prompt_token_default \
1813             grml_prompt_token_function
1814
1815 grml_prompt_pre_default=(
1816     at                ''
1817     battery           ' '
1818     change-root       ''
1819     date              '%F{blue}'
1820     grml-chroot       '%F{red}'
1821     history           '%F{green}'
1822     host              ''
1823     jobs              '%F{cyan}'
1824     newline           ''
1825     path              '%B'
1826     percent           ''
1827     rc                '%F{red}'
1828     rc-always         ''
1829     sad-smiley        ''
1830     shell-level       '%F{red}'
1831     time              '%F{blue}'
1832     user              '%B%F{blue}'
1833     vcs               ''
1834 )
1835
1836 grml_prompt_post_default=(
1837     at                ''
1838     battery           ''
1839     change-root       ''
1840     date              '%f'
1841     grml-chroot       '%f '
1842     history           '%f'
1843     host              ''
1844     jobs              '%f'
1845     newline           ''
1846     path              '%b'
1847     percent           ''
1848     rc                '%f'
1849     rc-always         ''
1850     sad-smiley        ''
1851     shell-level       '%f'
1852     time              '%f'
1853     user              '%f%b'
1854     vcs               ''
1855 )
1856
1857 grml_prompt_token_default=(
1858     at                '@'
1859     battery           'PERCENT'
1860     change-root       'debian_chroot'
1861     date              '%D{%Y-%m-%d}'
1862     grml-chroot       'GRML_CHROOT'
1863     history           '{history#%!} '
1864     host              '%m '
1865     jobs              '[%j running job(s)] '
1866     newline           $'\n'
1867     path              '%40<..<%~%<< '
1868     percent           '%# '
1869     rc                '%(?..%? )'
1870     rc-always         '%?'
1871     sad-smiley        '%(?..:()'
1872     shell-level       '%(3L.+ .)'
1873     time              '%D{%H:%M:%S} '
1874     user              '%n'
1875     vcs               '0'
1876 )
1877
1878 function GRML_theme_add_token_usage () {
1879     cat <<__EOF__
1880   Usage: grml_theme_add_token <name> [-f|-i] <token/function> [<pre> <post>]
1881
1882     <name> is the name for the newly added token. If the \`-f' or \`-i' options
1883     are used, <token/function> is the name of the function (see below for
1884     details). Otherwise it is the literal token string to be used. <pre> and
1885     <post> are optional.
1886
1887   Options:
1888
1889     -f <function>   Use a function named \`<function>' each time the token
1890                     is to be expanded.
1891
1892     -i <function>   Use a function named \`<function>' to initialise the
1893                     value of the token _once_ at runtime.
1894
1895     The functions are called with one argument: the token's new name. The
1896     return value is expected in the \$REPLY parameter. The use of these
1897     options is mutually exclusive.
1898
1899   Example:
1900
1901     To add a new token \`day' that expands to the current weekday in the
1902     current locale in green foreground colour, use this:
1903
1904       grml_theme_add_token day '%D{%A}' '%F{green}' '%f'
1905
1906     Another example would be support for \$VIRTUAL_ENV:
1907
1908       function virtual_env_prompt () {
1909         REPLY=\${VIRTUAL_ENV+\${VIRTUAL_ENV:t} }
1910       }
1911       grml_theme_add_token virtual-env -f virtual_env_prompt
1912
1913     After that, you will be able to use a changed \`items' style to
1914     assemble your prompt.
1915 __EOF__
1916 }
1917
1918 function grml_theme_add_token () {
1919     emulate -L zsh
1920     local name token pre post
1921     local -i init funcall
1922
1923     if (( ARGC == 0 )); then
1924         GRML_theme_add_token_usage
1925         return 0
1926     fi
1927
1928     init=0
1929     funcall=0
1930     pre=''
1931     post=''
1932     name=$1
1933     shift
1934     if [[ $1 == '-f' ]]; then
1935         funcall=1
1936         shift
1937     elif [[ $1 == '-i' ]]; then
1938         init=1
1939         shift
1940     fi
1941
1942     if (( ARGC == 0 )); then
1943         printf '
1944 grml_theme_add_token: No token-string/function-name provided!\n\n'
1945         GRML_theme_add_token_usage
1946         return 1
1947     fi
1948     token=$1
1949     shift
1950     if (( ARGC != 0 && ARGC != 2 )); then
1951         printf '
1952 grml_theme_add_token: <pre> and <post> need to by specified _both_!\n\n'
1953         GRML_theme_add_token_usage
1954         return 1
1955     fi
1956     if (( ARGC )); then
1957         pre=$1
1958         post=$2
1959         shift 2
1960     fi
1961
1962     if (( ${+grml_prompt_token_default[$name]} )); then
1963         printf '
1964 grml_theme_add_token: Token `%s'\'' exists! Giving up!\n\n' $name
1965         GRML_theme_add_token_usage
1966         return 2
1967     fi
1968     if (( init )); then
1969         $token $name
1970         token=$REPLY
1971     fi
1972     grml_prompt_pre_default[$name]=$pre
1973     grml_prompt_post_default[$name]=$post
1974     if (( funcall )); then
1975         grml_prompt_token_function[$name]=$token
1976         grml_prompt_token_default[$name]=23
1977     else
1978         grml_prompt_token_default[$name]=$token
1979     fi
1980 }
1981
1982 function grml_typeset_and_wrap () {
1983     emulate -L zsh
1984     local target="$1"
1985     local new="$2"
1986     local left="$3"
1987     local right="$4"
1988
1989     if (( ${+parameters[$new]} )); then
1990         typeset -g "${target}=${(P)target}${left}${(P)new}${right}"
1991     fi
1992 }
1993
1994 function grml_prompt_addto () {
1995     emulate -L zsh
1996     local target="$1"
1997     local lr it apre apost new v
1998     local -a items
1999     shift
2000
2001     [[ $target == PS1 ]] && lr=left || lr=right
2002     zstyle -a ":prompt:${grmltheme}:${lr}:setup" items items || items=( "$@" )
2003     typeset -g "${target}="
2004     for it in "${items[@]}"; do
2005         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" pre apre \
2006             || apre=${grml_prompt_pre_default[$it]}
2007         zstyle -s ":prompt:grml:${grmltheme}:${lr}:$it" post apost \
2008             || apost=${grml_prompt_post_default[$it]}
2009         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" token new \
2010             || new=${grml_prompt_token_default[$it]}
2011         typeset -g "${target}=${(P)target}${apre}"
2012         if (( ${+grml_prompt_token_function[$it]} )); then
2013             ${grml_prompt_token_function[$it]} $it
2014             typeset -g "${target}=${(P)target}${REPLY}"
2015         else
2016             case $it in
2017             battery)
2018                 grml_typeset_and_wrap $target $new '' ''
2019                 ;;
2020             change-root)
2021                 grml_typeset_and_wrap $target $new '(' ')'
2022                 ;;
2023             grml-chroot)
2024                 if [[ -n ${(P)new} ]]; then
2025                     typeset -g "${target}=${(P)target}(CHROOT)"
2026                 fi
2027                 ;;
2028             vcs)
2029                 v="vcs_info_msg_${new}_"
2030                 if (( ! vcscalled )); then
2031                     vcs_info
2032                     vcscalled=1
2033                 fi
2034                 if (( ${+parameters[$v]} )) && [[ -n "${(P)v}" ]]; then
2035                     typeset -g "${target}=${(P)target}${(P)v}"
2036                 fi
2037                 ;;
2038             *) typeset -g "${target}=${(P)target}${new}" ;;
2039             esac
2040         fi
2041         typeset -g "${target}=${(P)target}${apost}"
2042     done
2043 }
2044
2045 function prompt_grml_precmd () {
2046     emulate -L zsh
2047     local grmltheme=grml
2048     local -a left_items right_items
2049     left_items=(rc change-root user at host path vcs percent)
2050     right_items=(sad-smiley)
2051
2052     prompt_grml_precmd_worker
2053 }
2054
2055 function prompt_grml-chroot_precmd () {
2056     emulate -L zsh
2057     local grmltheme=grml-chroot
2058     local -a left_items right_items
2059     left_items=(grml-chroot user at host path percent)
2060     right_items=()
2061
2062     prompt_grml_precmd_worker
2063 }
2064
2065 function prompt_grml-large_precmd () {
2066     emulate -L zsh
2067     local grmltheme=grml-large
2068     local -a left_items right_items
2069     left_items=(rc jobs history shell-level change-root time date newline
2070                 user at host path vcs percent)
2071     right_items=(sad-smiley)
2072
2073     prompt_grml_precmd_worker
2074 }
2075
2076 function prompt_grml_precmd_worker () {
2077     emulate -L zsh
2078     local -i vcscalled=0
2079
2080     grml_prompt_addto PS1 "${left_items[@]}"
2081     if zstyle -T ":prompt:${grmltheme}:right:setup" use-rprompt; then
2082         grml_prompt_addto RPS1 "${right_items[@]}"
2083     fi
2084 }
2085
2086 grml_prompt_fallback() {
2087     setopt prompt_subst
2088     precmd() {
2089         (( ${+functions[vcs_info]} )) && vcs_info
2090     }
2091
2092     p0="${RED}%(?..%? )${WHITE}${debian_chroot:+($debian_chroot)}"
2093     p1="${BLUE}%n${NO_COLOR}@%m %40<...<%B%~%b%<< "'${vcs_info_msg_0_}'"%# "
2094     if (( EUID == 0 )); then
2095         PROMPT="${BLUE}${p0}${RED}${p1}"
2096     else
2097         PROMPT="${RED}${p0}${BLUE}${p1}"
2098     fi
2099     unset p0 p1
2100 }
2101
2102 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2103     # Since we define the required functions in here and not in files in
2104     # $fpath, we need to stick the theme's name into `$prompt_themes'
2105     # ourselves, since promptinit does not pick them up otherwise.
2106     prompt_themes+=( grml grml-chroot grml-large )
2107     # Also, keep the array sorted...
2108     prompt_themes=( "${(@on)prompt_themes}" )
2109 else
2110     print 'Notice: no promptinit available :('
2111     grml_prompt_fallback
2112 fi
2113
2114 if is437; then
2115     # The prompt themes use modern features of zsh, that require at least
2116     # version 4.3.7 of the shell. Use the fallback otherwise.
2117     if [[ $BATTERY -gt 0 ]]; then
2118         zstyle ':prompt:grml:right:setup' items sad-smiley battery
2119         add-zsh-hook precmd battery
2120     fi
2121     if [[ "$TERM" == dumb ]] ; then
2122         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" pre ''
2123         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" post ' '
2124         for i in rc user path jobs history date time shell-level; do
2125             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" pre ''
2126             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" post ''
2127         done
2128         unset i
2129         zstyle ':prompt:grml(|-large|-chroot):right:setup' use-rprompt false
2130     elif (( EUID == 0 )); then
2131         zstyle ':prompt:grml(|-large|-chroot):*:items:user' pre '%F{red}'
2132     fi
2133
2134     # Finally enable one of the prompts.
2135     if [[ -n $GRML_CHROOT ]]; then
2136         prompt grml-chroot
2137     elif [[ $GRMLPROMPT -gt 0 ]]; then
2138         prompt grml-large
2139     else
2140         prompt grml
2141     fi
2142 else
2143     grml_prompt_fallback
2144 fi
2145
2146 # Terminal-title wizardry
2147
2148 function ESC_print () {
2149     info_print $'\ek' $'\e\\' "$@"
2150 }
2151 function set_title () {
2152     info_print  $'\e]0;' $'\a' "$@"
2153 }
2154
2155 function info_print () {
2156     local esc_begin esc_end
2157     esc_begin="$1"
2158     esc_end="$2"
2159     shift 2
2160     printf '%s' ${esc_begin}
2161     printf '%s' "$*"
2162     printf '%s' "${esc_end}"
2163 }
2164
2165 function grml_reset_screen_title () {
2166     # adjust title of xterm
2167     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2168     [[ ${NOTITLE:-} -gt 0 ]] && return 0
2169     case $TERM in
2170         (xterm*|rxvt*)
2171             set_title ${(%):-"%n@%m: %~"}
2172             ;;
2173     esac
2174 }
2175
2176 function grml_vcs_to_screen_title () {
2177     if [[ $TERM == screen* ]] ; then
2178         if [[ -n ${vcs_info_msg_1_} ]] ; then
2179             ESC_print ${vcs_info_msg_1_}
2180         else
2181             ESC_print "zsh"
2182         fi
2183     fi
2184 }
2185
2186 function grml_maintain_name () {
2187     # set hostname if not running on host with name 'grml'
2188     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2189        NAME="@$HOSTNAME"
2190     fi
2191 }
2192
2193 function grml_cmd_to_screen_title () {
2194     # get the name of the program currently running and hostname of local
2195     # machine set screen window title if running in a screen
2196     if [[ "$TERM" == screen* ]] ; then
2197         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME"
2198         ESC_print ${CMD}
2199     fi
2200 }
2201
2202 function grml_control_xterm_title () {
2203     case $TERM in
2204         (xterm*|rxvt*)
2205             set_title "${(%):-"%n@%m:"}" "$1"
2206             ;;
2207     esac
2208 }
2209
2210 zrcautoload add-zsh-hook || add-zsh-hook () { :; }
2211 if [[ $NOPRECMD -eq 0 ]]; then
2212     add-zsh-hook precmd grml_reset_screen_title
2213     add-zsh-hook precmd grml_vcs_to_screen_title
2214     add-zsh-hook preexec grml_maintain_name
2215     add-zsh-hook preexec grml_cmd_to_screen_title
2216     if [[ $NOTITLE -eq 0 ]]; then
2217         add-zsh-hook preexec grml_control_xterm_title
2218     fi
2219 fi
2220
2221 # 'hash' some often used directories
2222 #d# start
2223 hash -d deb=/var/cache/apt/archives
2224 hash -d doc=/usr/share/doc
2225 hash -d linux=/lib/modules/$(command uname -r)/build/
2226 hash -d log=/var/log
2227 hash -d slog=/var/log/syslog
2228 hash -d src=/usr/src
2229 hash -d templ=/usr/share/doc/grml-templates
2230 hash -d tt=/usr/share/doc/texttools-doc
2231 hash -d www=/var/www
2232 #d# end
2233
2234 # some aliases
2235 if check_com -c screen ; then
2236     if [[ $UID -eq 0 ]] ; then
2237         if [[ -r /etc/grml/screenrc ]]; then
2238             alias screen="${commands[screen]} -c /etc/grml/screenrc"
2239         fi
2240     elif [[ -r $HOME/.screenrc ]] ; then
2241         alias screen="${commands[screen]} -c $HOME/.screenrc"
2242     else
2243         if [[ -r /etc/grml/screenrc_grml ]]; then
2244             alias screen="${commands[screen]} -c /etc/grml/screenrc_grml"
2245         else
2246             if [[ -r /etc/grml/screenrc ]]; then
2247                 alias screen="${commands[screen]} -c /etc/grml/screenrc"
2248             fi
2249         fi
2250     fi
2251 fi
2252
2253 # do we have GNU ls with color-support?
2254 if [[ "$TERM" != dumb ]]; then
2255     #a1# List files with colors (\kbd{ls -b -CF \ldots})
2256     alias ls='ls -b -CF '${ls_options:+"${ls_options[*]}"}
2257     #a1# List all files, with colors (\kbd{ls -la \ldots})
2258     alias la='ls -la '${ls_options:+"${ls_options[*]}"}
2259     #a1# List files with long colored list, without dotfiles (\kbd{ls -l \ldots})
2260     alias ll='ls -l '${ls_options:+"${ls_options[*]}"}
2261     #a1# List files with long colored list, human readable sizes (\kbd{ls -hAl \ldots})
2262     alias lh='ls -hAl '${ls_options:+"${ls_options[*]}"}
2263     #a1# List files with long colored list, append qualifier to filenames (\kbd{ls -lF \ldots})\\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2264     alias l='ls -lF '${ls_options:+"${ls_options[*]}"}
2265 else
2266     alias ls='ls -b -CF'
2267     alias la='ls -la'
2268     alias ll='ls -l'
2269     alias lh='ls -hAl'
2270     alias l='ls -lF'
2271 fi
2272
2273 alias mdstat='cat /proc/mdstat'
2274 alias ...='cd ../../'
2275
2276 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2277 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2278     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2279 fi
2280
2281 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2282 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2283 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2284
2285 # make sure it is not assigned yet
2286 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2287 utf2iso() {
2288     if isutfenv ; then
2289         for ENV in $(env | command grep -i '.utf') ; do
2290             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2291         done
2292     fi
2293 }
2294
2295 # make sure it is not assigned yet
2296 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2297 iso2utf() {
2298     if ! isutfenv ; then
2299         for ENV in $(env | command grep -i '\.iso') ; do
2300             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2301         done
2302     fi
2303 }
2304
2305 # especially for roadwarriors using GNU screen and ssh:
2306 if ! check_com asc &>/dev/null ; then
2307   asc() { autossh -t "$@" 'screen -RdU' }
2308   compdef asc=ssh
2309 fi
2310
2311 #f1# Hints for the use of zsh on grml
2312 zsh-help() {
2313     print "$bg[white]$fg[black]
2314 zsh-help - hints for use of zsh on grml
2315 =======================================$reset_color"
2316
2317     print '
2318 Main configuration of zsh happens in /etc/zsh/zshrc.
2319 That file is part of the package grml-etc-core, if you want to
2320 use them on a non-grml-system just get the tar.gz from
2321 http://deb.grml.org/ or (preferably) get it from the git repository:
2322
2323   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2324
2325 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2326 The file is still there, but it is empty for backwards compatibility.
2327
2328 For your own changes use these two files:
2329     $HOME/.zshrc.pre
2330     $HOME/.zshrc.local
2331
2332 The former is sourced very early in our zshrc, the latter is sourced
2333 very lately.
2334
2335 System wide configuration without touching configuration files of grml
2336 can take place in /etc/zsh/zshrc.local.
2337
2338 For information regarding zsh start at http://grml.org/zsh/
2339
2340 Take a look at grml'\''s zsh refcard:
2341 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2342
2343 Check out the main zsh refcard:
2344 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2345
2346 And of course visit the zsh-lovers:
2347 % man zsh-lovers
2348
2349 You can adjust some options through environment variables when
2350 invoking zsh without having to edit configuration files.
2351 Basically meant for bash users who are not used to the power of
2352 the zsh yet. :)
2353
2354   "NOCOR=1    zsh" => deactivate automatic correction
2355   "NOMENU=1   zsh" => do not use auto menu completion
2356                       (note: use ctrl-d for completion instead!)
2357   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2358   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2359                       preexec() and precmd() completely
2360   "BATTERY=1  zsh" => activate battery status (via acpi) on right side of prompt
2361   "COMMAND_NOT_FOUND=1 zsh"
2362                    => Enable a handler if an external command was not found
2363                       The command called in the handler can be altered by setting
2364                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2365                       "/usr/share/command-not-found/command-not-found"
2366
2367 A value greater than 0 is enables a feature; a value equal to zero
2368 disables it. If you like one or the other of these settings, you can
2369 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2370 zshrc.'
2371
2372     print "
2373 $bg[white]$fg[black]
2374 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2375 Enjoy your grml system with the zsh!$reset_color"
2376 }
2377
2378 # debian stuff
2379 if [[ -r /etc/debian_version ]] ; then
2380     #a3# Execute \kbd{apt-cache search}
2381     alias acs='apt-cache search'
2382     #a3# Execute \kbd{apt-cache show}
2383     alias acsh='apt-cache show'
2384     #a3# Execute \kbd{apt-cache policy}
2385     alias acp='apt-cache policy'
2386     #a3# Execute \kbd{apt-get dist-upgrade}
2387     salias adg="apt-get dist-upgrade"
2388     #a3# Execute \kbd{apt-get install}
2389     salias agi="apt-get install"
2390     #a3# Execute \kbd{aptitude install}
2391     salias ati="aptitude install"
2392     #a3# Execute \kbd{apt-get upgrade}
2393     salias ag="apt-get upgrade"
2394     #a3# Execute \kbd{apt-get update}
2395     salias au="apt-get update"
2396     #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2397     salias -a up="aptitude update ; aptitude safe-upgrade"
2398     #a3# Execute \kbd{dpkg-buildpackage}
2399     alias dbp='dpkg-buildpackage'
2400     #a3# Execute \kbd{grep-excuses}
2401     alias ge='grep-excuses'
2402
2403     # get a root shell as normal user in live-cd mode:
2404     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2405        alias su="sudo su"
2406      fi
2407
2408     #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog}
2409     salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2410     #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog}
2411     salias tlog="tail -f /var/log/syslog"    # follow the syslog
2412 fi
2413
2414 # sort installed Debian-packages by size
2415 if check_com -c dpkg-query ; then
2416     #a3# List installed Debian-packages sorted by size
2417     alias debs-by-size="dpkg-query -Wf 'x \${Installed-Size} \${Package} \${Status}\n' | sed -ne '/^x  /d' -e '/^x \(.*\) install ok installed$/s//\1/p' | sort -nr"
2418 fi
2419
2420 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2421 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2422     if check_com -c wodim; then
2423         cdrecord() {
2424             cat <<EOMESS
2425 cdrecord is not provided under its original name by Debian anymore.
2426 See #377109 in the BTS of Debian for more details.
2427
2428 Please use the wodim binary instead
2429 EOMESS
2430             return 1
2431         }
2432     fi
2433 fi
2434
2435 # Use hard limits, except for a smaller stack and no core dumps
2436 unlimit
2437 is425 && limit stack 8192
2438 isgrmlcd && limit core 0 # important for a live-cd-system
2439 limit -s
2440
2441 # grmlstuff
2442 grmlstuff() {
2443 # people should use 'grml-x'!
2444     if check_com -c 915resolution; then
2445         855resolution() {
2446             echo "Please use 915resolution as resolution modifying tool for Intel \
2447 graphic chipset."
2448             return -1
2449         }
2450     fi
2451
2452     #a1# Output version of running grml
2453     alias grml-version='cat /etc/grml_version'
2454
2455     if check_com -c grml-debootstrap ; then
2456         debian2hd() {
2457             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2458             return 1
2459         }
2460     fi
2461 }
2462
2463 # now run the functions
2464 isgrml && checkhome
2465 is4    && isgrml    && grmlstuff
2466 is4    && grmlcomp
2467
2468 # keephack
2469 is4 && xsource "/etc/zsh/keephack"
2470
2471 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2472 # You use it as follows:
2473 # $ NTREF=/reference/file
2474 # $ ls -l *(e:nt:)
2475 # This lists all the files in the current directory newer than the reference file.
2476 # You can also specify the reference file inline; note quotes:
2477 # $ ls -l *(e:'nt ~/.zshenv':)
2478 is4 && nt() {
2479     if [[ -n $1 ]] ; then
2480         local NTREF=${~1}
2481     fi
2482     [[ $REPLY -nt $NTREF ]]
2483 }
2484
2485 # shell functions
2486
2487 #f1# Reload an autoloadable function
2488 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2489 compdef _functions freload
2490
2491 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
2492 sll() {
2493     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
2494     for file in "$@" ; do
2495         while [[ -h "$file" ]] ; do
2496             ls -l $file
2497             file=$(readlink "$file")
2498         done
2499     done
2500 }
2501
2502 # TODO: Is it supported to use pager settings like this?
2503 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2504 # with respect to wordsplitting. (ie. ${=PAGER})
2505 if check_com -c $PAGER ; then
2506     #f3# View Debian's changelog of a given package
2507     dchange() {
2508         emulate -L zsh
2509         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
2510             $PAGER /usr/share/doc/$1/changelog.Debian.gz
2511         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2512             $PAGER /usr/share/doc/$1/changelog.gz
2513         else
2514             if check_com -c aptitude ; then
2515                 echo "No changelog for package $1 found, using aptitude to retrieve it."
2516                 if isgrml ; then
2517                     aptitude -t unstable changelog $1
2518                 else
2519                     aptitude changelog $1
2520                 fi
2521             else
2522                 echo "No changelog for package $1 found, sorry."
2523                 return 1
2524             fi
2525         fi
2526     }
2527     _dchange() { _files -W /usr/share/doc -/ }
2528     compdef _dchange dchange
2529
2530     #f3# View Debian's NEWS of a given package
2531     dnews() {
2532         emulate -L zsh
2533         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2534             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2535         else
2536             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2537                 $PAGER /usr/share/doc/$1/NEWS.gz
2538             else
2539                 echo "No NEWS file for package $1 found, sorry."
2540                 return 1
2541             fi
2542         fi
2543     }
2544     _dnews() { _files -W /usr/share/doc -/ }
2545     compdef _dnews dnews
2546
2547     #f3# View Debian's copyright of a given package
2548     dcopyright() {
2549         emulate -L zsh
2550         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2551             $PAGER /usr/share/doc/$1/copyright
2552         else
2553             echo "No copyright file for package $1 found, sorry."
2554             return 1
2555         fi
2556     }
2557     _dcopyright() { _files -W /usr/share/doc -/ }
2558     compdef _dcopyright dcopyright
2559
2560     #f3# View upstream's changelog of a given package
2561     uchange() {
2562         emulate -L zsh
2563         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2564             $PAGER /usr/share/doc/$1/changelog.gz
2565         else
2566             echo "No changelog for package $1 found, sorry."
2567             return 1
2568         fi
2569     }
2570     _uchange() { _files -W /usr/share/doc -/ }
2571     compdef _uchange uchange
2572 fi
2573
2574 # zsh profiling
2575 profile() {
2576     ZSH_PROFILE_RC=1 $SHELL "$@"
2577 }
2578
2579 #f1# Edit an alias via zle
2580 edalias() {
2581     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2582 }
2583 compdef _aliases edalias
2584
2585 #f1# Edit a function via zle
2586 edfunc() {
2587     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2588 }
2589 compdef _functions edfunc
2590
2591 # use it e.g. via 'Restart apache2'
2592 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
2593 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
2594 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
2595 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
2596 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
2597 #m# f6 Status() \kbd{/etc/init.d/\em{process}}\quad\kbd{status}
2598 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2599     __start_stop() {
2600         local action_="${1:l}"  # e.g Start/Stop/Restart
2601         local service_="$2"
2602         local param_="$3"
2603
2604         local service_target_="$(readlink /etc/init.d/$service_)"
2605         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2606             # runit
2607             case "${action_}" in
2608                 start) if [[ ! -e /etc/service/$service_ ]]; then
2609                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2610                        else
2611                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2612                        fi ;;
2613                 # there is no reload in runits sysv emulation
2614                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2615                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2616             esac
2617         else
2618             # sysvinit
2619             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2620         fi
2621     }
2622
2623     _grmlinitd() {
2624         local -a scripts
2625         scripts=( /etc/init.d/*(x:t) )
2626         _describe "service startup script" scripts
2627     }
2628
2629     for i in Start Restart Stop Force-Reload Reload Status ; do
2630         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
2631         compdef _grmlinitd $i
2632     done
2633 fi
2634
2635 #f1# Provides useful information on globbing
2636 H-Glob() {
2637     echo -e "
2638     /      directories
2639     .      plain files
2640     @      symbolic links
2641     =      sockets
2642     p      named pipes (FIFOs)
2643     *      executable plain files (0100)
2644     %      device files (character or block special)
2645     %b     block special files
2646     %c     character special files
2647     r      owner-readable files (0400)
2648     w      owner-writable files (0200)
2649     x      owner-executable files (0100)
2650     A      group-readable files (0040)
2651     I      group-writable files (0020)
2652     E      group-executable files (0010)
2653     R      world-readable files (0004)
2654     W      world-writable files (0002)
2655     X      world-executable files (0001)
2656     s      setuid files (04000)
2657     S      setgid files (02000)
2658     t      files with the sticky bit (01000)
2659
2660   print *(m-1)          # Files modified up to a day ago
2661   print *(a1)           # Files accessed a day ago
2662   print *(@)            # Just symlinks
2663   print *(Lk+50)        # Files bigger than 50 kilobytes
2664   print *(Lk-50)        # Files smaller than 50 kilobytes
2665   print **/*.c          # All *.c files recursively starting in \$PWD
2666   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2667   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2668   print *~*.*           # All Files that do not contain a dot
2669   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2670   print -l *(.c|.h)     # Lists *.c and *.h
2671   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2672   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2673 }
2674 alias help-zshglob=H-Glob
2675
2676 # grep for running process, like: 'any vim'
2677 any() {
2678     emulate -L zsh
2679     unsetopt KSH_ARRAYS
2680     if [[ -z "$1" ]] ; then
2681         echo "any - grep for process(es) by keyword" >&2
2682         echo "Usage: any <keyword>" >&2 ; return 1
2683     else
2684         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
2685     fi
2686 }
2687
2688
2689 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2690 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2691 [[ -r /proc/1/maps ]] && \
2692 deswap() {
2693     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2694     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2695     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2696 }
2697
2698 # a wrapper for vim, that deals with title setting
2699 #   VIM_OPTIONS
2700 #       set this array to a set of options to vim you always want
2701 #       to have set when calling vim (in .zshrc.local), like:
2702 #           VIM_OPTIONS=( -p )
2703 #       This will cause vim to send every file given on the
2704 #       commandline to be send to it's own tab (needs vim7).
2705 if check_com vim; then
2706     vim() {
2707         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
2708     }
2709 fi
2710
2711 # make a backup of a file
2712 bk() {
2713     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
2714 }
2715
2716 ssl_hashes=( sha512 sha256 sha1 md5 )
2717
2718 for sh in ${ssl_hashes}; do
2719     eval 'ssl-cert-'${sh}'() {
2720         emulate -L zsh
2721         if [[ -z $1 ]] ; then
2722             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
2723             return 1
2724         fi
2725         openssl x509 -noout -fingerprint -'${sh}' -in $1
2726     }'
2727 done; unset sh
2728
2729 ssl-cert-fingerprints() {
2730     emulate -L zsh
2731     local i
2732     if [[ -z $1 ]] ; then
2733         printf 'usage: ssl-cert-fingerprints <file>\n'
2734         return 1
2735     fi
2736     for i in ${ssl_hashes}
2737         do ssl-cert-$i $1;
2738     done
2739 }
2740
2741 ssl-cert-info() {
2742     emulate -L zsh
2743     if [[ -z $1 ]] ; then
2744         printf 'usage: ssl-cert-info <file>\n'
2745         return 1
2746     fi
2747     openssl x509 -noout -text -in $1
2748     ssl-cert-fingerprints $1
2749 }
2750
2751 # make sure our environment is clean regarding colors
2752 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
2753
2754 # "persistent history"
2755 # just write important commands you always need to ~/.important_commands
2756 if [[ -r ~/.important_commands ]] ; then
2757     fc -R ~/.important_commands
2758 fi
2759
2760 # load the lookup subsystem if it's available on the system
2761 zrcautoload lookupinit && lookupinit
2762
2763 # variables
2764
2765 # set terminal property (used e.g. by msgid-chooser)
2766 export COLORTERM="yes"
2767
2768 # aliases
2769
2770 # general
2771 #a2# Execute \kbd{du -sch}
2772 alias da='du -sch'
2773 #a2# Execute \kbd{jobs -l}
2774 alias j='jobs -l'
2775
2776 # listing stuff
2777 #a2# Execute \kbd{ls -lSrah}
2778 alias dir="ls -lSrah"
2779 #a2# Only show dot-directories
2780 alias lad='ls -d .*(/)'
2781 #a2# Only show dot-files
2782 alias lsa='ls -a .*(.)'
2783 #a2# Only files with setgid/setuid/sticky flag
2784 alias lss='ls -l *(s,S,t)'
2785 #a2# Only show symlinks
2786 alias lsl='ls -l *(@)'
2787 #a2# Display only executables
2788 alias lsx='ls -l *(*)'
2789 #a2# Display world-{readable,writable,executable} files
2790 alias lsw='ls -ld *(R,W,X.^ND/)'
2791 #a2# Display the ten biggest files
2792 alias lsbig="ls -flh *(.OL[1,10])"
2793 #a2# Only show directories
2794 alias lsd='ls -d *(/)'
2795 #a2# Only show empty directories
2796 alias lse='ls -d *(/^F)'
2797 #a2# Display the ten newest files
2798 alias lsnew="ls -rtlh *(D.om[1,10])"
2799 #a2# Display the ten oldest files
2800 alias lsold="ls -rtlh *(D.Om[1,10])"
2801 #a2# Display the ten smallest files
2802 alias lssmall="ls -Srl *(.oL[1,10])"
2803 #a2# Display the ten newest directories and ten newest .directories
2804 alias lsnewdir="ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
2805 #a2# Display the ten oldest directories and ten oldest .directories
2806 alias lsolddir="ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
2807
2808 # some useful aliases
2809 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir \$OLDCWD}
2810 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
2811
2812 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
2813 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2814 #a2# scp with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
2815 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2816
2817 # work around non utf8 capable software in utf environment via $LANG and luit
2818 if check_com isutfenv && check_com luit ; then
2819     if check_com -c mrxvt ; then
2820         isutfenv && [[ -n "$LANG" ]] && \
2821             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
2822     fi
2823
2824     if check_com -c aterm ; then
2825         isutfenv && [[ -n "$LANG" ]] && \
2826             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
2827     fi
2828
2829     if check_com -c centericq ; then
2830         isutfenv && [[ -n "$LANG" ]] && \
2831             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
2832     fi
2833 fi
2834
2835 # useful functions
2836
2837 #f5# Backup \kbd{file {\rm to} file\_timestamp}
2838 bk() {
2839     emulate -L zsh
2840     cp -b $1 $1_`date --iso-8601=m`
2841 }
2842
2843 #f5# cd to directoy and list files
2844 cl() {
2845     emulate -L zsh
2846     cd $1 && ls -a
2847 }
2848
2849 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
2850 cd() {
2851     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
2852         [[ ! -e ${1:h} ]] && return 1
2853         print "Correcting ${1} to ${1:h}"
2854         builtin cd ${1:h}
2855     else
2856         builtin cd "$@"
2857     fi
2858 }
2859
2860 #f5# Create Directoy and \kbd{cd} to it
2861 mkcd() {
2862     if (( ARGC != 1 )); then
2863         printf 'usage: mkcd <new-directory>\n'
2864         return 1;
2865     fi
2866     if [[ ! -d "$1" ]]; then
2867         command mkdir -p "$1"
2868     else
2869         printf '`%s'\'' already exists: cd-ing.\n' "$1"
2870     fi
2871     builtin cd "$1"
2872 }
2873
2874 #f5# Create temporary directory and \kbd{cd} to it
2875 cdt() {
2876     local t
2877     t=$(mktemp -d)
2878     echo "$t"
2879     builtin cd "$t"
2880 }
2881
2882 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
2883 accessed() {
2884     emulate -L zsh
2885     print -l -- *(a-${1:-1})
2886 }
2887
2888 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
2889 changed() {
2890     emulate -L zsh
2891     print -l -- *(c-${1:-1})
2892 }
2893
2894 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
2895 modified() {
2896     emulate -L zsh
2897     print -l -- *(m-${1:-1})
2898 }
2899 # modified() was named new() in earlier versions, add an alias for backwards compatibility
2900 check_com new || alias new=modified
2901
2902 # use colors when GNU grep with color-support
2903 #a2# Execute \kbd{grep -{}-color=auto}
2904 (( $#grep_options > 0 )) && alias grep='grep '${grep_options:+"${grep_options[*]}"}
2905
2906 # Translate DE<=>EN
2907 # 'translate' looks up fot a word in a file with language-to-language
2908 # translations (field separator should be " : "). A typical wordlist looks
2909 # like at follows:
2910 #  | english-word : german-transmission
2911 # It's also only possible to translate english to german but not reciprocal.
2912 # Use the following oneliner to turn back the sort order:
2913 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
2914 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
2915 #f5# Translates a word
2916 trans() {
2917     emulate -L zsh
2918     case "$1" in
2919         -[dD]*)
2920             translate -l de-en $2
2921             ;;
2922         -[eE]*)
2923             translate -l en-de $2
2924             ;;
2925         *)
2926             echo "Usage: $0 { -D | -E }"
2927             echo "         -D == German to English"
2928             echo "         -E == English to German"
2929     esac
2930 }
2931
2932 # Usage: simple-extract <file>
2933 # Using option -d deletes the original archive file.
2934 #f5# Smart archive extractor
2935 simple-extract() {
2936     emulate -L zsh
2937     setopt extended_glob noclobber
2938     local DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
2939     local RC=0
2940     zparseopts -D -E "d=DELETE_ORIGINAL"
2941     for ARCHIVE in "${@}"; do
2942         case $ARCHIVE in
2943             *(tar.bz2|tbz2|tbz))
2944                 DECOMP_CMD="tar -xvjf -"
2945                 USES_STDIN=true
2946                 USES_STDOUT=false
2947                 ;;
2948             *(tar.gz|tgz))
2949                 DECOMP_CMD="tar -xvzf -"
2950                 USES_STDIN=true
2951                 USES_STDOUT=false
2952                 ;;
2953             *(tar.xz|txz|tar.lzma))
2954                 DECOMP_CMD="tar -xvJf -"
2955                 USES_STDIN=true
2956                 USES_STDOUT=false
2957                 ;;
2958             *tar)
2959                 DECOMP_CMD="tar -xvf -"
2960                 USES_STDIN=true
2961                 USES_STDOUT=false
2962                 ;;
2963             *rar)
2964                 DECOMP_CMD="unrar x"
2965                 USES_STDIN=false
2966                 USES_STDOUT=false
2967                 ;;
2968             *lzh)
2969                 DECOMP_CMD="lha x"
2970                 USES_STDIN=false
2971                 USES_STDOUT=false
2972                 ;;
2973             *7z)
2974                 DECOMP_CMD="7z x"
2975                 USES_STDIN=false
2976                 USES_STDOUT=false
2977                 ;;
2978             *(zip|jar))
2979                 DECOMP_CMD="unzip"
2980                 USES_STDIN=false
2981                 USES_STDOUT=false
2982                 ;;
2983             *deb)
2984                 DECOMP_CMD="ar -x"
2985                 USES_STDIN=false
2986                 USES_STDOUT=false
2987                 ;;
2988             *bz2)
2989                 DECOMP_CMD="bzip2 -d -c -"
2990                 USES_STDIN=true
2991                 USES_STDOUT=true
2992                 ;;
2993             *(gz|Z))
2994                 DECOMP_CMD="gzip -d -c -"
2995                 USES_STDIN=true
2996                 USES_STDOUT=true
2997                 ;;
2998             *(xz|lzma))
2999                 DECOMP_CMD="xz -d -c -"
3000                 USES_STDIN=true
3001                 USES_STDOUT=true
3002                 ;;
3003             *)
3004                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
3005                 RC=$((RC+1))
3006                 continue
3007                 ;;
3008         esac
3009
3010         if ! check_com ${DECOMP_CMD[(w)1]}; then
3011             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
3012             RC=$((RC+2))
3013             continue
3014         fi
3015
3016         GZTARGET="${ARCHIVE:t:r}"
3017         if [[ -f $ARCHIVE ]] ; then
3018
3019             print "Extracting '$ARCHIVE' ..."
3020             if $USES_STDIN; then
3021                 if $USES_STDOUT; then
3022                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
3023                 else
3024                     ${=DECOMP_CMD} < "$ARCHIVE"
3025                 fi
3026             else
3027                 if $USES_STDOUT; then
3028                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
3029                 else
3030                     ${=DECOMP_CMD} "$ARCHIVE"
3031                 fi
3032             fi
3033             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
3034
3035         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
3036             if check_com curl; then
3037                 WGET_CMD="curl -L -k -s -o -"
3038             elif check_com wget; then
3039                 WGET_CMD="wget -q -O - --no-check-certificate"
3040             else
3041                 print "ERROR: neither wget nor curl is installed" >&2
3042                 RC=$((RC+4))
3043                 continue
3044             fi
3045             print "Downloading and Extracting '$ARCHIVE' ..."
3046             if $USES_STDIN; then
3047                 if $USES_STDOUT; then
3048                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
3049                     RC=$((RC+$?))
3050                 else
3051                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
3052                     RC=$((RC+$?))
3053                 fi
3054             else
3055                 if $USES_STDOUT; then
3056                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
3057                 else
3058                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
3059                 fi
3060             fi
3061
3062         else
3063             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
3064             RC=$((RC+8))
3065         fi
3066     done
3067     return $RC
3068 }
3069
3070 __archive_or_uri()
3071 {
3072     _alternative \
3073         '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)"' \
3074         '_urls:Remote Archives:_urls'
3075 }
3076
3077 _simple_extract()
3078 {
3079     _arguments \
3080         '-d[delete original archivefile after extraction]' \
3081         '*:Archive Or Uri:__archive_or_uri'
3082 }
3083 compdef _simple_extract simple-extract
3084 alias se=simple-extract
3085
3086 #f5# Set all ulimit parameters to \kbd{unlimited}
3087 allulimit() {
3088     ulimit -c unlimited
3089     ulimit -d unlimited
3090     ulimit -f unlimited
3091     ulimit -l unlimited
3092     ulimit -n unlimited
3093     ulimit -s unlimited
3094     ulimit -t unlimited
3095 }
3096
3097 #f5# Change the xterm title from within GNU-screen
3098 xtrename() {
3099     emulate -L zsh
3100     if [[ $1 != "-f" ]] ; then
3101         if [[ -z ${DISPLAY} ]] ; then
3102             printf 'xtrename only makes sense in X11.\n'
3103             return 1
3104         fi
3105     else
3106         shift
3107     fi
3108     if [[ -z $1 ]] ; then
3109         printf 'usage: xtrename [-f] "title for xterm"\n'
3110         printf '  renames the title of xterm from _within_ screen.\n'
3111         printf '  also works without screen.\n'
3112         printf '  will not work if DISPLAY is unset, use -f to override.\n'
3113         return 0
3114     fi
3115     print -n "\eP\e]0;${1}\C-G\e\\"
3116     return 0
3117 }
3118
3119 # Create small urls via http://goo.gl using curl(1).
3120 # API reference: https://code.google.com/apis/urlshortener/
3121 function zurl() {
3122     emulate -L zsh
3123     setopt extended_glob
3124
3125     if [[ -z $1 ]]; then
3126         print "USAGE: zurl <URL>"
3127         return 1
3128     fi
3129
3130     local PN url prog api json contenttype item
3131     local -a data
3132     PN=$0
3133     url=$1
3134
3135     # Prepend 'http://' to given URL where necessary for later output.
3136     if [[ ${url} != http(s|)://* ]]; then
3137         url='http://'${url}
3138     fi
3139
3140     if check_com -c curl; then
3141         prog=curl
3142     else
3143         print "curl is not available, but mandatory for ${PN}. Aborting."
3144         return 1
3145     fi
3146     api='https://www.googleapis.com/urlshortener/v1/url'
3147     contenttype="Content-Type: application/json"
3148     json="{\"longUrl\": \"${url}\"}"
3149     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
3150     # Parse the response
3151     for item in "${data[@]}"; do
3152         case "$item" in
3153             ' '#'"id":'*)
3154                 item=${item#*: \"}
3155                 item=${item%\",*}
3156                 printf '%s\n' "$item"
3157                 return 0
3158                 ;;
3159         esac
3160     done
3161     return 1
3162 }
3163
3164 #f2# Find history events by search pattern and list them by date.
3165 whatwhen()  {
3166     emulate -L zsh
3167     local usage help ident format_l format_s first_char remain first last
3168     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3169     help='Use `whatwhen -h'\'' for further explanations.'
3170     ident=${(l,${#${:-Usage: }},, ,)}
3171     format_l="${ident}%s\t\t\t%s\n"
3172     format_s="${format_l//(\\t)##/\\t}"
3173     # Make the first char of the word to search for case
3174     # insensitive; e.g. [aA]
3175     first_char=[${(L)1[1]}${(U)1[1]}]
3176     remain=${1[2,-1]}
3177     # Default search range is `-100'.
3178     first=${2:-\-100}
3179     # Optional, just used for `<first> <last>' given.
3180     last=$3
3181     case $1 in
3182         ("")
3183             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3184             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3185         ;;
3186         (-h)
3187             printf '%s\n\n' ${usage}
3188             print 'OPTIONS:'
3189             printf $format_l '-h' 'show help text'
3190             print '\f'
3191             print 'SEARCH RANGE:'
3192             printf $format_l "'0'" 'the whole history,'
3193             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3194             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3195             printf '\n%s\n' 'EXAMPLES:'
3196             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3197             printf $format_l 'whatwhen zsh -250'
3198             printf $format_l 'whatwhen foo 1 99'
3199         ;;
3200         (\?)
3201             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3202         ;;
3203         (*)
3204             # -l list results on stout rather than invoking $EDITOR.
3205             # -i Print dates as in YYYY-MM-DD.
3206             # -m Search for a - quoted - pattern within the history.
3207             fc -li -m "*${first_char}${remain}*" $first $last
3208         ;;
3209     esac
3210 }
3211
3212 # mercurial related stuff
3213 if check_com -c hg ; then
3214     # gnu like diff for mercurial
3215     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3216     #f5# GNU like diff for mercurial
3217     hgdi() {
3218         emulate -L zsh
3219         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3220     }
3221
3222     # build debian package
3223     #a2# Alias for \kbd{hg-buildpackage}
3224     alias hbp='hg-buildpackage'
3225
3226     # execute commands on the versioned patch-queue from the current repos
3227     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3228
3229     # diffstat for specific version of a mercurial repository
3230     #   hgstat      => display diffstat between last revision and tip
3231     #   hgstat 1234 => display diffstat between revision 1234 and tip
3232     #f5# Diffstat for specific version of a mercurial repos
3233     hgstat() {
3234         emulate -L zsh
3235         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3236     }
3237
3238 fi # end of check whether we have the 'hg'-executable
3239
3240 # grml-small cleanups
3241
3242 # The following is used to remove zsh-config-items that do not work
3243 # in grml-small by default.
3244 # If you do not want these adjustments (for whatever reason), set
3245 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3246 # sources if it is there).
3247
3248 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3249
3250     unset abk[V]
3251     unalias    'V'      &> /dev/null
3252     unfunction vman     &> /dev/null
3253     unfunction viless   &> /dev/null
3254     unfunction 2html    &> /dev/null
3255
3256     # manpages are not in grmlsmall
3257     unfunction manzsh   &> /dev/null
3258     unfunction man2     &> /dev/null
3259
3260 fi
3261
3262 zrclocal
3263
3264 ## genrefcard.pl settings
3265
3266 ### doc strings for external functions from files
3267 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3268
3269 ### example: split functions-search 8,16,24,32
3270 #@# split functions-search 8
3271
3272 ## END OF FILE #################################################################
3273 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3274 # Local variables:
3275 # mode: sh
3276 # End: