Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
International Rescue Committe

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
Copyright Info
Terms of Use
Privacy Info
Masthead / Impressum
Your Account

Private Messages

News Archive
Submit News
User Articles
Web Links


The Web

Who's Online
There are currently, 182 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here




       The  Zsh  source  distribution  includes a number of items
       contributed by the user community.  These are  not  inher­
       ently  a  part of the shell, and some may not be available
       in every zsh installation.  The most significant of  these
       are  documented  here.   For  documentation  on other con­
       tributed items such as shell functions, look for  comments
       in the function source files.


   Accessing On-Line Help
       The key sequence ESC h is normally bound by ZLE to execute
       the run-help widget (see  zshzle(1)).   This  invokes  the
       run-help  command  with  the command word from the current
       input line as its argument.  By default,  run-help  is  an
       alias  for  the  man command, so this often fails when the
       command word is a shell builtin or  a  user-defined  func­
       tion.   By  redefining the run-help alias, one can improve
       the on-line help provided by the shell.

       The helpfiles utility, found in the Util directory of  the
       distribution,  is  a Perl program that can be used to pro­
       cess the zsh manual to produce a separate  help  file  for
       each  shell  builtin  and for many other shell features as
       well.  The autoloadable run-help function, found in  Func­
       tions/Misc, searches for these helpfiles and performs sev­
       eral other tests to produce the most complete help  possi­
       ble for the command.

       There  may  already  be  a directory of help files on your
       system; look in /usr/share/zsh or /usr/local/share/zsh and
       subdirectories below those, or ask your system administra­

       To create your own help files with  helpfiles,  choose  or
       create a directory where the individual command help files
       will reside.  For example, you  might  choose  ~/zsh_help.
       If  you  unpacked the zsh distribution in your home direc­
       tory, you would use the commands:

              mkdir ~/zsh_help
              cd ~/zsh_help
              man zshall | colcrt - | \
              perl ~/zsh-4.1.1/Util/helpfiles

       Next, to use the run-help function, you need to add  lines
       something  like the following to your .zshrc or equivalent
       startup file:

              unalias run-help

   Recompiling Functions
       If you frequently edit your zsh functions, or periodically
       update  your zsh installation to track the latest develop­
       ments, you may find that function  digests  compiled  with
       the  zcompile  builtin  are  frequently  out  of date with
       respect to the function source files.  This is not usually
       a  problem,  because  zsh always looks for the newest file
       when loading a function, but it  may  cause  slower  shell
       startup  and  function loading.  Also, if a digest file is
       explicitly used as an element of fpath,  zsh  won't  check
       whether any of its source files has changed.

       The  zrecompile  autoloadable  function,  found  in  Func­
       tions/Misc, can be used to keep  function  digests  up  to

       zrecompile [ -qt ] [ name ... ]
       zrecompile [ -qt ] -p args [ -- args ... ]
              This  tries  to  find *.zwc files and automatically
              re-compile them if at least  one  of  the  original
              files  is newer than the compiled file.  This works
              only if the names stored in the compiled files  are
              full  paths  or  are relative to the directory that
              contains the .zwc file.

              In the first form, each name is the name of a  com­
              piled  file  or  a directory containing *.zwc files
              that should be checked.  If no arguments are given,
              the  directories and *.zwc files in fpath are used.

              When -t is given, no compilation is performed,  but
              a  return status of zero (true) is set if there are
              files that need  to  be  re-compiled  and  non-zero
              (false) otherwise.  The -q option quiets the chatty
              output that describes what zrecompile is doing.

              Without the -t option, the return status is zero if
              all  files that needed re-compilation could be com­
              piled and non-zero if compilation for at least  one
              of the files failed.

              If the -p option is given, the args are interpreted
              as one or more sets of arguments for zcompile, sep­
              arated by `--'.  For example:

                     zrecompile -p \
                                -R ~/.zshrc -- \
                                -M ~/.zcompdump -- \
                                ~/zsh/comp.zwc ~/zsh/Completion/*/_*

       creating function digests for all functions in your fpath,
       assuming that you have write permission  to  the  directo­

              for ((i=1; i <= $#fpath; ++i)); do
                if [[ $dir == (.|..) || $dir == (.|..)/* ]]; then
                if [[ -w $dir:h && -n $files ]]; then
                  if ( cd $dir:h &&
                       zrecompile -p -U -z $zwc $files ); then

       The -U and -z options are appropriate for functions in the
       default zsh installation fpath; you may need to  use  dif­
       ferent options for your personal function directories.

       Once the digests have been created and your fpath modified
       to refer to them, you can keep them up to date by  running
       zrecompile with no arguments.

   Keyboard Definition
       The  large  number  of possible combinations of keyboards,
       workstations, terminals,  emulators,  and  window  systems
       makes  it impossible for zsh to have built-in key bindings
       for every situation.  The zkbd  utility,  found  in  Func­
       tions/Misc,  can  help you quickly create key bindings for
       your configuration.

       Run zkbd either as an autoloaded function, or as  a  shell

              zsh -f ~/zsh-4.1.1/Functions/Misc/zkbd

       When  you run zkbd, it first asks you to enter your termi­
       nal type; if the default it offers is correct, just  press
       return.   It  then asks you to press a number of different
       keys to determine characteristics  of  your  keyboard  and
       terminal;  zkbd  warns you if it finds anything out of the
       ordinary, such as a Delete key that sends neither  ^H  nor

       The  keystrokes  read by zkbd are recorded as a definition
       for an associative array named key, written to a  file  in
       file must be in one of the directories named in your fpath
       array  (see zshparam(1)).  This should already be the case
       if you have a standard zsh installation;  if  it  is  not,
       copy Functions/Misc/zkbd to an appropriate directory.

   Dumping Shell State
       Occasionally you may encounter what appears to be a bug in
       the shell, particularly if you are using a beta version of
       zsh or a development release.  Usually it is sufficient to
       send a description of the problem to one of the zsh  mail­
       ing  lists  (see  zsh(1)),  but  sometimes  one of the zsh
       developers will need to recreate your environment in order
       to track the problem down.

       The  script named reporter, found in the Util directory of
       the distribution, is provided for this  purpose.   (It  is
       also  possible  to  autoload reporter, but reporter is not
       installed in fpath by default.)   This  script  outputs  a
       detailed  dump  of the shell state, in the form of another
       script that can be read with `zsh  -f'  to  recreate  that

       To  use reporter, read the script into your shell with the
       `.'  command and redirect the output into a file:

              . ~/zsh-4.1.1/Util/reporter > zsh.report

       You should check the zsh.report  file  for  any  sensitive
       information  such  as  passwords  and  delete them by hand
       before sending the script to the developers.  Also, as the
       output can be voluminous, it's best to wait for the devel­
       opers to ask for this information before sending it.

       You can also use reporter to dump only  a  subset  of  the
       shell  state.   This  is  sometimes  useful  for  creating
       startup files for the first time.  Most of the output from
       reporter  is  far  more detailed than usually is necessary
       for a startup file, but the aliases, options, and  zstyles
       states  may  be  useful  because they include only changes
       from the defaults.  The bindings state may  be  useful  if
       you have created any of your own keymaps, because reporter
       arranges to dump the keymap creation commands as  well  as
       the bindings for every keymap.

       As  is usual with automated tools, if you create a startup
       file with reporter, you should edit the results to  remove
       unnecessary  commands.   Note that if you're using the new
       completion system, you should not dump the functions state
       to  your  startup  files  with  reporter; use the compdump
       function instead (see zshcompsys(1)).

                     Output autoloads and function definitions.
              limits Output limit commands.
                     Output setopt commands.
              styles Same as zstyles.
                     Output  shell  parameter  assignments,  plus
                     export  commands  for  any environment vari­
                     Output zstyle commands.

              If the state is omitted, all is assumed.

       With the exception of `all', every state can  be  abbrevi­
       ated  by  any  prefix, even a single letter; thus a is the
       same as aliases, z is the same as zstyles, etc.


       You should make sure all  the  functions  from  the  Func­
       tions/Prompts  directory  of  the  source distribution are
       available; they all begin with the string `prompt_' except
       for  the  special function`promptinit'.  You also need the
       `colors' function from Functions/Misc.  All of these func­
       tions  may  already have been installed on your system; if
       not, you will need to find them and copy them.  The direc­
       tory  should  appear  as  one of the elements of the fpath
       array (this should  already  be  the  case  if  they  were
       installed), and at least the function promptinit should be
       autoloaded; it will autoload the rest.  Finally,  to  ini­
       tialize  the use of the system you need to call the promp­
       tinit function.  The following code in  your  .zshrc  will
       arrange  for  this; assume the functions are stored in the
       directory ~/myfns:

              fpath=(~/myfns $fpath)
              autoload -U promptinit

   Theme Selection
       Use the prompt command to  select  your  preferred  theme.
       This  command  may  be  added to your .zshrc following the
       call to promptinit in order to  start  zsh  with  a  theme
       already selected.

       prompt [ -c | -l ]
       prompt [ -p | -h ] [ theme ... ]
       prompt [ -s ] theme [ arg ... ]
              Set  or  examine the prompt theme.  With no options
              -c     Show the currently selected  theme  and  its
                     parameters, if any.
              -l     List all available prompt themes.
              -p     Preview  the  theme  named  by theme, or all
                     themes if no theme is given.
              -h     Show help for the theme named by  theme,  or
                     for  the  prompt  function  if  no  theme is
              -s     Set theme as  the  current  theme  and  save

              Each  available theme has a setup function which is
              called by  the  prompt  function  to  install  that
              theme.  This function may define other functions as
              necessary to maintain the prompt,  including  func­
              tions  used  to  preview the prompt or provide help
              for its  use.   You  should  not  normally  call  a
              theme's setup function directly.


       These  functions  all  implement  user-defined ZLE widgets
       (see zshzle(1)) which can be bound to keystrokes in inter­
       active  shells.   To  use them, your .zshrc should contain
       lines of the form

              autoload function
              zle -N function

       followed by an appropriate bindkey  command  to  associate
       the  function with a key sequence.  Suggested bindings are
       described below.

       bash-style word functions
              If you are looking for functions to implement  mov­
              ing  over  and editing words in the manner of bash,
              where only alphanumeric characters  are  considered
              word   characters,   you   can  use  the  functions
              described in the next section.   The  following  is

                     autoload -U select-word-style
                     select-word-style bash

       forward-word-match, backward-word-match
       kill-word-match, backward-kill-word-match
       transpose-words-match, capitalize-word-match
       up-case-word-match, down-case-word-match
       select-word-style, match-word-by-style
              builtin  versions, so they do not need to be loaded

              The word styles available are as follows.  Only the
              first character is examined.

              bash   Word  characters are alphanumeric characters

              normal As in normal shell operation:  word  charac­
                     ters  are  alphanumeric  characters plus any
                     characters present in the  string  given  by
                     the parameter $WORDCHARS.

              shell  Words  are complete shell command arguments,
                     possibly including complete quoted  strings,
                     or any tokens special to the shell.

                     Words are any set of characters delimited by

                     Restore the default settings; this  is  usu­
                     ally the same as `normal'.

              More  control can be obtained using the zstyle com­
              mand, as described in zshmodules(1).  Each style is
              looked  up  in the context :zle:widget where widget
              is the name of the  user-defined  widget,  not  the
              name  of  the  function  implementing it, so in the
              case    of    the    definitions    supplied     by
              select-word-style   the  appropriate  contexts  are
              :zle:forward-word,  and  so   on.    The   function
              select-word-style  itself always defines styles for
              the context `:zle:*' which  can  be  overridden  by
              more specific (longer) patterns as well as explicit

              The style word-style specifies the  rules  to  use.
              This may have the following values.

              normal Use  the standard shell rules, i.e. alphanu­
                     merics and $WORDCHARS, unless overridden  by
                     the styles word-chars or word-class.

                     Similar  to  normal,  but only the specified
                     characters, and not also alphanumerics,  are
                     considered word characters.

              The first three of those styles usually use  $WORD­
              CHARS,  but the value in the parameter can be over­
              ridden by the  style  word-chars,  which  works  in
              exactly  the  same way as $WORDCHARS.  In addition,
              the style word-class uses character class syntax to
              group   characters   and   takes   precedence  over
              word-chars if both are set.  The  word-class  style
              does  not  include  the surrounding brackets of the
              character class; for example,  `-:[:alnum:]'  is  a
              valid  word-class to include all alphanumerics plus
              the characters `-' and `:'.  Be  careful  including
              `]',  `^' and `-' as these are special inside char­
              acter classes.

              The final style is skip-chars.  This is mostly use­
              ful  for transpose-words and similar functions.  If
              set, it gives a count of characters starting at the
              cursor  position  which will not be considered part
              of the word and are treated as space, regardless of
              what they actually are.  For example, if

                     zstyle ':zle:transpose-words' skip-chars 1

              has  been  set, and transpose-words-match is called
              with the cursor on the X of fooXbar, where X can be
              any  character,  then  the  resulting expression is

              The word matching and all the  handling  of  zstyle
              settings  is  actually  implemented by the function
              match-word-by-style.  This can be  used  to  create
              new  user-defined  widgets.   The  calling function
              should  set  the  local  parameter  curcontext   to
              :zle:widget,    create    the    local    parameter
              matched_words and call match-word-by-style with  no
              arguments.  On return, matched_words will be set to
              an array with the elements: (1) the  start  of  the
              line  (2)  the  word  before  the  cursor  (3)  any
              non-word characters between that word and the  cur­
              sor  (4) any non-word character at the cursor posi­
              tion plus any remaining non-word characters  before
              the  next  word, including all characters specified
              by the skip-chars style, (5) the word at or follow­
              ing  the cursor (6) any non-word characters follow­
              ing that word (7) the remainder of the  line.   Any
              of the elements may be an empty string; the calling
              function should test for this to decide whether  it
              can perform its function.

              This   widget   works   like   a   combination   of
              insert-last-word     and      copy-prev-shell-word.
              called  to retrieve words.  This widget must accept
              the same three arguments as insert-last-word.

              After inserting an unambiguous string into the com­
              mand line, the new function based completion system
              may know about multiple places in this string where
              characters  are missing or differ from at least one
              of the possible matches.  It will  then  place  the
              cursor  on the position it considers to be the most
              interesting one, i.e. the one where one can  disam­
              biguate between as many matches as possible with as
              little typing as possible.

              This widget allows the cursor to be easily moved to
              the  other  interesting  spots.   It can be invoked
              repeatedly to cycle between all positions  reported
              by the completion system.

              Edit  the command line using your visual editor, as
              in ksh.

                     bindkey -M vicmd v edit-command-line

              This function implements the widgets history-begin­
              ning-search-backward-end     and     history-begin­
              ning-search-forward-end.  These  commands  work  by
              first calling the corresponding builtin widget (see
              `History Control' in zshzle(1)) and then moving the
              cursor to the end of the line.  The original cursor
              position is remembered and restored before  calling
              the  builtin widget a second time, so that the same
              search is repeated to look farther through the his­

              Although  you  autoload only one function, the com­
              mands to use it are slightly different  because  it
              implements two widgets.

                     zle -N history-beginning-search-backward-end \
                     zle -N history-beginning-search-forward-end \
                     bindkey '\e^P' history-beginning-search-backward-end
                     bindkey '\e^N' history-beginning-search-forward-end

       up-line-or-beginning-search, down-line-or-beginning-search
              These  widgets are similar to the builtin functions
              up-line-or-search and down-line-or-search:  if in a
              multiline  buffer  they  move up or down within the
              incarg may be set to change the  default  increment
              something other than one.

                     bindkey '^X+' incarg

              This  allows  incremental  completion  of  a  word.
              After starting this command, a list  of  completion
              choices  can  be  shown  after  every character you
              type, which you can delete with ^H or DEL.   Press­
              ing  return  accepts  the  completion  so  far  and
              returns you to normal editing (that is, the command
              line is not immediately executed).  You can hit TAB
              to do normal completion, ^G to abort  back  to  the
              state when you started, and ^D to list the matches.

              This works only with the new function based comple­
              tion system.

                     bindkey '^Xi' incremental-complete-word

              This  function  allows you type a file pattern, and
              see the results of  the  expansion  at  each  step.
              When  you  hit  return, all expansions are inserted
              into the command line.

                     bindkey '^Xf' insert-files

       narrow-to-region [ -p pre ] [ -P post ]
           [ -S statepm | -R statepm ] [ -n ] [ start end ])
              Narrow the editable portion of the  buffer  to  the
              region  between  the cursor and the mark, which may
              be in either order.  The region may not be empty.

              narrow-to-region may be used as a widget or  called
              as  a  function  from  a  user-defined  widget;  by
              default, the text outside the editable area remains
              visible.   A  recursive-edit  is  performed and the
              original widening status is then restored.  Various
              options  and  arguments  are  available  when it is
              called as a function.

              The options -p pretext and -P posttext may be  used
              to  replace  the  text before and after the display
              for the duration of the function;  either  or  both
              may be an empty string.

              If the option -n is also given, pretext or posttext
              will only be inserted if there is  text  before  or
              after  the  region  respectively which will be made
              option -S, perform its own editing on  the  command
              line  or  pass  control to the user via `zle recur­
              sive-edit', then call this function with the option
              -R.   The  argument statepm must be a suitable name
              for an ordinary parameter, except  that  parameters
              beginning  with  the  prefix _ntr_ are reserved for
              use within narrow-to-region.  Typically the parame­
              ter will be local to the calling function.

              narrow-to-region-invisible is a simple widget which
              calls narrow-to-region with arguments which replace
              any text outside the region with `...'.

              The  display  is  restored (and the widget returns)
              upon any zle command which would usually cause  the
              line  to  be  accepted  or aborted.  Hence an addi­
              tional such command is required to accept or  abort
              the current line.

              The  return  status  of both widgets is zero if the
              line was accepted, else non-zero.

              Here is a trivial example of a  widget  using  this
                     local state
                     narrow-to-region -p $'Editing restricted region\n' \
                       -P '' -S state
                     zle recursive-edit
                     narrow-to-region -R state

              This  set of functions implements predictive typing
              using history  search.   After  predict-on,  typing
              characters  causes  the  editor to look backward in
              the history for the first line beginning with  what
              you  have typed so far.  After predict-off, editing
              returns to normal for the line found.  In fact, you
              often  don't  even need to use predict-off, because
              if the line doesn't match something in the history,
              adding a key performs standard completion, and then
              inserts itself if no completions were found.   How­
              ever,  editing in the middle of a line is liable to
              confuse prediction; see the toggle style below.

              With the function based completion system (which is
              needed for this), you should be able to type TAB at
              almost any point to advance the cursor to the  next
              ``interesting'' character position (usually the end
              of the current word, but sometimes somewhere in the
              middle  of the word).  And of course as soon as the
              entire line is what you want, you can  accept  with
              return,  without  needing to move the cursor to the

              Although you autoload only the predict-on function,
              it  is  necessary  to  create a keybinding for pre­
              dict-off as well.

                     zle -N predict-on
                     zle -N predict-off
                     bindkey '^X^Z' predict-on
                     bindkey '^Z' predict-off

              This is most useful when called as a function  from
              inside  a widget, but will work correctly as a wid­
              get in its own right.  It prompts for a value below
              the  current  command  line;  a  value may be input
              using all of the standard zle operations  (and  not
              merely the restricted set available when executing,
              for example, execute-named-cmd).  The value is then
              returned  to  the calling function in the parameter
              $REPLY and the editing buffer restored to its  pre­
              vious state.  If the read was aborted by a keyboard
              break (typically ^G), the function returns status 1
              and  $REPLY is not set.  If an argument is supplied
              to the function it is taken as a prompt,  otherwise
              `? ' is used.

              One  option  is  available: `-k num' specifies that
              num characters are to be read instead  of  a  whole
              line.   The  line editor is not invoked recursively
              in this case.  Note that unlike  the  read  builtin
              num must be given; there is no default.

              The  name  is  a  slight  misnomer,  as in fact the
              shell's own minibuffer is not used.   Hence  it  is
              still possible to call executed-named-cmd and simi­
              lar functions while reading a value.

       replace-string, replace-pattern
              The function replace-string implements two widgets.
              If  defined under the same name as the function, it
              prompts for two strings; the first (source)  string
              will be replaced by the second everywhere it occurs
              in the line editing buffer.

              If the widget name contains the word `pattern', for
              example  by  defining  the widget using the command
              `zle -N replace-pattern replace-string',  then  the
              replacement  is  done by pattern matching.  All zsh
              extended globbing  patterns  can  be  used  in  the
              source string; note that unlike filename generation
              the pattern does not need to match an entire  word,
              nor  do  glob qualifiers have any effect.  In addi­
              the not very useful line:

                     print This line contains car and cord

              The range of the replacement string can be  limited
              by  using  the  narrow-to-region-invisible  widget.
              One limitation of the current version is that  undo
              will  cycle  through changes to the replacement and
              source  strings  before  undoing  the   replacement

              This function may replace the insert-last-word wid­
              get, like so:

                     zle -N insert-last-word smart-insert-last-word

              With a numeric prefix, or when passed command  line
              arguments in a call from another widget, it behaves
              like insert-last-word, except that  words  in  com­
              ments are ignored when INTERACTIVE_COMMENTS is set.

              Otherwise, the rightmost ``interesting'' word  from
              the  previous  command  is found and inserted.  The
              default definition of ``interesting'' is  that  the
              word  contains  at  least one alphabetic character,
              slash, or backslash.  This definition may be  over­
              ridden by use of the match style.  The context used
              to look up the style is the widget name, so usually
              the context is :insert-last-word.  However, you can
              bind this function to different widgets to use dif­
              ferent patterns:

                     zle -N insert-last-assignment smart-insert-last-word
                     zstyle :insert-last-assignment match '[[:alpha:]][][[:alnum:]]#=*'
                     bindkey '\e=' insert-last-assignment

       The  behavior  of several of the above widgets can be con­
       trolled by the use of the zstyle mechanism.   In  particu­
       lar, widgets that interact with the completion system pass
       along their context to any completions that they invoke.

              This style is used by the incremental-complete-word
              widget. Its value should be a pattern, and all keys
              matching this pattern will cause the widget to stop
              incremental  completion  without the key having any
              further effect. Like all styles  used  directly  by
              incremental-complete-word,  this style is looked up
              using the context `:incremental'.
                     zstyle ':completion:incremental:*' completer \
                             _complete _correct
                     zstyle ':completion:predict:*' completer \

              It is a good idea to restrict the  completers  used
              in  prediction,  because  they may be automatically
              invoked as you type.   The  _list  and  _menu  com­
              pleters  should never be used with prediction.  The
              _approximate, _correct, _expand,  and  _match  com­
              pleters  may  be  used,  but be aware that they may
              change characters anywhere in the word  behind  the
              cursor,  so  you  need  to watch carefully that the
              result is what you intended.

       cursor The insert-and-predict widget uses this  style,  in
              the  context  `:predict',  to decide where to place
              the cursor after completion has been tried.  Values

                     The cursor is left where it was when comple­
                     tion finished, but only if  it  is  after  a
                     character  equal to the one just inserted by
                     the user.  If it is after another character,
                     this value is the same as `key'.

              key    The  cursor is left after the nth occurrence
                     of the character just inserted, where  n  is
                     the  number of times that character appeared
                     in the word before completion was attempted.
                     In short, this has the effect of leaving the
                     cursor after the character just  typed  even
                     if  the  completion  code  found out that no
                     other characters need to be inserted at that

              Any  other  value  for  this  style unconditionally
              leaves the cursor at the position where the comple­
              tion code left it.

       list   When  using  the  incremental-complete-word widget,
              this style says if the matches should be listed  on
              every  key  press (if they fit on the screen).  Use
              the context prefix `:completion:incremental'.

              The insert-and-predict widget uses  this  style  to
              decide  if  the  completion should be shown even if
              there is only one  possible  completion.   This  is
              done  if  the  value  of  this  style is the string
              always.  In this case  the  context  is  `:predict'
              (not `:completion:predict').
                     zstyle :insert-last-word match '*[[:alpha:][:space:]/\\]*'

              Or include numbers as long as the word is at  least
              two characters long:

                     zstyle :insert-last-word match '*([[:digit:]]?|[[:alpha:]/\\])*'

              The  above example causes redirections like "2>" to
              be included.

       prompt The  incremental-complete-word  widget  shows   the
              value  of  this  style  in  the  status line during
              incremental completion.  The string value may  con­
              tain  any of the following substrings in the manner
              of the PS1 and other prompt parameters:

              %c     Replaced by the name of the completer  func­
                     tion that generated the matches (without the
                     leading underscore).

              %l     When the list  style  is  set,  replaced  by
                     `...'  if the list of matches is too long to
                     fit on the screen and with an  empty  string
                     otherwise.   If the list style is `false' or
                     not set, `%l' is always removed.

              %n     Replaced by the number of matches generated.

              %s     Replaced  by `-no match-', `-no prefix-', or
                     an empty string if there  is  no  completion
                     matching  the  word  on  the  line,  if  the
                     matches have no common prefix different from
                     the  word on the line, or if there is such a
                     common prefix, respectively.

              %u     Replaced by  the  unambiguous  part  of  all
                     matches,  if there is any, and if it is dif­
                     ferent from the word on the line.

              Like `break-keys',  this  uses  the  `:incremental'

              This style is used by the incremental-complete-word
              widget.  Its value is treated similarly to the  one
              for  the  break-keys  style (and uses the same con­
              text: `:incremental').  However, in this  case  all
              keys  matching  the pattern given as its value will
              stop incremental completion and will  then  execute
              their usual function.

       toggle This  boolean  style  is used by predict-on and its
              tive state is toggled.  This is most useful in com­
              bination with the toggle style.  The  default  does
              not display these messages.

       widget This  style  is  similar  to the command style: For
              widget functions that use zle to  call  other  wid­
              gets,  this style can sometimes be used to override
              the widget which is called.  The context  for  this
              style  is  the  name of the calling widget (not the
              name of the calling function, because one  function
              may be bound to multiple widget names).

                     zstyle :copy-earlier-word widget smart-insert-last-word

              Check  the  documentation for the calling widget or
              function to determine whether the widget  style  is


       There are a large number of helpful functions in the Func­
       tions/Misc directory of the zsh  distribution.   Most  are
       very  simple  and do not require documentation here, but a
       few are worthy of special mention.

       colors This  function  initializes   several   associative
              arrays  to  map  color names to (and from) the ANSI
              standard eight-color  terminal  codes.   These  are
              used  by  the prompt theme system (see above).  You
              seldom should need to run colors more than once.

              The eight base colors are: black, red, green,  yel­
              low, blue, magenta, cyan, and white.  Each of these
              has codes for foreground and background.  In  addi­
              tion  there  are  eight intensity attributes: bold,
              faint, standout,  underline,  blink,  reverse,  and
              conceal.   Finally,  there  are  six  codes used to
              negate attributes: none (reset  all  attributes  to
              the  defaults),  normal  (neither  bold nor faint),
              no-standout,    no-underline,     no-blink,     and

              Some  terminals  do not support all combinations of
              colors and intensities.

              The associative arrays are:

              colour Map all the color  names  to  their  integer
                     codes, and integer codes to the color names.

                     Map the eight basic color names to ANSI ter­
                     minal  escape  sequences that set the corre­
                     sponding foreground text properties.  The fg
                     sequences  change the color without changing
                     the eight intensity attributes.

                     Map the eight basic color names to ANSI ter­
                     minal  escape  sequences that set the corre­
                     sponding  background  properties.   The   bg
                     sequences  change the color without changing
                     the eight intensity attributes.

              In addition, the scalar parameters reset_color  and
              bold_color  are  set  to  the ANSI terminal escapes
              that turn off  all  attributes  and  turn  on  bold
              intensity, respectively.

       fned name
              Same  as  zed -f.  This function does not appear in
              the zsh distribution, but can be created by linking
              zed  to  the  name  fned  in some directory in your

       is-at-least needed [ present ]
              Perform a  greater-than-or-equal-to  comparison  of
              two strings having the format of a zsh version num­
              ber; that is, a string of  numbers  and  text  with
              segments  separated by dots or dashes.  If the pre­
              sent string is not provided, $ZSH_VERSION is  used.
              Segments   are  paired  left-to-right  in  the  two
              strings with leading non-number parts ignored.   If
              one  string  has fewer segments than the other, the
              missing segments are considered zero.

              This is useful in startup files to set options  and
              other  state that are not available in all versions
              of zsh.

                     is-at-least 3.1.6-15 && setopt NO_GLOBAL_RCS
                     is-at-least 3.1.0 && setopt HIST_REDUCE_BLANKS
                     is-at-least 2.6-17 || print "You can't use is-at-least here."

       nslookup [ arg ... ]
              This wrapper  function  for  the  nslookup  command
              requires  the  zsh/zpty module (see zshmodules(1)).
              It  behaves  exactly  like  the  standard  nslookup
              Emacs, because it lacked a Tetris game.  This func­
              tion was written to refute this vicious slander.

              This function must be used as a ZLE widget:

                     autoload -U tetris
                     zle -N tetris
                     bindkey keys tetris

              To  start  a game, execute the widget by typing the
              keys.  Whatever command line you were editing  dis­
              appears  temporarily,  and your keymap is also tem­
              porarily replaced by the Tetris control keys.   The
              previous editor state is restored when you quit the
              game (by pressing `q') or when you lose.

              If you quit in the middle of a game, the next invo­
              cation of the tetris widget will continue where you
              left off.  If you lost, it will start a new game.

       zcalc [ expression ... ]
              A reasonably powerful  calculator  based  on  zsh's
              arithmetic evaluation facility.  The syntax is sim­
              ilar to that of formulae in most  programming  lan­
              guages;  see the section `Arithmetic Evaluation' in
              zshmisc(1) for details.  The  mathematical  library
              zsh/mathfunc will be loaded if it is available; see
              the section `The zsh/mathfunc  Module'  in  zshmod­
              ules(1).   The mathematical functions correspond to
              the raw system libraries,  so  trigonometric  func­
              tions are evaluated using radians, and so on.

              Each line typed is evaluated as an expression.  The
              prompt shows a number, which corresponds to a posi­
              tional  parameter where the result of that calcula­
              tion is stored.  For example,  the  result  of  the
              calculation on the line preceded by `4> ' is avail­
              able as $4.  Full command line  editing,  including
              the history of previous calculations, is available;
              the history is saved in the file  ~/.zcalc_history.
              To exit, enter a blank line or type `q' on its own.

              If arguments are given to zcalc on start  up,  they
              are  used to prime the first few positional parame­
              ters.  A visual indication of this  is  given  when
              the calculator starts.

              The  constants  PI  (3.14159...) and E (2.71828...)
              are provided.  Parameter  assignment  is  possible,
              but  note  that all parameters will be put into the
              global namespace.

              CPROMPT, which undergoes standard prompt expansion.
              The index of the current entry is stored locally in
              the first element of the array psvar, which can  be
              referred  to  in ZCALCPROMPT as `%1v'.  The default
              prompt is `%1v> '.

              See the comments in the function for  a  few  extra

       zed [ -f ] name
              This function uses the ZLE editor to edit a file or
              function.  It rebinds the return key  to  insert  a
              line  break,  and  adds  bindings for `^X^W' in the
              emacs keymap and `ZZ' in the vicmd keymap to accept
              (and  therefore  write,  in the case of a file) the
              edited file or function.  Keybindings are otherwise
              the  standard  ones;  completion  is available, and
              styles may be set with the context prefix `:comple­

              Only  one  name  argument is recognized (additional
              arguments are ignored).  If the -f option is given,
              the  name is taken to be that of a function; if the
              function is marked for  autoloading,  zed  searches
              for  it in the fpath and loads it.  Note that func­
              tions edited this way are installed into  the  cur­
              rent  shell,  but  not written back to the autoload

              Without -f, name is the path name of  the  file  to
              edit, which need not exist; it is created on write,
              if necessary.

       zcp [ -finqQvwW ] srcpat dest
       zln [ -finqQsvwW ] srcpat dest
              Same as zmv -C and  zmv  -L,  respectively.   These
              functions  do  not  appear in the zsh distribution,
              but can be created by linking zmv to the names  zcp
              and zln in some directory in your fpath.

       zkbd   See `Keyboard Definition' above.

       zmv [ -finqQsvwW ] [ -C | -L | -M | -p program ] [ -o opt­
       string ] srcpat dest
              Move  (usually,  rename) files matching the pattern
              srcpat to corresponding files having names  of  the
              form given by dest, where srcpat contains parenthe­
              ses surrounding patterns which will be replaced  in
              turn by $1, $2, ... in dest.  For example,

                     zmv '(*).lis' '$1.txt'

              -f     Force overwriting of destination files.  Not
                     currently passed down to the  mv/cp/ln  com­
                     mand due to vagaries of implementations (but
                     you can use -o-f to do that).
              -i     Interactive: show each line to  be  executed
                     and ask the user whether to execute it.  `Y'
                     or `y' will execute it, anything  else  will
                     skip  it.   Note  that you just need to type
                     one character.
              -n     No execution: print what would  happen,  but
                     don't do it.
              -q     Turn  bare  glob qualifiers off: now assumed
                     by default, so this has no effect.
              -Q     Force bare glob qualifiers on.   Don't  turn
                     this  on  unless you are actually using glob
                     qualifiers in a pattern.
              -s     Symbolic, passed down to ln; only works with
              -v     Verbose:  print  each  command as it's being
              -w     Pick out wildcard parts of the  pattern,  as
                     described  above,  and implicitly add paren­
                     theses for referring to them.
              -W     Just like -w, with the addition  of  turning
                     wildcards  in  the  replacement pattern into
                     sequential ${1} .. ${N} references.
              -M     Force cp, ln or mv, respectively, regardless
                     of the name of the function.
              -p program
                     Call program instead of cp, ln or mv.  What­
                     ever it does, it should at least  understand
                     the  form `program -- oldname newname' where
                     oldname and newname are filenames  generated
                     by zmv.
              -o optstring
                     The optstring is split into words and passed
                     down verbatim to the cp, ln  or  mv  command
                     called to perform the work.  It should prob­
                     ably begin with a `-'.

              For more complete examples and other implementation
              details,  see  the zmv source file, usually located
              in one of the directories named in your  fpath,  or
              in Functions/Misc/zmv in the zsh distribution.

              See `Recompiling Functions' above.

       zstyle+ context style value [ + subcontext style value ...
              context unchanged.

              The  zed function sets this style in context `:com­
              pletion:zed:*' to turn off completion when  TAB  is
              typed at the beginning of a line.  You may override
              this by setting your own value for this context and

       pager  The  nslookup  function  looks up this style in the
              context `:nslookup' to determine the  program  used
              to  display  output  that  does not fit on a single

              The nslookup function looks up this  style  in  the
              context  `:nslookup'  to  set  the  prompt  and the
              right-side prompt, respectively.  The usual  expan­
              sions  for  the PS1 and RPS1 parameters may be used
              (see zshmisc(1)).

zsh 4.1.1                 June 18, 2003             ZSHCONTRIB(1)

Looking for a "printer friendly" version?



Security Code
Security Code
Type Security Code

Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!

Amazon Wish List

Did You Know?
The Linux Tutorial can use your help.


Tell a Friend About Us

Bookmark and Share

Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.12 Seconds