Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
Let The Music Play: Join EFF Today

 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, 63 guest(s) and 0 member(s) that are online.

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




       Some  optional  parts of zsh are in modules, separate from
       the core of the shell.   Each  of  these  modules  may  be
       linked  in  to  the shell at build time, or can be dynami­
       cally linked while the shell is running if  the  installa­
       tion  supports this feature.  The modules that are bundled
       with the zsh distribution are:

              Builtins for manipulating POSIX.1e (POSIX.6)  capa­
              bility (privilege) sets.

              A  builtin  that  can  clone  a  running shell onto
              another terminal.

              The compctl builtin for controlling completion.

              The basic completion code.

              Completion listing extensions.

              A module with utility builtins needed for the shell
              function based completion system.

              A ZLE function duplicating EMACS' zap-to-char.

              An example of how to write a module.

              Some  basic file manipulation commands as builtins.

              Access to external files via a special  associative

              Standard scientific functions for use in mathemati­
              cal evaluations.

              Access to internal hash tables via special associa­
              tive arrays.

              Interface to the PCRE library.

              Interface to the terminfo database.

              A builtin FTP client.

              The  Zsh  Line  Editor,  including  the bindkey and
              vared builtins.

              Access to internals of  the  Zsh  Line  Editor  via

              A module allowing profiling for shell functions.

              A builtin for starting a command in a pseudo-termi­

              Block and return when file descriptors are ready.

              Some utility builtins, e.g. the one for  supporting
              configuration via styles.

              Manipulation of TCP sockets


       The  zsh/cap  module  is  used  for  manipulating POSIX.1e
       (POSIX.6) capability sets.  If the operating  system  does
       not  support  this interface, the builtins defined by this
       module will do nothing.  The builtins in this module are:

       cap [ capabilities ]
              Change the shell's process capability sets  to  the
              specified   capabilities,   otherwise  display  the
              shell's current capabilities.

       getcap filename ...
              This is a  built-in  implementation  of  the  POSIX
              standard  utility.  It displays the capability sets
              on each specified filename.

       setcap capabilities filename ...
              This is a  built-in  implementation  of  the  POSIX
              standard  utility.   It sets the capability sets on
              each specified filename to the specified  capabili­
              shells if successful, and non-zero on error.


       The  zsh/compctl  module  makes available two builtin com­
       mands. compctl, is the old, deprecated way to control com­
       pletions  for  ZLE.  See zshcompctl(1).  The other builtin
       command, compcall can be used in  user-defined  completion
       widgets, see zshcompwid(1).


       The  zsh/complete  module  makes available several builtin
       commands which can be used in user-defined completion wid­
       gets, see zshcompwid(1).


       The zsh/complist module offers three extensions to comple­
       tion listings: the ability to highlight matches in such  a
       list,  the ability to scroll through long lists and a dif­
       ferent style of menu completion.

   Colored completion listings
       Whenever one of the parameters ZLS_COLORS  or  ZLS_COLOURS
       is  set  and  the  zsh/complist module is loaded or linked
       into the shell, completion lists will be  colored.   Note,
       however, that complist will not automatically be loaded if
       it is not linked in:  on  systems  with  dynamic  loading,
       `zmodload zsh/complist' is required.

       The  parameters  ZLS_COLORS  and  ZLS_COLOURS describe how
       matches are highlighted.  To turn on highlighting an empty
       value suffices, in which case all the default values given
       below will be used.  The format  of  the  value  of  these
       parameters  is  the same as used by the GNU version of the
       ls command: a colon-separated list  of  specifications  of
       the form `name=value'.  The name may be one of the follow­
       ing strings, most of which specify file  types  for  which
       the  value  will  be  used.  The strings and their default
       values are:

       no 0   for normal text  (i.e.  when  displaying  something
              other than a matched file)

       fi 0   for regular files

       di 32  for directories

       ln 36  for symbolic links

       pi 31  for named pipes (FIFOs)

       so 33  for sockets

       rc m   for the right code

       tc 0   for the character indicating the file type  printed
              after filenames if the LIST_TYPES option is set

       sp 0   for  the  spaces printed after matches to align the
              next column

       ec none
              for the end code

       Apart from these strings, the name may also be an asterisk
       (`*')  followed  by any string. The value given for such a
       string will be used for all files whose name ends with the
       string.   The  name  may also be an equals sign (`=') fol­
       lowed by a pattern.  The value given for this pattern will
       be used for all matches (not just filenames) whose display
       string are matched by the pattern.  Definitions  for  both
       of  these take precedence over the values defined for file
       types and the form with the leading asterisk takes  prece­
       dence over the form with the leading equal sign.

       The last form also allows different parts of the displayed
       strings to be colored differently.  For this, the  pattern
       has to use the `(#b)' globbing flag and pairs of parenthe­
       ses surrounding the parts of the strings that  are  to  be
       colored  differently.   In this case the value may consist
       of more than one color code separated by equal signs.  The
       first  code  will  be  used  for  all  parts  for which no
       explicit code is specified and the following codes will be
       used  for  the parts matched by the sub-patterns in paren­
       theses.      For      example,      the      specification
       `=(#b)(?)*(?)=0=3=7'  will  be  used for all matches which
       are at least two characters long and will use the code `3'
       for  the  first  character, `7' for the last character and
       `0' for the rest.

       All three forms of name may be preceded by  a  pattern  in
       parentheses.   If  this  is  given, the value will be used
       only for matches in groups whose names are matched by  the
       pattern   given   in   the   parentheses.    For  example,
       `(g*)m*=43' highlights all matches beginning with  `m'  in
       groups  whose  names   begin with `g' using the color code
       `43'.  In case of the `lc',  `rc',  and  `ec'  codes,  the
       group pattern is ignored.

       Note  also  that  all  patterns  are tried in the order in
       which they appear in the parameter value until  the  first
       one matches which is then used.

       When  printing  a  match, the code prints the value of lc,
       red and `$colors[bg-green]' for the  code  for  background
       color green.

       If  the  completion  system  invoked  by compinit is used,
       these parameters should not be set  directly  because  the
       system  controls  them  itself.   Instead, the list-colors
       style should be used (see the section  `Completion  System
       Configuration' in zshcompsys(1)).

   Scrolling in completion listings
       To  enable  scrolling through a completion list, the LIST­
       PROMPT parameter must be set.  Its value will be  used  as
       the  prompt;  if  it is the empty string, a default prompt
       will be used.  The value may contain escapes of  the  form
       `%x'.   It  supports  the  escapes `%B', `%b', `%S', `%s',
       `%U', `%u' and `%{...%}' used also  in  shell  prompts  as
       well  as  three  pairs  of additional sequences: a `%l' or
       `%L' is replaced by the number of the last line shown  and
       the  total  number  of lines in the form `number/total'; a
       `%m' or `%M' is replaced with the number of the last match
       shown and the total number of matches; and `%p' or `%P' is
       replaced with `Top', `Bottom' or the position of the first
       line  shown  in  percent  of  the  total  number of lines,
       respectively.  In each of these cases the  form  with  the
       uppercase  letter  will be replaced with a string of fixed
       width, padded to the right with spaces, while  the  lower­
       case form will not be padded.

       If  the  parameter  LISTPROMPT is set, the completion code
       will not ask if the list  should  be  shown.   Instead  it
       immediately starts displaying the list, stopping after the
       first screenful, showing the prompt at the bottom, waiting
       for   a   keypress  after  temporarily  switching  to  the
       listscroll keymap.  Some of the zle functions have a  spe­
       cial meaning while scrolling lists:

              stops listing discarding the key pressed

       accept-line, down-history, down-line-or-history
       down-line-or-search, vi-down-line-or-history
              scrolls forward one line

       complete-word, menu-complete, expand-or-complete
       expand-or-complete-prefix, menu-complete-or-expand
              scrolls forward one screenful

       Every  other  character stops listing and immediately pro­
       cesses the key as usual.  Any key that is not bound in the
       listscroll  keymap  or  that  is bound to undefined-key is
       looked up in the keymap currently selected.
       module.   Alternatively,  the  parameter MENUSELECT can be
       set to an integer,  which  gives  the  minimum  number  of
       matches  that  must  be  present  before menu selection is
       automatically turned on.  This second method requires that
       menu  completion be started, either directly from a widget
       such as menu-complete,  or  due  to  one  of  the  options
       MENU_COMPLETE  or  AUTO_MENU  being set.  If MENUSELECT is
       set, but is 0, 1 or empty, menu selection will  always  be
       started during an ambiguous menu completion.

       When using the completion system based on shell functions,
       the MENUSELECT parameter should  not  be  used  (like  the
       ZLS_COLORS  and  ZLS_COLOURS  parameters described above).
       Instead, the menu style should be used with the select=...

       After  menu  selection  is  started,  the  matches will be
       listed. If there are more matches than fit on the  screen,
       only  the first screenful is shown.  The matches to insert
       into the command line can be selected from this list.   In
       the  list  one match is highlighted using the value for ma
       from the ZLS_COLORS or ZLS_COLOURS parameter.  The default
       value  for  this is `7' which forces the selected match to
       be highlighted using standout mode on  a  vt100-compatible
       terminal.   If  neither ZLS_COLORS nor ZLS_COLOURS is set,
       the same terminal control sequence as for the `%S'  escape
       in prompts is used.

       If  there  are more matches than fit on the screen and the
       parameter MENUPROMPT is set, its value will be shown below
       the  matches.   It  supports  the same escape sequences as
       LISTPROMPT, but the number of the match or line shown will
       be that of the one where the mark is placed.  If its value
       is the empty string, a default prompt will be used.

       The MENUSCROLL parameter can be used to  specify  how  the
       list is scrolled.  If the parameter is unset, this is done
       line by line, if it is set to `0' (zero),  the  list  will
       scroll  half  the  number  of lines of the screen.  If the
       value is positive, it gives the number of lines to  scroll
       and  if it is negative, the list will be scrolled the num­
       ber of lines of the screen minus the (absolute) value.

       As for the ZLS_COLORS, ZLS_COLOURS and LISTPROMPT  parame­
       ters,  neither  MENUPROMPT  nor  MENUSCROLL  should be set
       directly when using the shell  function  based  completion
       system.   Instead,  the  select-prompt  and  select-scroll
       styles should be used.

       The completion code sometimes decides not to show  all  of
       the  matches in the list.  These hidden matches are either
       matches for which the completion function which added them
       up  and  down  when  crossing the top or bottom line.  The
       following zle functions have special meaning  during  menu

              accepts the current match and leaves menu selection

              leaves menu selection  and  restores  the  previous
              contents of the command line

       redisplay, clear-screen
              execute  their normal function without leaving menu

       accept-and-hold, accept-and-menu-complete
              accept the currently inserted  match  and  continue
              selection  allowing  to  select  the  next match to
              insert into the line

              accepts the current match and then tries completion
              with  menu  selection  again;  in the case of files
              this allows one to select a directory  and  immedi­
              ately  attempt  to  complete files in it;  if there
              are no matches, a message is shown and one can  use
              undo  to  go  back  to  completion  on the previous
              level,  every  other  key  leaves  menu   selection
              (including the other zle functions which are other­
              wise special during menu selection)

       undo   removes matches inserted during the menu  selection
              by one of the three functions before

       down-history, down-line-or-history
       vi-down-line-or-history,  down-line-or-search
              moves the mark one line down

       up-history, up-line-or-history
       vi-up-line-or-history, up-line-or-search
              moves the mark one line up

       forward-char, vi-forward-char
              moves the mark one column right

       backward-char, vi-backward-char
              moves the mark one column left

       forward-word, vi-forward-word
       vi-forward-word-end, emacs-forward-word
              moves the mark one screenful down

              moves the mark to the last line

       beginning-of-buffer-or-history, beginning-of-line
       beginning-of-line-hist, vi-beginning-of-line
              moves the mark to the leftmost column

       end-of-buffer-or-history, end-of-line
       end-of-line-hist, vi-end-of-line
              moves the mark to the rightmost column

       complete-word, menu-complete, expand-or-complete
       expand-or-complete-prefix, menu-expand-or-complete
              moves the mark to the next match

              moves the mark to the previous match

              this  toggles  between normal and interactive mode;
              in interactive mode the keys bound  to  self-insert
              and self-insert-unmeta insert into the command line
              as in normal editing mode but without leaving  menu
              selection; after each character completion is tried
              again and the list changes to contain only the  new
              matches;  the  completion  widgets make the longest
              unambiguous string be inserted in the command  line
              and  undo  and  backward-delete-char go back to the
              previous set of matches

              history-incremental-search-backward   this   starts
              incremental  searches  in  the  list of completions
              displayed; in this mode,  accept-line  only  leaves
              incremental  search,  going back to the normal menu
              selection mode

       All movement functions wrap around at the edges; any other
       zle function not listed leaves menu selection and executes
       that function.  It is possible  to  make  widgets  in  the
       above  list  do  the  same by using the form of the widget
       with  a  `.'  in   front.    For   example,   the   widget
       `.accept-line'  has  the  effect of leaving menu selection
       and accepting the entire command line.

       During this selection the widget uses the  keymap  menuse­
       lect.   Any key that is not defined in this keymap or that
       is bound to undefined-key is looked up in the keymap  cur­
       rently  selected.   This  is  used to ensure that the most
       important keys used during selection  (namely  the  cursor
       keys,  return,  and TAB) have sensible defaults.  However,
       keys in the menuselect keymap  can  be  modified  directly
       your own completion functions.  In summary, these  builtin
       commands are:

              This  is  used by the _arguments function to do the
              argument and command line  parsing.   Like  compde­
              scribe  it  has  an option -i to do the parsing and
              initialize some internal state and various  options
              to  access  the  state  information  to decide what
              should be completed.

              This is used by the _describe function to build the
              displays  for the matches and to get the strings to
              add as matches with their options.   On  the  first
              call one of the options -i or -I should be supplied
              as the first argument.  In the first case,  display
              strings without the descriptions will be generated,
              in the second case, the string used to separate the
              matches  from  their  descriptions must be given as
              the second argument and the descriptions  (if  any)
              will  be  shown.   All other arguments are like the
              definition arguments to _describe itself.

              Once compdescribe has been called with  either  the
              -i  or  the  -I option, it can be repeatedly called
              with the -g option and the names of five arrays  as
              its  arguments.  This will step through the differ­
              ent sets of matches and store the  options  in  the
              first  array,  the strings with descriptions in the
              second, the matches for these  in  the  third,  the
              strings without descriptions in the fourth, and the
              matches for them in the  fifth  array.   These  are
              then  directly  given  to  compadd  to register the
              matches with the completion code.

              Used by the _path_files function to  optimize  com­
              plex  recursive filename generation (globbing).  It
              does three things.  With the -p and -P  options  it
              builds  the  glob  patterns  to  use, including the
              paths already handled and trying  to  optimize  the
              patterns with respect to the prefix and suffix from
              the line  and  the  match  specification  currently
              used.   The  -i option does the directory tests for
              the ignore-parents style and the -r option tests if
              a  component  for  some of the matches are equal to
              the string  on  the  line  and  removes  all  other
              matches if that is true.

              Used  by the _tags function to implement the inter­
              this  builtin command.  The arguments are the names
              of scalar or array parameters  and  the  values  of
              these  parameters  are  quoted  as  needed  for the
              innermost quoting  level.   If  the  -p  option  is
              given,  quoting  is done as if there is some prefix
              before the values of  the  parameters,  so  that  a
              leading equal sign will not be quoted.

              The  return  value  is non-zero in case of an error
              and zero otherwise.

              These implement the internals of  the  tags  mecha­

              Like comparguments, but for the _values function.


       The  zsh/deltochar  module  makes  available two ZLE func­

              Read a character from the keyboard, and delete from
              the  cursor  position  up to and including the next
              (or, with repeat count n, the nth) instance of that
              character.   Negative  repeat  counts  mean  delete

              This behaves like delete-to-char, except  that  the
              final  occurrence  of  the  character itself is not


       The zsh/example module makes available  one  builtin  com­

       example [ -flags ] [ args ... ]
              Displays  the  flags  and  arguments  it is invoked

       The purpose of the module is to serve as an example of how
       to write a module.


       The  zsh/files  module makes some standard commands avail­
       able as builtins:

       chgrp [ -Rs ] group filename ...
              Changes group of files specified.  This is  equiva­
              :group do not change owner; change group to group

              In  each  case,  the `:' may instead be a `.'.  The
              rule is that if there is a `:' then  the  separator
              is  `:', otherwise if there is a `.' then the sepa­
              rator is `.', otherwise there is no separator.

              Each of user and group may be either a username (or
              group  name,  as  appropriate) or a decimal user ID
              (group ID).  Interpretation as a name takes  prece­
              dence,  if  there  is  an  all-numeric username (or
              group name).

              The -R option causes chown to  recursively  descend
              into  directories,  changing  the  ownership of all
              files in the directory after changing the ownership
              of the directory itself.

              The -s option is a zsh extension to chown function­
              ality.  It enables paranoid behaviour, intended  to
              avoid  security  problems  involving  a chown being
              tricked into affecting files other  than  the  ones
              intended.  It will refuse to follow symbolic links,
              so    that    (for    example)    ``chown     luser
              /tmp/foo/passwd''    can't    accidentally    chown
              /etc/passwd if /tmp/foo happens to  be  a  link  to
              /etc.  It will also check where it is after leaving
              directories, so that a recursive chown  of  a  deep
              directory  tree  can't  end up recursively chowning
              /usr as a result of directories being moved up  the

       ln [ -dfis ] filename dest
       ln [ -dfis ] filename ... dir
              Creates hard (or, with -s, symbolic) links.  In the
              first form, the specified destination  is  created,
              as a link to the specified filename.  In the second
              form, each of the filenames is taken in  turn,  and
              linked  to  a  pathname  in the specified directory
              that has the same last pathname component.

              Normally, ln will not attempt to create hard  links
              to directories.  This check can be overridden using
              the -d option.  Typically only the  super-user  can
              actually succeed in creating hard links to directo­
              ries.  This does not apply to symbolic links in any

              By  default,  existing  files cannot be replaced by
              links.  The -i option causes the user to be queried
              about  replacing  existing  files.   The  -f option
              causes existing files to be silently deleted, with­
              Moves files.  In  the  first  form,  the  specified
              filename is moved to the specified destination.  In
              the second form, each of the filenames is taken  in
              turn,  and  moved  to  a  pathname in the specified
              directory that has the same  last  pathname  compo­

              By default, the user will be queried before replac­
              ing any file that the user  cannot  write  to,  but
              writable  files  will  be silently removed.  The -i
              option causes the user to be queried about  replac­
              ing  any  existing files.  The -f option causes any
              existing files  to  be  silently  deleted,  without
              querying.  -f takes precedence.

              Note  that  this  mv  will  not  move  files across
              devices.  Historical versions of  mv,  when  actual
              renaming  is  impossible,  fall back on copying and
              removing files; if this behaviour is  desired,  use
              cp  and  rm  manually.  This may change in a future

       rm [ -dfirs ] filename ...
              Removes files and directories specified.

              Normally, rm will not  remove  directories  (except
              with  the  -r  option).  The -d option causes rm to
              try   removing   directories   with   unlink   (see
              unlink(2)),  the same method used for files.  Typi­
              cally only the super-user can actually  succeed  in
              unlinking directories in this way.  -d takes prece­
              dence over -r.

              By default, the user will be queried before  remov­
              ing  any  file  that  the user cannot write to, but
              writable files will be silently  removed.   The  -i
              option causes the user to be queried about removing
              any files.   The  -f  option  causes  files  to  be
              silently  deleted, without querying, and suppresses
              all error indications.  -f takes precedence.

              The -r option causes rm to recursively descend into
              directories,  deleting  all  files in the directory
              before removing the directory with the rmdir system
              call (see rmdir(2)).

              The  -s option is a zsh extension to rm functional­
              ity.  It enables paranoid  behaviour,  intended  to
              avoid common security problems involving a root-run
              rm being tricked into removing files other than the
              ones  intended.   It will refuse to follow symbolic
              links, so that (for example) ``rm /tmp/foo/passwd''


       The  zsh/mapfile  module  provides one special associative
       array parameter of the same name.

              This associative array takes as keys the  names  of
              files;  the  resulting  value is the content of the
              file.  The value  is  treated  identically  to  any
              other  text coming from a parameter.  The value may
              also be assigned to, in  which  case  the  file  in
              question  is  written (whether or not it originally
              existed); or an element may be  unset,  which  will
              delete  the  file in question.  For example, `vared
              mapfile[myfile]' works  as  expected,  editing  the
              file `myfile'.

              When the array is accessed as a whole, the keys are
              the names of files in the  current  directory,  and
              the  values  are  empty (to save a huge overhead in
              memory).  Thus ${(k)mapfile} has the same affect as
              the  glob operator *(D), since files beginning with
              a dot are not special.  Care  must  be  taken  with
              expressions  such  as  rm ${(k)mapfile}, which will
              delete every file in the current directory  without
              the usual `rm *' test.

              The  parameter  mapfile  may  be made read-only; in
              that case, files referenced may not be  written  or

       Although  reading  and  writing of the file in question is
       efficiently handled, zsh's internal memory management  may
       be  arbitrarily baroque.  Thus it should not automatically
       be assumed that use of mapfile represents a gain in  effi­
       ciency  over  use of other mechanisms.  Note in particular
       that the whole contents of the  file  will  always  reside
       physically  in  memory  when  accessed  (possibly multiple
       times, due to standard parameter substitution operations).
       In  particular,  this  means handling of sufficiently long
       files (greater than the machine's swap space, or than  the
       range of the pointer type) will be incorrect.

       No errors are printed or flagged for non-existent, unread­
       able, or unwritable files, as the parameter  mechanism  is
       too low in the shell execution hierarchy to make this con­

       It is unfortunate that the mechanism for  loading  modules
       does  not  yet  allow  the user to specify the name of the
       from or to integer type will be performed automatically by
       the shell.  Apart from atan with a second argument and the
       abs,  int  and  float  functions,  all functions behave as
       noted in the manual page for the corresponding C function,
       except that any arguments out of range for the function in
       question will be  detected  by  the  shell  and  an  error

       The following functions take a single floating point argu­
       ment: acos, acosh, asin, asinh, atan, atanh,  cbrt,  ceil,
       cos,  cosh, erf, erfc, exp, expm1, fabs, floor, gamma, j0,
       j1, lgamma, log, log10, log1p, logb, sin, sinh, sqrt, tan,
       tanh,  y0,  y1.   The  atan function can optionally take a
       second argument, in which case it behaves like the C func­
       tion  atan2.   The  ilogb function takes a single floating
       point argument, but returns an integer.

       The function signgam takes no arguments,  and  returns  an
       integer,  which  is  the  C  variable of the same name, as
       described in gamma(3).  Note that  it  is  therefore  only
       useful  immediately after a call to gamma or lgamma.  Note
       also that `signgam()' and `signgam' are  distinct  expres­

       The following functions take two floating point arguments:
       copysign, fmod, hypot, nextafter.

       The following take an integer first argument and a  float­
       ing point second argument: jn, yn.

       The  following take a floating point first argument and an
       integer second argument: ldexp, scalb.

       The function abs does not convert the type of  its  single
       argument; it returns the absolute value of either a float­
       ing point number or an integer.  The functions  float  and
       int convert their arguments into a floating point or inte­
       ger value (by truncation) respectively.

       Note that the C pow function is available in ordinary math
       evaluation  as the `**' operator and is not provided here.

       The function rand48 is available if your  system's  mathe­
       matical library has the function erand48(3).  It returns a
       pseudo-random floating point number between 0 and  1.   It
       takes a single string optional argument.

       If  the argument is not present, the random number seed is
       initialised by three calls to  the  rand(3)  function  ---
       this  produces  the  same random numbers as the next three
       values of $RANDOM.

              print $(( rand48(seed) ))
              print $(( rand48() ))
              print $(( rand48(seed) ))

       Assuming  $seed  does not exist, it will be initialised by
       the first call.  In the second call, the default  seed  is
       initialised; note, however, that because of the properties
       of rand() there is a correlation between  the  seeds  used
       for  the two initialisations, so for more secure uses, you
       should generate your own 12-byte  seed.   The  third  call
       returns to the same sequence of random numbers used in the
       first call, unaffected by the intervening rand48().


       The zsh/parameter module  gives  access  to  some  of  the
       internal  hash  tables  used by the shell by defining some
       special parameters.

              The keys for this associative array are  the  names
              of  the options that can be set and unset using the
              setopt and unsetopt builtins. The value of each key
              is  either the string on if the option is currently
              set, or the string off  if  the  option  is  unset.
              Setting  a key to one of these strings is like set­
              ting or unsetting the option, respectively.  Unset­
              ting  a key in this array is like setting it to the
              value off.

              This array gives access to the command hash  table.
              The  keys  are  the names of external commands, the
              values are the pathnames of the files that would be
              executed when the command would be invoked. Setting
              a key in this array defines a  new  entry  in  this
              table  in  the  same  way as with the hash builtin.
              Unsetting  a  key  as  in  `unset  "commands[foo]"'
              removes  the  entry for the given key from the com­
              mand hash table.

              This associative array maps names of enabled  func­
              tions  to their definitions. Setting a key in it is
              like defining a function with the name given by the
              key  and  the  body given by the value. Unsetting a
              key removes the definition for the  function  named
              by the key.

              Like functions but for disabled functions.

              Like reswords but for disabled reserved words.

              This  maps  the  names  of the regular aliases cur­
              rently enabled to their expansions.

              Like raliases but for disabled regular aliases.

              Like raliases, but for global aliases.

              Like galiases but for disabled global aliases.

              The keys in this associative array are the names of
              the  parameters  currently  defined. The values are
              strings describing the type of  the  parameter,  in
              the  same  format used by the t parameter flag, see
              zshexpn(1) .  Setting or  unsetting  keys  in  this
              array is not possible.

              An  associative array giving information about mod­
              ules. The keys are the names of the modules loaded,
              registered  to be autoloaded, or aliased. The value
              says which state the named module is in and is  one
              of   the   strings   `loaded',   `autoloaded',   or
              `alias:name', where name is the name the module  is
              aliased to.

              Setting or unsetting keys in this array is not pos­

              A normal array holding the elements of  the  direc­
              tory  stack.  Note  that  the  output  of  the dirs
              builtin command includes one  more  directory,  the
              current working directory.

              This  associative  array maps history event numbers
              to the full history lines.

              A special array containing the words stored in  the

              gives  the state the whole job is currently in, one
              of `running', `suspended', or `done'. The  mark  is
              `+'  for  the current job, `-' for the previous job
              and  empty  otherwise.  This  is  followed  by  one
              `pid=state'  for every process in the job. The pids
              are, of course,  the  process  IDs  and  the  state
              describes the state of that process.

              This  associative  array  maps  the  names of named
              directories to the pathnames they stand for.

              This associative array maps user names to the path­
              names of their home directories.

              This array contains the names of the functions cur­
              rently being executed. The  first  element  is  the
              name of the function using the parameter.


       The  zsh/pcre  module  makes  some  commands  available as

       pcre_compile [ -aimx ] PCRE
              Compiles a perl-compatible regular expression.

              Studies  the  previously-compiled  PCRE  which  may
              result in faster matching.

       pcre_match [ -a arr ] string
              Returns  successfully  if string matches the previ­
              ously-compiled PCRE.

              If the expression captures substrings within paren­
              theses,  pcre_match  will  set  the array $match to
              those substrings, unless the -a option is given, in
              which case it will set the array arr.


       The zsh/sched module makes available one builtin command:

       sched [+]hh:mm command ...
       sched [ -item ]
              Make  an entry in the scheduled list of commands to
              execute.  The time may be specified in either abso­
              lute  or  relative time.  With no arguments, prints
              the list of scheduled commands.  With the  argument
              `-item', removes the given item from the list.

              descriptor associated with that  connection.   Cur­
              rently, only stream connections are supported.

              If  -d  is specified, its argument will be taken as
              the target file descriptor for the connection.

              In order to elicit more verbose output, use -v.

   Inbound Connections
       zsocket -l [ -v ] [ -d fd ] filename
              zsocket -l will open a socket  listening  on  file­
              name.  The shell parameter REPLY will be set to the
              file descriptor associated with that listener.

              If -d is specified, its argument will be  taken  as
              the target file descriptor for the connection.

              In order to elicit more verbose output, use -v.

       zsocket -a [ -tv ] [ -d targetfd ] listenfd
              zsocket  -a  will  accept an incoming connection to
              the socket associated  with  listenfd.   The  shell
              parameter  REPLY will be set to the file descriptor
              associated with the inbound connection.

              If -d is specified, its argument will be  taken  as
              the target file descriptor for the connection.

              If  -t  is  specified,  zsocket  will  return if no
              incoming connection is pending.  Otherwise it  will
              wait for one.

              In order to elicit more verbose output, use -v.


       The zsh/stat module makes available one builtin command:

       stat  [ -gnNolLtTrs ] [ -f fd ] [ -H hash ] [ -A array ] [
       -F fmt ] [ +element ] [ file ... ]
              The  command acts as a front end to the stat system
              call (see stat(2)).  If the stat  call  fails,  the
              appropriate system error message printed and status
              1 is returned.  The  fields  of  struct  stat  give
              information  about  the files provided as arguments
              to the command.  In  addition  to  those  available
              from the stat call, an extra element `link' is pro­
              vided.  These elements are:

              device The number of the device on which  the  file

              gid    The group ID  of  the  file.   With  the  -s
                     option, this is displayed as a group name.

              rdev   The  raw device number.  This is only useful
                     for special devices.

              size   The size of the file in bytes.

              ctime  The  last  access,  modification  and  inode
                     change  times  of the file, respectively, as
                     the number of seconds since midnight GMT  on
                     1st  January,  1970.   With  the  -s option,
                     these are printed as strings for  the  local
                     time  zone;  the  format can be altered with
                     the -F option, and with the  -g  option  the
                     times are in GMT.

                     The  number of bytes in one allocation block
                     on the device on which the file resides.

              block  The number of disk blocks used by the  file.

              link   If  the  file is a link and the -L option is
                     in effect, this contains  the  name  of  the
                     file linked to, otherwise it is empty.  Note
                     that if this  element  is  selected  (``stat
                     +link'') then the -L option is automatically

              A particular element may be selected  by  including
              its name preceded by a `+' in the option list; only
              one element is allowed.  The element may be  short­
              ened to any unique set of leading characters.  Oth­
              erwise, all elements will be shown for all files.


              -A array
                     Instead of displaying the results  on  stan­
                     dard  output,  assign  them to an array, one
                     struct stat element per  array  element  for
                     each  file  in  order.  In this case neither
                     the name of the element nor the name of  the
                     files  appears  in array unless the -t or -n
                     options were given, respectively.  If -t  is
                     given,  the element name appears as a prefix
                     to the appropriate array element; if  -n  is
                     given,  the  file name appears as a separate

              -F fmt Supplies a strftime (see strftime(3)) string
                     for the formatting  of  the  time  elements.
                     The -s option is implied.

              -g     Show the time elements in the GMT time zone.
                     The -s option is implied.

              -l     List the names  of  the  type  elements  (to
                     standard  output or an array as appropriate)
                     and return immediately; options  other  than
                     -A and arguments are ignored.

              -L     Perform  an lstat (see lstat(2)) rather than
                     a stat system call.  In this  case,  if  the
                     file  is  a link, information about the link
                     itself  rather  than  the  target  file   is
                     returned.   This  option is required to make
                     the link element useful.

              -n     Always show the  names  of  files.   Usually
                     these are only shown when output is to stan­
                     dard output and there is more than one  file
                     in the list.

              -N     Never show the names of files.

              -o     If  a  raw  file mode is printed, show it in
                     octal, which is more useful for  human  con­
                     sumption  than  the  default  of decimal.  A
                     leading zero will be printed in  this  case.
                     Note that this does not affect whether a raw
                     or formatted file mode is  shown,  which  is
                     controlled  by  the  -r  and -s options, nor
                     whether a mode is shown at all.

              -r     Print raw data (the default  format)  along­
                     side string data (the -s format); the string
                     data appears in parentheses  after  the  raw

              -s     Print mode, uid, gid and the three time ele­
                     ments as strings  instead  of  numbers.   In
                     each  case the format is like that of ls -l.

              -t     Always show the type names for the  elements
                     of  struct  stat.   Usually  these  are only
                     shown when output is to standard output  and
                     no individual element has been selected.

              -T     Never show the type names of the struct stat


       The  zsh/terminfo  module makes available one builtin com­

       echoti cap [ arg ]
              Output the  terminfo  value  corresponding  to  the
              capability  cap,  instantiated with arg if applica­

       The zsh/terminfo module makes available one parameter:

              An associative array that maps terminfo  capability
              names to their values.


       The zsh/zftp module makes available one builtin command:

       zftp subcommand [ args ]
              The  zsh/zftp  module  is  a  client  for FTP (file
              transfer protocol).  It is implemented as a builtin
              to  allow  full  use of shell command line editing,
              file I/O, and job control mechanisms.  Often, users
              will access it via shell functions providing a more
              powerful interface; a set is provided with the  zsh
              distribution  and  is  described  in zshzftpsys(1).
              However, the zftp command is entirely usable in its
              own right.

              All  commands consist of the command name zftp fol­
              lowed by the  name  of  a  subcommand.   These  are
              listed below.  The return status of each subcommand
              is supposed to reflect the success  or  failure  of
              the  remote  operation.   See  a description of the
              variable ZFTP_VERBOSE for more information  on  how
              responses from the server may be printed.

       open host [ user [ password [ account ] ] ]
              Open  a  new  FTP session to host, which may be the
              name of a TCP/IP connected host or an IP number  in
              the standard dot notation.  Remaining arguments are
              passed to the login subcommand.  Note  that  if  no
              arguments  beyond  host are supplied, open will not
              automatically call login.  If no arguments  at  all
              are  supplied,  open will use the parameters set by
              the params subcommand.

              After  a  successful  open,  the  shell   variables
              ZFTP_HOST,  ZFTP_IP  and ZFTP_SYSTEM are available;
              see `Variables' below.
              see `Variables' below.

              This  command  may  be  re-issued  when  a  user is
              already logged in, and the  server  will  first  be
              reinitialized for a new user.

       params [ host [ user [ password [ account ] ] ] ]
       params -
              Store the given parameters for a later open command
              with no arguments.  Only those given on the command
              line  will  be  remembered.   If  no  arguments are
              given, the parameters currently  set  are  printed,
              although  the  password  will  appear  as a line of
              stars; the return value is  one  if  no  parameters
              were set, zero otherwise.

              Any  of  the  parameters may be specified as a `?',
              which may need to be  quoted  to  protect  it  from
              shell  expansion.   In  this  case, the appropriate
              parameter will be read from stdin as with the login
              subcommand, including special handling of password.
              If the `?' is followed by a string, that is used as
              the prompt for reading the parameter instead of the
              default  message  (any  necessary  punctuation  and
              whitespace  should  be  included  at the end of the
              prompt).  The first letter of the parameter  (only)
              may  be  quoted  with  a  `\';  hence  an  argument
              "\\$word" guarantees that the string from the shell
              parameter  $word will be treated literally, whether
              or not it begins with a `?'.

              If instead a single  `-'  is  given,  the  existing
              parameters,  if  any,  are  deleted.  In that case,
              calling open with no arguments will cause an error.

              The  list  of  parameters  is  not  deleted after a
              close, however it will be deleted if  the  zsh/zftp
              module is unloaded.

              For example,

                     zftp params ftp.elsewhere.xx juser '?Password for juser: '

              will  store  the host ftp.elsewhere.xx and the user
              juser and then prompt the user for the  correspond­
              ing password with the given prompt.

       test   Test  the  connection;  if  the server has reported
              that it has closed the connection (maybe due  to  a
              timeout),  return  status  2;  if no connection was
              open anyway, return status 1; else return status 0.
              The  test subcommand is silent, apart from messages
              Change  the  remote  directory  to directory.  Also
              alters the shell variable ZFTP_PWD.

       cdup   Change the remote directory to the  one  higher  in
              the directory tree.  Note that cd .. will also work
              correctly on non-UNIX systems.

       dir [ args... ]
              Give a (verbose) listing of the  remote  directory.
              The  args  are  passed  directly to the server. The
              command's behaviour  is  implementation  dependent,
              but  a UNIX server will typically interpret args as
              arguments to the ls command and with  no  arguments
              return  the  result  of  `ls  -l'. The directory is
              listed to standard output.

       ls [ args ]
              Give a (short) listing  of  the  remote  directory.
              With  no  args, produces a raw list of the files in
              the directory, one  per  line.   Otherwise,  up  to
              vagaries of the server implementation, behaves sim­
              ilar to dir.

       type [ type ]
              Change the type for the transfer to type, or  print
              the  current  type  if type is absent.  The allowed
              values are `A' (ASCII), `I' (Image,  i.e.  binary),
              or `B' (a synonym for `I').

              The  FTP default for a transfer is ASCII.  However,
              if zftp finds  that  the  remote  host  is  a  UNIX
              machine  with  8-bit  byes,  it  will automatically
              switch to using  binary  for  file  transfers  upon
              open.  This can subsequently be overridden.

              The transfer type is only passed to the remote host
              when a data connection is established; this command
              involves no network overhead.

       ascii  The same as type A.

       binary The same as type I.

       mode [ S | B ]
              Set  the  mode  type  to  stream  (S) or block (B).
              Stream mode is  the  default;  block  mode  is  not
              widely supported.

       remote files...
       local [ files... ]
              Print  the  size  and last modification time of the
              remote or local files.  If there is more  than  one
              with status 1 for a file not found.

              The local command (but not remote) may be used with
              no arguments, in which case the  information  comes
              from  examining  file descriptor zero.  This is the
              same file as seen by a put command with no  further

       get file [...]
              Retrieve  all  files from the server, concatenating
              them and sending them to standard output.

       put file [...]
              For each file, read a file from standard input  and
              send that to the remote host with the given name.

       append file [...]
              As put, but if the remote file already exists, data
              is appended to it instead of overwriting it.

       getat file point
       putat file point
       appendat file point
              Versions of get, put and append  which  will  start
              the transfer at the given point in the remote file.
              This is useful for appending to an incomplete local
              file.   However, note that this ability is not uni­
              versally supported by servers (and is not quite the
              behaviour specified by the standard).

       delete file [...]
              Delete the list of files on the server.

       mkdir directory
              Create a new directory directory on the server.

       rmdir directory
              Delete the directory directory  on the server.

       rename old-name new-name
              Rename file old-name to new-name on the server.

       site args...
              Send  a  host-specific  command to the server.  You
              will probably only need this if instructed  by  the
              server to use it.

       quote args...
              Send  the  raw  FTP command sequence to the server.
              You should be familiar with the FTP command set  as
              defined  in  RFC959 before doing this.  Useful com­
              mands may include STAT and  HELP.   Note  also  the
              characters;   the   default   session   is   called
              `default'.  If this command is  called  without  an
              argument,  it  will  list all the current sessions;
              with an argument, it  will  either  switch  to  the
              existing  session  called sessname, or create a new
              session of that name.

              Each session remembers the status  of  the  connec­
              tion,  the set of connection-specific shell parame­
              ters (the same set as are unset when  a  connection
              closes,  as given in the description of close), and
              any user parameters specified with the params  sub­
              command.   Changing  to a previous session restores
              those values; changing to a new session initialises
              them  in  the  same  way  as  if zftp had just been
              loaded.  The name of the current session  is  given
              by the parameter ZFTP_SESSION.

       rmsession [ sessname ]
              Delete  a session; if a name is not given, the cur­
              rent session is deleted.  If the current session is
              deleted,  the earliest existing session becomes the
              new current session, otherwise the current  session
              is  not  changed.   If the session being deleted is
              the only one, a new  session  called  `default'  is
              created  and becomes the current session; note that
              this is a new session even  if  the  session  being
              deleted is also called `default'. It is recommended
              that sessions not be deleted while background  com­
              mands which use zftp are still active.

       The  following  shell  parameters  are used by zftp.  Cur­
       rently none of them are special.

              Integer.  The time in seconds to wait for a network
              operation  to  complete  before returning an error.
              If this is not set when the module  is  loaded,  it
              will  be  given  the  default value 60.  A value of
              zero turns off timeouts.  If a  timeout  occurs  on
              the  control  connection  it will be closed.  Use a
              larger value if this occurs too frequently.

              Readonly.  The IP address of the current connection
              in dot notation.

              Readonly.   The  hostname  of  the  current  remote
              server.  If the host was opened as  an  IP  number,
              change this.

              Readonly.   The  username  currently  logged in, if

              Readonly.  The account name of the current user, if
              any.   Most servers do not require an account name.

              Readonly.  The current directory on the server.

              Readonly.  The three digit code  of  the  last  FTP
              reply  from the server as a string.  This can still
              be read after the connection is closed, and is  not
              changed when the current session changes.

              Readonly.   The last line of the last reply sent by
              the server.  This can still be read after the  con­
              nection is closed, and is not changed when the cur­
              rent session changes.

              Readonly.  The name of the current FTP session; see
              the description of the session subcommand.

              A  string  of  preferences  for altering aspects of
              zftp's behaviour.   Each  preference  is  a  single
              character.  The following are defined:

              P      Passive:   attempt to make the remote server
                     initiate data transfers.  This  is  slightly
                     more  efficient  than sendport mode.  If the
                     letter S occurs later in  the  string,  zftp
                     will  use  sendport  mode if passive mode is
                     not available.

              S      Sendport:  initiate  transfers  by  the  FTP
                     PORT  command.   If this occurs before any P
                     in the string, passive mode  will  never  be

              D      Dumb:  use only the bare minimum of FTP com­
                     mands.    This   prevents   the    variables
                     ZFTP_SYSTEM and ZFTP_PWD from being set, and
                     will mean all connections default  to  ASCII
                     type.   It  may prevent ZFTP_SIZE from being
                     set during a transfer if the server does not

              error.  The first digit of the  three  digit  reply
              code is defined by RFC959 to correspond to:

              1.     A positive preliminary reply.

              2.     A positive completion reply.

              3.     A positive intermediate reply.

              4.     A transient negative completion reply.

              5.     A permanent negative completion reply.

              It  should  be noted that, for unknown reasons, the
              reply `Service not available', which forces  termi­
              nation  of a connection, is classified as 421, i.e.
              `transient negative', an interesting interpretation
              of the word `transient'.

              The  code  0 is special:  it indicates that all but
              the last line of multiline replies  read  from  the
              server  will be printed to standard error in a pro­
              cessed format.  By  convention,  servers  use  this
              mechanism  for  sending information for the user to
              read.  The appropriate reply code,  if  it  matches
              the same response, takes priority.

              If  ZFTP_VERBOSE is not set when zftp is loaded, it
              will be set to the default value  450,  i.e.,  mes­
              sages  destined for the user and all errors will be
              printed.  A null string is valid and specifies that
              no messages should be printed.

              If  this  function is set by the user, it is called
              every time the directory  changes  on  the  server,
              including  when a user is logged in, or when a con­
              nection is closed.  In  the  last  case,  $ZFTP_PWD
              will  be  unset;  otherwise it will reflect the new

              If this function is set by the  user,  it  will  be
              called  during  a get, put or append operation each
              time sufficient data has  been  received  from  the
              host.   During  a get, the data is sent to standard
              output, so it is vital that  this  function  should
              write  to  standard error or directly to the termi­
              nal, not to standard output.

                     provided by the remote and local subcommands
                     for a particular file.  If the server cannot
                     supply  this  value  for a remote file being
                     retrieved, it will not be set.  If input  is
                     from  a  pipe the value may be incorrect and
                     correspond simply to a full pipe buffer.

                     The amount of data  so  far  transferred;  a
                     number  between zero and $ZFTP_SIZE, if that
                     is set.  This number is always available.

              The function is initially called with ZFTP_TRANSFER
              set  appropriately  and  ZFTP_COUNT  set  to  zero.
              After the transfer is finished, the  function  will
              be  called  one more time with ZFTP_TRANSFER set to
              GF or PF, in case it wishes to tidy up.  It is oth­
              erwise  never  called  twice with the same value of

              Sometimes the progress meter may cause  disruption.
              It is up to the user to decide whether the function
              should be defined and to use unfunction when neces­

       A  connection may not be opened in the left hand side of a
       pipe as this occurs in a subshell and the file information
       is  not updated in the main shell.  In the case of type or
       mode changes or closing the connection in a subshell,  the
       information  is  returned  but  variables  are not updated
       until the next call to zftp.  Other status changes in sub­
       shells  will  not be reflected by changes to the variables
       (but should be otherwise harmless).

       Deleting sessions while a zftp command is  active  in  the
       background  can  have  unexpected effects, even if it does
       not use the session being deleted.  This  is  because  all
       shell  subprocesses  share information on the state of all
       connections, and deleting a session changes  the  ordering
       of that information.

       On  some  operating systems, the control connection is not
       valid after a fork(), so that operations in subshells,  on
       the left hand side of a pipeline, or in the background are
       not possible, as they should be.  This is presumably a bug
       in the operating system.


       The zsh/zle module contains the Zsh Line Editor.  See zsh­
              either the string `builtin' for builtin widgets,  a
              string  of  the  form  `user:name' for user-defined
              widgets, where name is the name of the shell  func­
              tion  implementing the widget, or it is a string of
              the  form  `completion:type:name',  for  completion
              widgets.  In  the last case type is the name of the
              builtin widgets the completion widget  imitates  in
              its  behavior  and  name  is  the name of the shell
              function implementing the completion widget.


       When loaded, the zsh/zprof causes shell  functions  to  be
       profiled.   The profiling results can be obtained with the
       zprof builtin  command  made  available  by  this  module.
       There is no way to turn profiling off other than unloading
       the module.

       zprof [ -c ]
              Without  the  -c  option,  zprof  lists   profiling
              results to standard output.  The format is compara­
              ble to that of commands like gprof.

              At the top there is a summary listing all functions
              that  were  called  at least once.  This summary is
              sorted in decreasing order of the  amount  of  time
              spent in each.  The lines contain the number of the
              function in order, which is used in other parts  of
              the  list  in suffixes of the form `[num]'.RE, then
              the number of calls made to the function.  The next
              three  columns  list the time in milliseconds spent
              in the function and its  descendents,  the  average
              time  in milliseconds spent in the function and its
              descendents per call and  the  percentage  of  time
              spent  in all shell functions used in this function
              and its descendents.  The following  three  columns
              give  the  same  information, but counting only the
              time spent in the function itself.  The final  col­
              umn shows the name of the function.

              After the summary, detailed information about every
              function that was  invoked  is  listed,  sorted  in
              decreasing  order  of  the  amount of time spent in
              each function and its descendents.  Each  of  these
              entries  consists of descriptions for the functions
              that called the function  described,  the  function
              itself, and the functions that were called from it.
              The description for the  function  itself  has  the
              same  format  as in the summary (and shows the same
              information).  The other lines don't show the  num­
              ber of the function at the beginning and have their
              function named indented to make it easier  to  dis­
              tinguish the line showing the function described in
              Also in this case, the column showing the number of
              calls to a function also shows a slash and then the
              total number of  invocations  made  to  the  called

              As  long as the zsh/zprof module is loaded, profil­
              ing will be done and multiple  invocations  of  the
              zprof  builtin command will show the times and num­
              bers of calls since the module  was  loaded.   With
              the -c option, the zprof builtin command will reset
              its internal counters and will not show  the  list­
              ing.  )


       The zsh/zpty module offers one builtin:

       zpty [ -e ] [ -b ] name [ arg ... ]
              The  arguments following name are concatenated with
              spaces between, then executed as a command,  as  if
              passed to the eval builtin.  The command runs under
              a newly assigned pseudo-terminal;  this  is  useful
              for running commands non-interactively which expect
              an interactive environment.  The name is  not  part
              of  the  command, but is used to refer to this com­
              mand in later calls to zpty.

              With the -e option, the pseudo-terminal is  set  up
              so that input characters are echoed.

              With  the  -b  option, input to and output from the
              pseudo-terminal are made non-blocking.

       zpty -d [ names ... ]
              The second form, with the -d  option,  is  used  to
              delete  commands previously started, by supplying a
              list of their names.  If no names  are  given,  all
              commands  are  deleted.   Deleting a command causes
              the HUP signal to be sent to the corresponding pro­

       zpty -w [ -n ] name [ strings ... ]
              The  -w  option  can be used to send the to command
              name the  given  strings  as  input  (separated  by
              spaces).   If the -n option is not given, a newline
              is added at the end.

              If no strings are provided, the standard  input  is
              copied to the pseudo-terminal; this may stop before
              copying the full input if  the  pseudo-terminal  is

              Note  that  the  command  under the pseudo-terminal
              When  also given a param argument, at most one line
              is read and stored in the  parameter  named  param.
              Less   than   a  full  line  may  be  read  if  the
              pseudo-terminal is non-blocking.  The return  value
              is  zero  if  at  least  one character is stored in

              If a pattern is given as well, output is read until
              the  whole string read matches the pattern, even in
              the non-blocking case.  The return value is zero if
              the string read matches the pattern, or if the com­
              mand has exited but at least  one  character  could
              still  be  read.   As of this writing, a maximum of
              one megabyte of output can be consumed this way; if
              a  full  megabyte is read without matching the pat­
              tern, the return value is non-zero.

              In all cases, the return value is non-zero if noth­
              ing  could be read, and is 2 if this is because the
              command has finished.

              If the -r option is combined with  the  -t  option,
              zpty  tests whether output is available before try­
              ing to read.  If no output is available, zpty imme­
              diately returns the value 1.

       zpty -t name
              The  -t option without the -r option can be used to
              test whether the command name is still running.  It
              returns  a zero value if the command is running and
              a non-zero value otherwise.

       zpty [ -L ]
              The last form, without any arguments,  is  used  to
              list  the  commands  currently  defined.  If the -L
              option is given, this is done in the form of  calls
              to the zpty builtin.


       The  zsh/zselect  module  makes available one builtin com­

       zselect [ -rwe -t timeout -a array ] [ fd ... ]
              The zselect builtin is a front-end to the  `select'
              system  call,  which blocks until a file descriptor
              is ready for reading or writing, or  has  an  error
              condition,  with  an  optional timeout.  If this is
              not available on your system, the command prints an
              error  message  and returns status 2 (normal errors
              return status 1).  For more information,  see  your
              systems documentation for select(3).  Note there is
              no connection with the shell builtin  of  the  same

              (The presence of an `error condition' is  not  well
              defined  in  the documentation for many implementa­
              tions of the  select  system  call.   According  to
              recent  versions  of the POSIX specification, it is
              really an exception condition, of  which  the  only
              standard  example is out-of-band data received on a
              socket.  So zsh users are unlikely to find  the  -e
              option useful.)

              The option `-t timeout' specifies a timeout in hun­
              dredths of a second.  This may be  zero,  in  which
              case the file descriptors will simply be polled and
              zselect will return immediately.  It is possible to
              call   zselect  with  no  file  descriptors  and  a
              non-zero  timeout  for  use  as   a   finer-grained
              replacement  for  `sleep'; not, however, the return
              status is always 1 for a timeout.

              The option `-a array' indicates that  array  should
              be set to indicate the file descriptor(s) which are
              ready.  If the option is not given, the array reply
              will be used for this purpose.  The array will con­
              tain a string similar to the arguments for zselect.
              For example,

                     zselect -t 0 -r 0 -w 1

              might  return  immediately with status 0 and $reply
              containing `-r 0 -w  1'  to  show  that  both  file
              descriptors are ready for the requested operations.

              The option `-A assoc' indicates that  the  associa­
              tive array assoc should be set to indicate the file
              descriptor(s) which are ready.  This  option  over­
              rides  the  option  -a, nor will reply be modified.
              The keys of assoc are the file descriptors, and the
              corresponding  values  are  any  of  the characters
              `rwe' to indicate the condition.

              The command returns 0 if some file descriptors  are
              ready  for reading.  If the operation timed out, or
              a timeout of 0 was given and  no  file  descriptors
              were  ready, or there was an error, it returns sta­
              tus 1 and the array will not be set  (nor  modified
              in  any  way).  If there was an error in the select
              operation the appropriate error message is printed.


       The zsh/zutil module only adds some builtins:

       zstyle [ -L ]

              For ordering of comparisons, patterns are  searched
              from  most specific to least specific, and patterns
              that are equally specific keep the order  in  which
              they  were  defined.  A pattern is considered to be
              more specific than another if it contains more com­
              ponents  (substrings separated by colons) or if the
              patterns for  the  components  are  more  specific,
              where simple strings are considered to be more spe­
              cific than patterns and complex patterns  are  con­
              sidered to be more specific than the pattern `*'.

              The  first form (without arguments) lists the defi­
              nitions in the order zstyle will test them. If  the
              -L  option is given, listing is done in the form of
              calls to zstyle.  Forms with arguments:

              zstyle [ - | -- | -e ] pattern style strings ...
                     Defines the given style for the pattern with
                     the  strings as the value.  If the -e option
                     is given, the strings will  be  concatenated
                     (separated  by  spaces)  and  the  resulting
                     string will be evaluated (in the same way as
                     it is done by the eval builtin command) when
                     the style is looked up.  In  this  case  the
                     parameter  `reply'  must  be assigned to set
                     the strings returned after  the  evaluation.
                     Before evaluating the value, reply is unset,
                     and if it is still unset after  the  evalua­
                     tion, the style is treated as if it were not

              zstyle -d [ pattern [ styles ... ] ]
                     Delete style definitions. Without  arguments
                     all  definitions are deleted, with a pattern
                     all definitions for that pattern are deleted
                     and if any styles are given, then only those
                     styles are deleted for the pattern.

              zstyle -g name [ pattern [ style ] ]
                     Retrieve a style  definition.  The  name  is
                     used  as  the  name of an array in which the
                     results  are  stored.  Without  any  further
                     arguments,    all   patterns   defined   are
                     returned. With a pattern the styles  defined
                     for  that pattern are returned and with both
                     a pattern and a style, the value strings  of
                     that combination is returned.

              The other forms can be used to look up or test pat­

              zstyle -a context style name
                     The  value is stored in name as an array. If
                     name is declared as  an  associative  array,
                     the  first,  third, etc. strings are used as
                     the keys and the other strings are  used  as
                     the values.

              zstyle -t context style [ strings ...]
              zstyle -T context style [ strings ...]
                     Test  the  value  of  a  style,  i.e. the -t
                     option only  returns  a  status  (sets  $?).
                     Without  any  strings  the  return status is
                     zero if the style is defined  for  at  least
                     one matching pattern, has only one string in
                     its value, and  that  is  equal  to  one  of
                     `true',  `yes',  `on' or `1'. If any strings
                     are given the status is zero if and only  if
                     at  least  one of the strings is equal to at
                     least one of the strings in  the  value.  If
                     the style is not defined, the status is 2.

                     The  -T option tests the values of the style
                     like -t, but it returns zero (rather than 2)
                     if the style is not defined for any matching

              zstyle -m context style pattern
                     Match a value. Returns status  zero  if  the
                     pattern  matches at least one of the strings
                     in the value.

       zformat -f param format specs ...
       zformat -a array sep specs ...
              This builtin provides two different forms  of  for­
              matting.  The  first  form  is selected with the -f
              option. In this case the format string will be mod­
              ified  by  replacing sequences starting with a per­
              cent sign in it with strings from the specs.   Each
              spec should be of the form `char:string' which will
              cause every appearance of the sequence  `%char'  in
              format  to  be  replaced  by  the  string.  The `%'
              sequence may also contain optional minimum and max­
              imum field width specifications between the `%' and
              the `char' in the form `%min.maxc', i.e. the  mini­
              mum  field  width is given first and if the maximum
              field width is used, it has to  be  preceded  by  a
              dot.   Specifying  a  minimum field width makes the
              result be padded with spaces to the  right  if  the
              string   is   shorter  than  the  requested  width.
              Padding to the left can be  achieved  by  giving  a
              negative  minimum  field width.  If a maximum field
              are printed below each other.  All strings  without
              a  colon are left unchanged and all strings with an
              empty right string have the trailing colon removed.
              In  both  cases  the lengths of the strings are not
              used to determine how the other strings are  to  be
              aligned.   The  resulting strings are stored in the

              This implements some internals of the  _regex_argu­
              ments function.

       zparseopts  [ -D ] [ -K ] [ -E ] [ -a array ] [ -A assoc ]
              This  builtin  simplifies the parsing of options in
              positional parameters, i.e. the  set  of  arguments
              given  by  $*.   Each spec describes one option and
              must be of the form `opt[=array]'.   If  an  option
              described by opt is found in the positional parame­
              ters it is copied into the array specified with the
              -a option; if the optional `=array' is given, it is
              instead copied into that array.

              Note that it is an error to give any  spec  without
              an  `=array'  unless one of the -a or -A options is

              Unless the -E option is given, parsing stops at the
              first  string  that  isn't  described by one of the
              specs.  Even with -E, parsing  always  stops  at  a
              positional parameter equal to `-' or `--'.

              The  opt  description must be one of the following.
              Any of the special characters  can  appear  in  the
              option name provided it is preceded by a backslash.

              name+  The name is the name of the  option  without
                     the  leading  `-'.   To  specify a GNU-style
                     long option, one of the  usual  two  leading
                     `-' must be included in name; for example, a
                     `--file' option is represented by a name  of

                     If  a  `+' appears after name, the option is
                     appended to array each time it is  found  in
                     the  positional  parameters; without the `+'
                     only the last occurrence of  the  option  is

                     If  one  of  these forms is used, the option
                     takes no argument, so parsing stops  if  the
                     this makes empty strings as arguments indis­
                     tinguishable).   A  mandatory  argument   is
                     added  as a separate element unless the `:-'
                     form is used, in which case the argument  is
                     put into the same element.

                     A  `+' as described above may appear between
                     the name and the first colon.

       The options of zparseopts itself are:

       -a array
              As described above, this names the default array in
              which to store the recognised options.

       -A assoc
              If  this is given, the options and their values are
              also put into an associative array with the  option
              names  as  keys  and  the arguments (if any) as the

       -D     If this option is  given,  all  options  found  are
              removed from the positional parameters of the call­
              ing shell or shell function, up to but not  includ­
              ing  any not described by the specs.  This is simi­
              lar to using the shift builtin.

       -K     With this option, the arrays specified with the  -a
              and -A options and with the `=array' forms are kept
              unchanged when none of the specs for them is  used.
              This  allows  assignment  of default values to them
              before calling zparseopts.

       -E     This changes the parsing rules to not stop  at  the
              first  string  that  isn't  described by one of the
              specs.  It can be used to  test  for  or  (if  used
              together  with  -D) extract options and their argu­
              ments, ignoring all  other  options  and  arguments
              that may be in the positional parameters.

       For example,

              set -- -a -bx -c y -cz baz -cend
              zparseopts a=foo b:=bar c+:=bar

       will have the effect of

              bar=(-b x -c y -c z)

       The arguments from `baz' on will not be used.

       The zsh/net/tcp module makes available  one  builtin  com­

       ztcp [ -acflLtv ] [ -d fd ] [ args ]
              ztcp  is implemented as a builtin to allow full use
              of shell command line editing, file  I/O,  and  job
              control mechanisms.

              If  ztcp is run with no options, it will output the
              contents of its session table.

              If it is run with only the option -L, it will  out­
              put  the  contents of the session table in a format
              suitable for  automatic  parsing.   The  option  is
              ignored  if given with a command to open or close a
              session.  The output consists of a  set  of  lines,
              one per session, each containing the following ele­
              ments separated by spaces:

              File descriptor
                     The file descriptor in use for  the  connec­
                     tion.   For  normal inbound (I) and outbound
                     (O) connections this may be read and written
                     by  the usual shell mechanisms.  However, it
                     should only be close with `ztcp -c'.

              Connection type
                     A letter indicating how the session was cre­

                      Z      A session created with the zftp com­

                      L      A connection  opened  for  listening
                             with `ztcp -l'.

                      I      An  inbound connection accepted with
                             `ztcp -a'.

                      O      An outbound connection created  with
                             `ztcp host ...'.

              The local host
                     This  is  usually  set  to  an  all-zero  IP
                     address as the address of the  localhost  is

              The local port
                     This is likely to be zero unless the connec­
                     tion is for listening.

              omitted,  it  will default to port 23.  The connec­
              tion will be added to the  session  table  and  the
              shell  parameter  REPLY  will  be  set  to the file
              descriptor associated with that connection.

              If -d is specified, its argument will be  taken  as
              the target file descriptor for the connection.

              In order to elicit more verbose output, use -v.

   Inbound Connections
       ztcp -l [ -v ] [ -d fd ] port
              ztcp  -l  will open a socket listening on TCP port.
              The socket will be added to the session  table  and
              the  shell  parameter REPLY will be set to the file
              descriptor associated with that listener.

              If -d is specified, its argument will be  taken  as
              the target file descriptor for the connection.

              In order to elicit more verbose output, use -v.

       ztcp -a [ -tv ] [ -d targetfd ] listenfd
              ztcp  -a  will accept an incoming connection to the
              port associated with listenfd.  The connection will
              be added to the session table and the shell parame­
              ter REPLY will be set to the file descriptor  asso­
              ciated with the inbound connection.

              If  -d  is specified, its argument will be taken as
              the target file descriptor for the connection.

              If -t is specified, ztcp will return if no incoming
              connection  is pending.  Otherwise it will wait for

              In order to elicit more verbose output, use -v.

   Closing Connections
       ztcp -cf [ -v ] [ fd ]
       ztcp -c [ -v ] [ fd ]
              ztcp -c will close the socket associated  with  fd.
              The  socket will be removed from the session table.
              If fd is not specified, ztcp will close  everything
              in the session table.

              Normally,  sockets  registered by zftp (see zshmod­
              ules(1) ) cannot be closed this way.  In  order  to
              force such a socket closed, use -f.

       The  second  from  last  command  blocks until there is an
       incoming connection.

       Now create a connection from host2 (which may, of  course,
       be the same machine):
              zmodload zsh/net/tcp
              ztcp host1 5123

       Now on each host, $fd contains a file descriptor for talk­
       ing to the other.  For example, on host1:
              print This is a message >&$fd
       and on host2:
              read -r line <&$fd; print -r - $line
       prints `This is a message'.

       To tidy up, on host1:
              ztcp -c $listenfd
              ztcp -c $fd
       and on host2
              ztcp -c $fd

zsh 4.1.1                 June 18, 2003             ZSHMODULES(1)
Help us cut cost by not downloading the whole site!
Use of automated download sofware ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and therefore is expressedly prohibited. For more details on this, take a look here



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 welcomes your suggestions and ideas.


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.25 Seconds