zshzle man page on UnixWare

Man page or keyword search:  
man Server   3616 pages
apropos Keyword Search (all sections)
Output format
UnixWare logo
[printable version]

ZSHZLE(1)							     ZSHZLE(1)

NAME
       zshzle - zsh command line editor

DESCRIPTION
       If the ZLE option is set (which it is by default in interactive shells)
       and the shell input is attached to the terminal, the user  is  able  to
       edit command lines.

       There  are  two	display	 modes.	  The  first,  multiline  mode, is the
       default.	 It only works if the TERM parameter is set to a valid	termi‐
       nal type that can move the cursor up.  The second, single line mode, is
       used if TERM is invalid or incapable of moving the cursor up, or if the
       SINGLE_LINE_ZLE	option	is set.	 This mode is similar to ksh, and uses
       no termcap sequences.  If TERM is "emacs", the ZLE option will be unset
       by default.

       The  parameters BAUD, COLUMNS, and LINES are also used by the line edi‐
       tor.  See Parameters Used By The Shell in zshparam(1).

KEYMAPS
       A keymap in ZLE contains a set of bindings between  key	sequences  and
       ZLE commands.  The empty key sequence cannot be bound.

       There can be any number of keymaps at any time, and each keymap has one
       or more names.  If all of a keymap's names are deleted, it  disappears.
       bindkey can be used to manipulate keymap names.

       Initially, there are four keymaps:

       emacs  EMACS emulation
       viins  vi emulation - insert mode
       vicmd  vi emulation - command mode
       .safe  fallback keymap

       The  `.safe'  keymap is special.	 It can never be altered, and the name
       can never be removed.  However, it can be linked to other names,	 which
       can  be	removed.   In  the  future other special keymaps may be added;
       users should avoid  using  names	 beginning  with  `.'  for  their  own
       keymaps.

       In  addition  to	 these	four  names, either `emacs' or `viins' is also
       linked to the name `main'.  If one of the VISUAL or EDITOR  environment
       variables contain the string `vi' when the shell starts up then it will
       be `viins', otherwise it will be `emacs'.  bindkey's -e and -v  options
       provide a convenient way to override this default choice.

       When  the  editor starts up, it will select the `main' keymap.  If that
       keymap doesn't exist, it will use `.safe' instead.

       In the `.safe' keymap, each single key is bound to self-insert,	except
       for  ^J	(line  feed)  and  ^M (return) which are bound to accept-line.
       This is deliberately not pleasant to use; if you are using it, it means
       you deleted the main keymap, and you should put it back.

   Reading Commands
       When ZLE is reading a command from the terminal, it may read a sequence
       that is bound to some command and is also a prefix of  a	 longer	 bound
       string.	In this case ZLE will wait a certain time to see if more char‐
       acters are typed, and if not (or they don't match any longer string) it
       will  execute  the  binding.  This timeout is defined by the KEYTIMEOUT
       parameter; its default is 0.4 sec.  There is no timeout if  the	prefix
       string is not itself bound to a command.

       As  well	 as ZLE commands, key sequences can be bound to other strings,
       by using `bindkey -s'.  When such a sequence is read,  the  replacement
       string  is pushed back as input, and the command reading process starts
       again using these fake keystrokes.  This input can itself  invoke  fur‐
       ther replacement strings, but in order to detect loops the process will
       be stopped if there are twenty such replacements without a real command
       being read.

ZLE BUILTINS
       The  ZLE	 module	 contains  three related builtin commands. The bindkey
       command manipulates keymaps and key bindings; the vared command invokes
       ZLE  on the value of a shell parameter; and the zle command manipulates
       editing widgets and allows command line access  to  ZLE	commands  from
       within shell functions.

       bindkey [ options ] -l
       bindkey [ options ] -d
       bindkey [ options ] -D keymap ...
       bindkey [ options ] -A old-keymap new-keymap
       bindkey [ options ] -N new-keymap [ old-keymap ]
       bindkey [ options ] -m
       bindkey [ options ] -r in-string ...
       bindkey [ options ] -s in-string out-string ...
       bindkey [ options ] in-string command ...
       bindkey [ options ] [ in-string ]
	      bindkey's	 options  can be divided into three categories: keymap
	      selection, operation selection, and others.  The	keymap	selec‐
	      tion options are:

	      -e     Selects keymap `emacs', and also links it to `main'.

	      -v     Selects keymap `viins', and also links it to `main'.

	      -a     Selects keymap `vicmd'.

	      -M     The  first	 non-option argument is used as a keymap name,
		     and does not otherwise count as an argument.

	      If a keymap selection is required and none of the options	 above
	      are  used,  the  `main'  keymap is used.	Some operations do not
	      permit a keymap to be selected, namely:

	      -l     List all existing keymap names.  If the -L option is also
		     used,  list in the form of bindkey commands to create the
		     keymaps.

	      -d     Delete all existing keymaps  and  reset  to  the  default
		     state.

	      -D keymap ...
		     Delete the named keymaps.

	      -A old-keymap new-keymap
		     Make the new-keymap name an alias for old-keymap, so that
		     both names refer to the  same  keymap.   The  names  have
		     equal  standing; if either is deleted, the other remains.
		     If there is already a keymap with the new-keymap name, it
		     is deleted.

	      -N new-keymap [ old-keymap ]
		     Create  a	new  keymap,  named  new-keymap.   If a keymap
		     already has that name, it is deleted.  If	an  old-keymap
		     name  is  given,  the  new	 keymap is initialized to be a
		     duplicate of it, otherwise the new keymap will be empty.

	      To use a newly created keymap, it	 should	 be  linked  to	 main.
	      Hence  the  sequence  of commands to create and use a new keymap
	      `mymap'  initialized  from  the  emacs  keymap  (which   remains
	      unchanged) is:

		     bindkey -N mymap emacs
		     bindkey -A mymap main

	      Note  that  while `bindkey -A newmap main' will work when newmap
	      is emacs or viins, it will not work for vicmd, as switching from
	      vi insert to command mode becomes impossible.

	      The  following  operations act on the `main' keymap if no keymap
	      selection option was given:

	      -m     Add the built-in set of meta-key bindings to the selected
		     keymap.	Only   keys  that  are	unbound	 or  bound  to
		     self-insert are affected.

	      -r in-string ...
		     Unbind the specified in-strings in the  selected  keymap.
		     This  is  exactly	equivalent  to	binding the strings to
		     undefined-key.

		     When -R is also used, interpret the in-strings as ranges.

		     When -p is also used, the	in-strings  specify  prefixes.
		     Any binding that has the given in-string as a prefix, not
		     including the binding for the in-string itself,  if  any,
		     will be removed.  For example,

			    bindkey -rpM viins '^['

		     will  remove  all bindings in the vi-insert keymap begin‐
		     ning with an escape character (probably cursor keys), but
		     leave the binding for the escape character itself (proba‐
		     bly vi-cmd-mode).	This is incompatible with  the	option
		     -R.

	      -s in-string out-string ...
		     Bind  each	 in-string to each out-string.	When in-string
		     is typed, out-string will be pushed back and  treated  as
		     input  to	the line editor.  When -R is also used, inter‐
		     pret the in-strings as ranges.

	      in-string command ...
		     Bind each in-string to each command.  When	 -R  is	 used,
		     interpret the in-strings as ranges.

	      [ in-string ]
		     List  key	bindings.   If	an in-string is specified, the
		     binding of that string in the  selected  keymap  is  dis‐
		     played.   Otherwise,  all	key  bindings  in the selected
		     keymap are displayed.  (As a special case, if the	-e  or
		     -v	 option	 is  used alone, the keymap is not displayed -
		     the implicit linking of keymaps is the  only  thing  that
		     happens.)

		     When  the	option	-p  is	used,  the  in-string  must be
		     present.  The listing shows all bindings which  have  the
		     given  key	 sequence as a prefix, not including any bind‐
		     ings for the key sequence itself.

		     When the -L option is used, the list is in	 the  form  of
		     bindkey commands to create the key bindings.

       When  the  -R  option is used as noted above, a valid range consists of
       two characters, with an optional	 `-'  between  them.   All  characters
       between the two specified, inclusive, are bound as specified.

       For  either in-string or out-string, the following escape sequences are
       recognised:

       \a     bell character
       \b     backspace
       \e, \E escape
       \f     form feed
       \n     linefeed (newline)
       \r     carriage return
       \t     horizontal tab
       \v     vertical tab
       \NNN   character code in octal
       \xNN   character code in hexadecimal
       \M[-]X character with meta bit set
       \C[-]X control character
       ^X     control character

       In all other cases, `\' escapes the  following  character.   Delete  is
       written	as  `^?'.   Note  that `\M^?' and `^\M?' are not the same, and
       that (unlike emacs), the bindings `\M-X' and `\eX'  are	entirely  dis‐
       tinct,  although	 they are initialized to the same bindings by `bindkey
       -m'.

       vared [ -Aache ] [ -p prompt ] [ -r rprompt ] name
	      The value of the parameter name is loaded into the edit  buffer,
	      and  the line editor is invoked.	When the editor exits, name is
	      set to the string value returned by the  editor.	 When  the  -c
	      flag  is	given,	the parameter is created if it doesn't already
	      exist.  The -a flag may be given with  -c	 to  create  an	 array
	      parameter,  or  the  -A flag to create an associative array.  If
	      the type of an existing parameter does not match the type to  be
	      created, the parameter is unset and recreated.

	      If an array or array slice is being edited, separator characters
	      as defined in $IFS will be shown quoted  with  a	backslash,  as
	      will  backslashes	 themselves.  Conversely, when the edited text
	      is split into an array, a backslash quotes an  immediately  fol‐
	      lowing  separator	 character or backslash; no other special han‐
	      dling of backslashes, or any handling of quotes, is performed.

	      Individual elements  of  existing	 array	or  associative	 array
	      parameters may be edited by using subscript syntax on name.  New
	      elements are created automatically, even without -c.

	      If the -p flag is given, the following string will be  taken  as
	      the prompt to display at the left.  If the -r flag is given, the
	      following string gives the prompt to display at the  right.   If
	      the  -h flag is specified, the history can be accessed from ZLE.
	      If the -e flag is given, typing ^D (Control-D) on an empty  line
	      causes vared to exit immediately with a non-zero return value.

       zle -l [ -L | -a ] [ string ... ]
       zle -D widget ...
       zle -A old-widget new-widget
       zle -N widget [ function ]
       zle -C widget completion-widget function
       zle -R [ -c ] [ display-string ] [ string ... ]
       zle -M string
       zle -U string
       zle -I
       zle widget [ -n num ] [ -N ] args ...
       zle    The  zle builtin performs a number of different actions concern‐
	      ing ZLE.	Which operation it performs depends on its options:

	      -l [ -L | -a ]
		     List all existing user-defined widgets.  If the -L option
		     is	 used,	list in the form of zle commands to create the
		     widgets.

		     When combined with the -a option, all  widget  names  are
		     listed,  including	 the builtin ones. In this case the -L
		     option is ignored.

		     If at least one string is given, nothing will be  printed
		     but  the  return  status  will be zero if all strings are
		     names of existing widgets (or of user-defined widgets  if
		     the  -a  flag  is not given) and non-zero if at least one
		     string is not a name of an defined widget.

	      -D widget ...
		     Delete the named widgets.

	      -A old-widget new-widget
		     Make the new-widget name an alias for old-widget, so that
		     both  names  refer	 to  the  same widget.	The names have
		     equal standing; if either is deleted, the other  remains.
		     If there is already a widget with the new-widget name, it
		     is deleted.

	      -N widget [ function ]
		     Create a user-defined widget.  If there is already a wid‐
		     get with the specified name, it is overwritten.  When the
		     new widget is invoked from within the editor, the	speci‐
		     fied  shell  function  is called.	If no function name is
		     specified, it defaults to the same name  as  the  widget.
		     For  further information, see the section Widgets in zsh‐
		     zle(1).

	      -C widget completion-widget function
		     Create a user-defined completion widget named widget. The
		     completion	 widget	 will behave like the built-in comple‐
		     tion-widget whose name is given as completion-widget.  To
		     generate  the  completions,  the  shell function function
		     will be called.  For further  information,	 see  zshcomp‐
		     wid(1).

	      -R [ -c ] [ display-string ] [ string ... ]
		     Redisplay	the  command  line;  this is to be called from
		     within a user-defined widget to allow changes  to	become
		     visible.	If  a  display-string  is given and not empty,
		     this is shown in the status line (immediately  below  the
		     line being edited).

		     If	 the  optional strings are given they are listed below
		     the prompt in  the	 same  way  as	completion  lists  are
		     printed.  If  no  strings	are given but the -c option is
		     used such a list is cleared.

		     Note that this option is only useful for widgets that  do
		     not  exit	immediately after using it because the strings
		     displayed will be erased immediately  after  return  from
		     the widget.

		     This  command  can	 safely be called outside user defined
		     widgets; if zle is active, the display will be refreshed,
		     while  if	zle  is not active, the command has no effect.
		     In this case there will usually be	 no  other  arguments.
		     The status is zero if zle was active, else one.

	      -M string
		     As with the -R option, the string will be displayed below
		     the command line; unlike the -R option, the  string  will
		     not  be  put  into	 the  status  line but will instead be
		     printed normally below the prompt.	 This means  that  the
		     string  will  still be displayed after the widget returns
		     (until it is overwritten by subsequent commands).

	      -U string
		     This pushes the characters in the string onto  the	 input
		     stack  of	ZLE.  After the widget currently executed fin‐
		     ishes ZLE will behave as if the characters in the	string
		     were typed by the user.

		     As	 ZLE  uses  a stack, if this option is used repeatedly
		     the last string pushed onto the stack will	 be  processed
		     first.   However,	the  characters in each string will be
		     processed in the  order  in  which	 they  appear  in  the
		     string.

	      -I     Unusually,	 this  option  is only useful outside ordinary
		     widget functions.	It invalidates the current zle display
		     in	 preparation  for  output; usually this will be from a
		     trap function.  It has no effect if zle  is  not  active.
		     When a trap exits, the shell checks to see if the display
		     needs restoring, hence the following will print output in
		     such a way as not to disturb the line being edited:

			    TRAPUSR1() {
				# Invalidate zle display
			      zle -I
				# Show output
			      print Hello
			    }

		     Note  that there are better ways of manipulating the dis‐
		     play from within zle widgets.  In general, the trap func‐
		     tion  may need to test whether zle is loaded before using
		     this method; if it is not, there is no point  in  loading
		     it specially since the line editor will not be active.

		     The status is zero if zle was active, else one.

	      widget [ -n num ] [ -N ] args ...
		     Invoke  the specified widget.  This can only be done when
		     ZLE  is  active;  normally	 this	will   be   within   a
		     user-defined widget.

		     With  the	options -n and -N, the current numerical argu‐
		     ment will be saved and then restored after	 the  call  to
		     widget;  `-n num' sets the numerical argument temporarily
		     to num, while `-N' sets it to the	default,  i.e.	as  if
		     there were none.

		     Any  further  arguments will be passed to the widget.  If
		     it is a shell function, these are passed  down  as	 posi‐
		     tional  parameters;  for  builtin widgets it is up to the
		     widget in question what it	 does  with  them.   Currently
		     arguments are only handled by the incremental-search com‐
		     mands, the history-search-forward and -backward  and  the
		     corresponding  functions  prefixed by vi-, and by univer‐
		     sal-argument.  No error is flagged if  the	 command  does
		     not use the arguments, or only uses some of them.

		     The  return status reflects the success or failure of the
		     operation carried out by  the  widget,  or	 if  it	 is  a
		     user-defined  widget the return status of the shell func‐
		     tion.

		     A non-zero return status causes the shell	to  beep  when
		     the  widget  exits,  unless the BEEP options was unset or
		     the widget was called via the zle	command.   Thus	 if  a
		     user defined widget requires an immediate beep, it should
		     call the beep widget directly.

       With no options and no arguments, only the return status will  be  set.
       It  is  zero  if	 ZLE  is currently active and widgets could be invoked
       using this builtin command and non-zero if ZLE is not active.

WIDGETS
       All actions in the editor are performed by `widgets'.  A	 widget's  job
       is  simply  to  perform	some  small action.  The ZLE commands that key
       sequences in keymaps are bound to are in fact widgets.  Widgets can  be
       user-defined or built in.

       The  standard  widgets  built  in to ZLE are listed in Standard Widgets
       below.  Other built-in widgets can be defined  by  other	 modules  (see
       zshmodules(1)).	Each built-in widget has two names: its normal canoni‐
       cal name, and the same name preceded by a `.'.  The `.'	name  is  spe‐
       cial: it can't be rebound to a different widget.	 This makes the widget
       available even when its usual name has been redefined.

       User-defined widgets are defined using `zle  -N',  and  implemented  as
       shell  functions.  When the widget is executed, the corresponding shell
       function is executed, and can perform editing (or other)	 actions.   It
       is recommended that user-defined widgets should not have names starting
       with `.'.

USER-DEFINED WIDGETS
       User-defined widgets, being implemented as shell functions, can execute
       any  normal  shell  command.   They can also run other widgets (whether
       built-in or user-defined) using the zle builtin command.	 The  standard
       input of the function is closed to prevent external commands from unin‐
       tentionally blocking ZLE by reading from the terminal, but read	-k  or
       read  -q can be used to read characters.	 Finally, they can examine and
       edit the ZLE buffer being edited by reading  and	 setting  the  special
       parameters described below.

       These  special parameters are always available in widget functions, but
       are not in any way special outside ZLE.	If they have some normal value
       outside	ZLE,  that  value is temporarily inaccessible, but will return
       when the widget function exits.	These special parameters in fact  have
       local scope, like parameters created in a function using local.

       Inside  completion  widgets and traps called while ZLE is active, these
       parameters are available read-only.

       BUFFER (scalar)
	      The entire contents of the edit buffer.  If it  is  written  to,
	      the  cursor remains at the same offset, unless that would put it
	      outside the buffer.

       BUFFERLINES
	      The number of screen lines needed for the edit buffer  currently
	      displayed	 on  screen (i.e. without any changes to the preceding
	      parameters done after the last redisplay).

       CURSOR (integer)
	      The offset of the cursor, within the edit buffer.	  This	is  in
	      the  range  0  to	 $#BUFFER,  and	 is  by	 definition  equal  to
	      $#LBUFFER.  Attempts to move the cursor outside the buffer  will
	      result  in  the cursor being moved to the appropriate end of the
	      buffer.

       HISTNO (integer)
	      The current history number.

       KEYS (scalar)
	      The keys typed to invoke this widget, as a literal string.

       LASTWIDGET (scalar)
	      The name of the last widget that was executed.

       LBUFFER (scalar)
	      The part of the buffer that lies to the left of the cursor posi‐
	      tion.   If  it  is  assigned to, only that part of the buffer is
	      replaced, and the cursor remains between the  new	 $LBUFFER  and
	      the old $RBUFFER.

       MARK (integer)
	      Like CURSOR, but for the mark.

       NUMERIC (integer)
	      The  numeric  argument.  If  no numeric argument was given, this
	      parameter is unset. When this is set inside a  widget  function,
	      builtin widgets called with the zle builtin command will use the
	      value assigned. If it is unset inside a widget function, builtin
	      widgets called behave as if no numeric argument was given.

       PENDING (integer)
	      The  number of bytes pending for input, i.e. the number of bytes
	      which have already been typed and can immediately	 be  read.  On
	      systems  where  the  shell  is not able to get this information,
	      this parameter will always have a value of zero.

       PREBUFFER (scalar)
	      In a multi-line input at the secondary  prompt,  this  read-only
	      parameter	 contains the contents of the lines before the one the
	      cursor is currently in.

       RBUFFER (scalar)
	      The part of the buffer that lies to  the	right  of  the	cursor
	      position.	 If it is assigned to, only that part of the buffer is
	      replaced, and the cursor remains between the  old	 $LBUFFER  and
	      the new $RBUFFER.

       WIDGET (scalar)
	      The name of the widget currently being executed.

STANDARD WIDGETS
       The  following is a list of all the standard widgets, and their default
       bindings in emacs mode,	vi  command  mode  and	vi  insert  mode  (the
       `emacs', `vicmd' and `viins' keymaps, respectively).

       Note  that cursor keys are bound to movement keys in all three keymaps;
       the shell assumes that the cursor keys send the key sequences  reported
       by  the	terminal-handling  library  (termcap  or  terminfo).   The key
       sequences shown in the list are those based on  the  VT100,  common  on
       many modern terminals, but in fact these are not necessarily bound.  In
       the case of the viins keymap,  the  initial  escape  character  of  the
       sequences  serves also to return to the vicmd keymap: whether this hap‐
       pens is determined by the KEYTIMEOUT parameter, see zshparam(1).

   Movement
       vi-backward-blank-word (unbound) (B) (unbound)
	      Move backward one word, where a word is defined as a  series  of
	      non-blank characters.

       backward-char (^B ESC-[D) (unbound) (unbound)
	      Move backward one character.

       vi-backward-char (unbound) (^H h ^?) (ESC-[D)
	      Move backward one character, without changing lines.

       backward-word (ESC-B ESC-b) (unbound) (unbound)
	      Move to the beginning of the previous word.

       emacs-backward-word
	      Move to the beginning of the previous word.

       vi-backward-word (unbound) (b) (unbound)
	      Move to the beginning of the previous word, vi-style.

       beginning-of-line (^A) (unbound) (unbound)
	      Move  to the beginning of the line.  If already at the beginning
	      of the line, move to the beginning of the previous line, if any.

       vi-beginning-of-line
	      Move to the beginning of the line, without changing lines.

       end-of-line (^E) (unbound) (unbound)
	      Move to the end of the line.  If already at the end of the line,
	      move to the end of the next line, if any.

       vi-end-of-line (unbound) ($) (unbound)
	      Move  to	the  end of the line.  If an argument is given to this
	      command, the cursor will be moved to the end of the line	(argu‐
	      ment - 1) lines down.

       vi-forward-blank-word (unbound) (W) (unbound)
	      Move  forward  one  word, where a word is defined as a series of
	      non-blank characters.

       vi-forward-blank-word-end (unbound) (E) (unbound)
	      Move to the end of the current word, or, if at the  end  of  the
	      current  word,  to  the  end  of	the next word, where a word is
	      defined as a series of non-blank characters.

       forward-char (^F ESC-[C) (unbound) (unbound)
	      Move forward one character.

       vi-forward-char (unbound) (space l) (ESC-[C)
	      Move forward one character.

       vi-find-next-char (^X^F) (f) (unbound)
	      Read a character from the keyboard, and move to the next	occur‐
	      rence of it in the line.

       vi-find-next-char-skip (unbound) (t) (unbound)
	      Read  a  character  from	the keyboard, and move to the position
	      just before the next occurrence of it in the line.

       vi-find-prev-char (unbound) (F) (unbound)
	      Read a character from the keyboard, and  move  to	 the  previous
	      occurrence of it in the line.

       vi-find-prev-char-skip (unbound) (T) (unbound)
	      Read  a  character  from	the keyboard, and move to the position
	      just after the previous occurrence of it in the line.

       vi-first-non-blank (unbound) (^) (unbound)
	      Move to the first non-blank character in the line.

       vi-forward-word (unbound) (w) (unbound)
	      Move forward one word, vi-style.

       forward-word (ESC-F ESC-f) (unbound) (unbound)
	      Move to the beginning of the next word.  The editor's idea of  a
	      word is specified with the WORDCHARS parameter.

       emacs-forward-word
	      Move to the end of the next word.

       vi-forward-word-end (unbound) (e) (unbound)
	      Move to the end of the next word.

       vi-goto-column (ESC-|) (|) (unbound)
	      Move to the column specified by the numeric argument.

       vi-goto-mark (unbound) (`) (unbound)
	      Move to the specified mark.

       vi-goto-mark-line (unbound) (') (unbound)
	      Move to beginning of the line containing the specified mark.

       vi-repeat-find (unbound) (;) (unbound)
	      Repeat the last vi-find command.

       vi-rev-repeat-find (unbound) (,) (unbound)
	      Repeat the last vi-find command in the opposite direction.

   History Control
       beginning-of-buffer-or-history (ESC-<) (unbound) (unbound)
	      Move  to	the beginning of the buffer, or if already there, move
	      to the first event in the history list.

       beginning-of-line-hist
	      Move to the beginning of the line.  If already at the  beginning
	      of the buffer, move to the previous history line.

       beginning-of-history
	      Move to the first event in the history list.

       down-line-or-history (^N ESC-[B) (j) (ESC-[B)
	      Move  down  a  line  in  the buffer, or if already at the bottom
	      line, move to the next event in the history list.

       vi-down-line-or-history (unbound) (+) (unbound)
	      Move down a line in the buffer, or  if  already  at  the	bottom
	      line,  move to the next event in the history list.  Then move to
	      the first non-blank character on the line.

       down-line-or-search
	      Move down a line in the buffer, or  if  already  at  the	bottom
	      line,  search  forward  in the history for a line beginning with
	      the first word in the buffer.

	      If called from a function by the zle command with arguments, the
	      first  argument  is  taken  as  the  string for which to search,
	      rather than the first word in the buffer.

       down-history (unbound) (^N) (unbound)
	      Move to the next event in the history list.

       history-beginning-search-backward
	      Search backward in the history for a  line  beginning  with  the
	      current  line  up	 to the cursor.	 This leaves the cursor in its
	      original position.

       end-of-buffer-or-history (ESC->) (unbound) (unbound)
	      Move to the end of the buffer, or if already there, move to  the
	      last event in the history list.

       end-of-line-hist
	      Move  to the end of the line.  If already at the end of the buf‐
	      fer, move to the next history line.

       end-of-history
	      Move to the last event in the history list.

       vi-fetch-history (unbound) (G) (unbound)
	      Fetch the history line specified by the numeric argument.	  This
	      defaults	to  the	 current history line (i.e. the one that isn't
	      history yet).

       history-incremental-search-backward (^R ^Xr) (unbound) (unbound)
	      Search backward  incrementally  for  a  specified	 string.   The
	      search  is  case-insensitive  if the search string does not have
	      uppercase letters and no numeric argument was given.  The string
	      may  begin with `^' to anchor the search to the beginning of the
	      line.

	      A restricted set	of  editing  functions	is  available  in  the
	      mini-buffer.   An	 interrupt signal, as defined by the stty set‐
	      ting, will stop the search and go back to the original line.  An
	      undefined key will have the same effect. The supported functions
	      are:	 backward-delete-char,	      vi-backward-delete-char,
	      clear-screen,    redisplay,   quoted-insert,   vi-quoted-insert,
	      accept-and-hold, accept-and-infer-next-history, accept-line  and
	      accept-line-and-down-history.

	      magic-space  just	 inserts a space.  vi-cmd-mode toggles between
	      the `main' and `vicmd' keymaps; the `main' keymap (insert	 mode)
	      will be selected initially.  history-incremental-search-backward
	      will get the next occurrence of the contents of the mini-buffer.
	      history-incremental-search-forward  inverts  the	sense  of  the
	      search.  vi-repeat-search and vi-rev-repeat-search are similarly
	      supported.   The	direction  of  the  search is indicated in the
	      mini-buffer.

	      Any multi-character string that is not bound to one of the above
	      functions	 will  beep and interrupt the search, leaving the last
	      found line in the buffer. Any single character that is not bound
	      to   one	 of   the   above   functions,	 or   self-insert   or
	      self-insert-unmeta, will have the same effect but	 the  function
	      will be executed.

	      When  called  from  a  widget  function  by the zle command, the
	      incremental search commands can take a  string  argument.	  This
	      will  be	treated	 as  a string of keys, as for arguments to the
	      bindkey command, and used as initial input for the command.  Any
	      characters  in  the  string  which are unused by the incremental
	      search will be silently ignored.	For example,

		     zle history-incremental-search-backward forceps

	      will search backwards for forceps, leaving the  minibuffer  con‐
	      taining the string `forceps'.

       history-incremental-search-forward (^S ^Xs) (unbound) (unbound)
	      Search forward incrementally for a specified string.  The search
	      is case-insensitive if the search string does not have uppercase
	      letters and no numeric argument was given.  The string may begin
	      with `^' to anchor the search to the beginning of the line.  The
	      functions	 available in the mini-buffer are the same as for his‐
	      tory-incremental-search-backward.

       history-search-backward (ESC-P ESC-p) (unbound) (unbound)
	      Search backward in the history for a  line  beginning  with  the
	      first word in the buffer.

	      If called from a function by the zle command with arguments, the
	      first argument is taken as  the  string  for  which  to  search,
	      rather than the first word in the buffer.

       vi-history-search-backward (unbound) (/) (unbound)
	      Search  backward	in  the	 history  for a specified string.  The
	      string may begin with `^' to anchor the search to the  beginning
	      of the line.

	      A	 restricted  set  of  editing  functions  is  available in the
	      mini-buffer.  An interrupt signal, as defined by the  stty  set‐
	      ting,   will  stop  the  search.	The functions available in the
	      mini-buffer  are:	 accept-line,  backward-delete-char,  vi-back‐
	      ward-delete-char,	  backward-kill-word,	vi-backward-kill-word,
	      clear-screen, redisplay, quoted-insert and vi-quoted-insert.

	      vi-cmd-mode is treated the same as accept-line, and  magic-space
	      is treated as a space.  Any other character that is not bound to
	      self-insert or self-insert-unmeta will beep and be  ignored.  If
	      the function is called from vi command mode, the bindings of the
	      current insert mode will be used.

	      If called from a function by the zle command with arguments, the
	      first  argument  is  taken  as  the  string for which to search,
	      rather than the first word in the buffer.

       history-search-forward (ESC-N ESC-n) (unbound) (unbound)
	      Search forward in the history for	 a  line  beginning  with  the
	      first word in the buffer.

	      If called from a function by the zle command with arguments, the
	      first argument is taken as  the  string  for  which  to  search,
	      rather than the first word in the buffer.

       vi-history-search-forward (unbound) (?) (unbound)
	      Search  forward  in  the	history	 for  a specified string.  The
	      string may begin with `^' to anchor the search to the  beginning
	      of  the line. The functions available in the mini-buffer are the
	      same as for vi-history-search-backward.	Argument  handling  is
	      also the same as for that command.

       infer-next-history (^X^N) (unbound) (unbound)
	      Search  in  the history list for a line matching the current one
	      and fetch the event following it.

       insert-last-word (ESC-_ ESC-.) (unbound) (unbound)
	      Insert the last word from the previous history event at the cur‐
	      sor  position.   If a positive numeric argument is given, insert
	      that word from the end of the previous history  event.   If  the
	      argument	is  zero  or  negative	insert that word from the left
	      (zero inserts the previous command word).	 Repeating  this  com‐
	      mand replaces the word just inserted with the last word from the
	      history event prior to the one just used; numeric arguments  can
	      be used in the same way to pick a word from that event.

       vi-repeat-search (unbound) (n) (unbound)
	      Repeat the last vi history search.

       vi-rev-repeat-search (unbound) (N) (unbound)
	      Repeat the last vi history search, but in reverse.

       up-line-or-history (^P ESC-[A) (k) (ESC-[A)
	      Move  up	a  line	 in the buffer, or if already at the top line,
	      move to the previous event in the history list.

       vi-up-line-or-history (unbound) (-) (unbound)
	      Move up a line in the buffer, or if already  at  the  top	 line,
	      move  to	the  previous event in the history list.  Then move to
	      the first non-blank character on the line.

       up-line-or-search
	      Move up a line in the buffer, or if already  at  the  top	 line,
	      search  backward	in  the	 history for a line beginning with the
	      first word in the buffer.

	      If called from a function by the zle command with arguments, the
	      first  argument  is  taken  as  the  string for which to search,
	      rather than the first word in the buffer.

       up-history (unbound) (^P) (unbound)
	      Move to the previous event in the history list.

       history-beginning-search-forward
	      Search forward in the history for a line beginning with the cur‐
	      rent line up to the cursor.  This leaves the cursor in its orig‐
	      inal position.

   Modifying Text
       vi-add-eol (unbound) (A) (unbound)
	      Move to the end of the line and enter insert mode.

       vi-add-next (unbound) (a) (unbound)
	      Enter insert mode after the  current  cursor  position,  without
	      changing lines.

       backward-delete-char (^H ^?) (unbound) (unbound)
	      Delete the character behind the cursor.

       vi-backward-delete-char (unbound) (X) (^H)
	      Delete  the character behind the cursor, without changing lines.
	      If in insert mode, this won't delete past the point where insert
	      mode was last entered.

       backward-delete-word
	      Delete the word behind the cursor.

       backward-kill-line
	      Kill from the beginning of the line to the cursor position.

       backward-kill-word (^W ESC-^H ESC-^?) (unbound) (unbound)
	      Kill the word behind the cursor.

       vi-backward-kill-word (unbound) (unbound) (^W)
	      Kill  the	 word  behind the cursor, without going past the point
	      where insert mode was last entered.

       capitalize-word (ESC-C ESC-c) (unbound) (unbound)
	      Capitalize the current word and move past it.

       vi-change (unbound) (c) (unbound)
	      Read a movement command from the keyboard,  and  kill  from  the
	      cursor  position	to  the	 endpoint of the movement.  Then enter
	      insert mode.  If the command is vi-change,  change  the  current
	      line.

       vi-change-eol (unbound) (C) (unbound)
	      Kill to the end of the line and enter insert mode.

       vi-change-whole-line (unbound) (S) (unbound)
	      Kill the current line and enter insert mode.

       copy-region-as-kill (ESC-W ESC-w) (unbound) (unbound)
	      Copy the area from the cursor to the mark to the kill buffer.

       copy-prev-word (ESC-^_) (unbound) (unbound)
	      Duplicate the word to the left of the cursor.

       copy-prev-shell-word (ESC-^_) (unbound) (unbound)
	      Like  copy-prev-word, but the word is found by using shell pars‐
	      ing, whereas copy-prev-word looks for blanks. This makes a  dif‐
	      ference when the word is quoted and contains spaces.

       vi-delete (unbound) (d) (unbound)
	      Read  a  movement	 command  from the keyboard, and kill from the
	      cursor position to the endpoint of the movement.	If the command
	      is vi-delete, kill the current line.

       delete-char
	      Delete the character under the cursor.

       vi-delete-char (unbound) (x) (unbound)
	      Delete  the  character  under the cursor, without going past the
	      end of the line.

       delete-word
	      Delete the current word.

       down-case-word (ESC-L ESC-l) (unbound) (unbound)
	      Convert the current word to all lowercase and move past it.

       kill-word (ESC-D ESC-d) (unbound) (unbound)
	      Kill the current word.

       gosmacs-transpose-chars
	      Exchange the two characters behind the cursor.

       vi-indent (unbound) (>) (unbound)
	      Indent a number of lines.

       vi-insert (unbound) (i) (unbound)
	      Enter insert mode.

       vi-insert-bol (unbound) (I) (unbound)
	      Move to the first non-blank character  on	 the  line  and	 enter
	      insert mode.

       vi-join (^X^J) (J) (unbound)
	      Join the current line with the next one.

       kill-line (^K) (unbound) (unbound)
	      Kill  from the cursor to the end of the line.  If already on the
	      end of the line, kill the newline character.

       vi-kill-line (unbound) (unbound) (^U)
	      Kill from the cursor back	 to  wherever  insert  mode  was  last
	      entered.

       vi-kill-eol (unbound) (D) (unbound)
	      Kill from the cursor to the end of the line.

       kill-region
	      Kill from the cursor to the mark.

       kill-buffer (^X^K) (unbound) (unbound)
	      Kill the entire buffer.

       kill-whole-line (^U) (unbound) (unbound)
	      Kill the current line.

       vi-match-bracket (^X^B) (%) (unbound)
	      Move to the bracket character (one of {}, () or []) that matches
	      the one under the cursor.	 If the cursor is  not	on  a  bracket
	      character,  move	forward without going past the end of the line
	      to find one, and then go to the matching bracket.

       vi-open-line-above (unbound) (O) (unbound)
	      Open a line above the cursor and enter insert mode.

       vi-open-line-below (unbound) (o) (unbound)
	      Open a line below the cursor and enter insert mode.

       vi-oper-swap-case
	      Read a movement command from the keyboard, and swap the case  of
	      all  characters  from the cursor position to the endpoint of the
	      movement.	 If the movement command  is  vi-oper-swap-case,  swap
	      the case of all characters on the current line.

       overwrite-mode (^X^O) (unbound) (unbound)
	      Toggle between overwrite mode and insert mode.

       vi-put-before (unbound) (P) (unbound)
	      Insert  the  contents  of the kill buffer before the cursor.  If
	      the kill buffer contains a sequence  of  lines  (as  opposed  to
	      characters), paste it above the current line.

       vi-put-after (unbound) (p) (unbound)
	      Insert the contents of the kill buffer after the cursor.	If the
	      kill buffer contains a sequence of lines (as opposed to  charac‐
	      ters), paste it below the current line.

       quoted-insert (^V) (unbound) (unbound)
	      Insert  the  next character typed into the buffer literally.  An
	      interrupt character will not be inserted.

       vi-quoted-insert (unbound) (unbound) (^Q ^V)
	      Display a `^' at the cursor position, and insert the next	 char‐
	      acter  typed  into the buffer literally.	An interrupt character
	      will not be inserted.

       quote-line (ESC-') (unbound) (unbound)
	      Quote the current line; that is, put  a  `''  character  at  the
	      beginning and the end, and convert all `'' characters to `'\'''.

       quote-region (ESC-") (unbound) (unbound)
	      Quote the region from the cursor to the mark.

       vi-replace (unbound) (R) (unbound)
	      Enter overwrite mode.

       vi-repeat-change (unbound) (.) (unbound)
	      Repeat  the last vi mode text modification.  If a count was used
	      with the modification, it is remembered.	If a count is given to
	      this  command,  it overrides the remembered count, and is remem‐
	      bered for future uses of this command.  The cut buffer  specifi‐
	      cation is similarly remembered.

       vi-replace-chars (unbound) (r) (unbound)
	      Replace  the  character  under  the cursor with a character read
	      from the keyboard.

       self-insert (printable characters) (unbound) (printable characters  and
       some control characters)
	      Insert a character into the buffer at the cursor position.

       self-insert-unmeta (ESC-^I ESC-^J ESC-^M) (unbound) (unbound)
	      Insert  a character into the buffer after stripping the meta bit
	      and converting ^M to ^J.

       vi-substitute (unbound) (s) (unbound)
	      Substitute the next character(s).

       vi-swap-case (unbound) (~) (unbound)
	      Swap the case of the character under the cursor  and  move  past
	      it.

       transpose-chars (^T) (unbound) (unbound)
	      Exchange	the two characters to the left of the cursor if at end
	      of line, else exchange the character under the cursor  with  the
	      character to the left.

       transpose-words (ESC-T ESC-t) (unbound) (unbound)
	      Exchange the current word with the one before it.

       vi-unindent (unbound) (<) (unbound)
	      Unindent a number of lines.

       up-case-word (ESC-U ESC-u) (unbound) (unbound)
	      Convert the current word to all caps and move past it.

       yank (^Y) (unbound) (unbound)
	      Insert the contents of the kill buffer at the cursor position.

       yank-pop (ESC-y) (unbound) (unbound)
	      Remove  the text just yanked, rotate the kill-ring, and yank the
	      new top.	Only works following yank or yank-pop.

       vi-yank (unbound) (y) (unbound)
	      Read a movement command from the keyboard, and copy  the	region
	      from  the	 cursor	 position to the endpoint of the movement into
	      the kill buffer.	If the command is vi-yank,  copy  the  current
	      line.

       vi-yank-whole-line (unbound) (Y) (unbound)
	      Copy the current line into the kill buffer.

       vi-yank-eol
	      Copy  the region from the cursor position to the end of the line
	      into the kill buffer.  Arguably, this is what Y should do in vi,
	      but it isn't what it actually does.

   Arguments
       digit-argument (ESC-0..ESC-9) (1-9) (unbound)
	      Start  a	new  numeric argument, or add to the current one.  See
	      also vi-digit-or-beginning-of-line.  This only works if bound to
	      a key sequence ending in a decimal digit.

	      Inside  a	 widget	 function,  a call to this function treats the
	      last key of the key sequence which  called  the  widget  as  the
	      digit.

       neg-argument (ESC--) (unbound) (unbound)
	      Changes the sign of the following argument.

       universal-argument
	      Multiply	the argument of the next command by 4.	Alternatively,
	      if this command is followed by an	 integer  (positive  or	 nega‐
	      tive), use that as the argument for the next command.  Thus dig‐
	      its cannot be repeated using this command.  For example, if this
	      command occurs twice, followed immediately by forward-char, move
	      forward sixteen spaces; if instead it is followed	 by  -2,  then
	      forward-char, move backward two spaces.

	      Inside  a widget function, if passed an argument, i.e. `zle uni‐
	      versal-argument num', the numerical argument will be set to num;
	      this is equivalent to `NUMERIC=num'.

   Completion
       accept-and-menu-complete
	      In  a  menu  completion,	insert the current completion into the
	      buffer, and advance to the next possible completion.

       complete-word
	      Attempt completion on the current word.

       delete-char-or-list (^D) (unbound) (unbound)
	      Delete the character under the cursor.  If the cursor is at  the
	      end of the line, list possible completions for the current word.

       expand-cmd-path
	      Expand the current command to its full pathname.

       expand-or-complete (TAB) (unbound) (TAB)
	      Attempt  shell  expansion	 on  the current word.	If that fails,
	      attempt completion.

       expand-or-complete-prefix
	      Attempt shell expansion on the current word up to cursor.

       expand-history (ESC-space ESC-!) (unbound) (unbound)
	      Perform history expansion on the edit buffer.

       expand-word (^X*) (unbound) (unbound)
	      Attempt shell expansion on the current word.

       list-choices (ESC-^D) (^D =) (^D)
	      List possible completions for the current word.

       list-expand (^Xg ^XG) (^G) (^G)
	      List the expansion of the current word.

       magic-space
	      Perform history expansion and insert a space  into  the  buffer.
	      This is intended to be bound to space.

       menu-complete
	      Like  complete-word,  except  that menu completion is used.  See
	      the MENU_COMPLETE option.

       menu-expand-or-complete
	      Like expand-or-complete, except that menu completion is used.

       reverse-menu-complete
	      Perform menu completion, like menu-complete, except  that	 if  a
	      menu  completion	is  already  in progress, move to the previous
	      completion rather than the next.

       end-of-list
	      When a previous completion displayed a list  below  the  prompt,
	      this widget can be used to move the prompt below the list.

   Miscellaneous
       accept-and-hold (ESC-A ESC-a) (unbound) (unbound)
	      Push  the contents of the buffer on the buffer stack and execute
	      it.

       accept-and-infer-next-history
	      Execute the contents of the buffer.   Then  search  the  history
	      list for a line matching the current one and push the event fol‐
	      lowing onto the buffer stack.

       accept-line (^J ^M) (^J ^M) (^J ^M)
	      Finish editing the buffer.  Normally this causes the  buffer  to
	      be executed as a shell command.

       accept-line-and-down-history (^O) (unbound) (unbound)
	      Execute the current line, and push the next history event on the
	      the buffer stack.

       beep   Beep, unless the BEEP option is unset.

       vi-cmd-mode (^X^V) (unbound) (^[)
	      Enter command mode; that is, select the  `vicmd'	keymap.	  Yes,
	      this is bound by default in emacs mode.

       vi-caps-lock-panic
	      Hang  until  any lowercase key is pressed.  This is for vi users
	      without the mental capacity to keep track of their caps lock key
	      (like the author).

       clear-screen (^L ESC-^L) (^L) (^L)
	      Clear the screen and redraw the prompt.

       describe-key-briefly
	      Reads  a	key  sequence,	then prints the function bound to that
	      sequence.

       exchange-point-and-mark (^X^X) (unbound) (unbound)
	      Exchange the cursor position with the position of the mark.

       execute-named-cmd (ESC-x) (unbound) (unbound)
	      Read the name of an editor command and execute it.  A restricted
	      set  of  editing	functions is available in the mini-buffer.  An
	      interrupt signal, as defined by the stty setting, will abort the
	      function.	  The  allowed	functions  are:	 backward-delete-char,
	      vi-backward-delete-char, clear-screen, redisplay, quoted-insert,
	      vi-quoted-insert,	  backward-kill-word,	vi-backward-kill-word,
	      kill-whole-line, vi-kill-line, backward-kill-line, list-choices,
	      delete-char-or-list,  complete-word, accept-line, expand-or-com‐
	      plete and expand-or-complete-prefix.

	      kill-region kills the last word, and vi-cmd-mode is treated  the
	      same as accept-line.  The space and tab characters, if not bound
	      to one of these functions, will complete the name and then  list
	      the  possibilities  if  the  AUTO_LIST option is set.  Any other
	      character that is not bound to self-insert or self-insert-unmeta
	      will  beep  and  be ignored.  The bindings of the current insert
	      mode will be used.

       execute-last-named-cmd (ESC-z) (unbound) (unbound)
	      Redo the last function executed with execute-named-cmd.

       get-line (ESC-G ESC-g) (unbound) (unbound)
	      Pop the top line off the buffer stack and insert it at the  cur‐
	      sor position.

       pound-insert (unbound) (#) (unbound)
	      If  there	 is no # character at the beginning of the buffer, add
	      one to the beginning of each line.  If there is one, remove a  #
	      from each line that has one.  In either case, accept the current
	      line.  The INTERACTIVE_COMMENTS option must be set for  this  to
	      have any usefulness.

       vi-pound-insert
	      If there is no # character at the beginning of the current line,
	      add one.	If there is one, remove it.  The  INTERACTIVE_COMMENTS
	      option must be set for this to have any usefulness.

       push-input
	      Push  the	 entire	 current  multiline  construct onto the buffer
	      stack and return to the top-level (PS1) prompt.  If the  current
	      parser  construct	 is  only  a single line, this is exactly like
	      push-line.  Next time the editor starts up  or  is  popped  with
	      get-line, the construct will be popped off the top of the buffer
	      stack and loaded into the editing buffer.

       push-line (^Q ESC-Q ESC-q) (unbound) (unbound)
	      Push the current buffer onto the buffer stack and clear the buf‐
	      fer.   Next time the editor starts up, the buffer will be popped
	      off the top of the buffer stack and loaded into the editing buf‐
	      fer.

       push-line-or-edit
	      At  the  top-level  (PS1) prompt, equivalent to push-line.  At a
	      secondary (PS2) prompt, move the entire current  multiline  con‐
	      struct  into  the	 editor	 buffer.   The latter is equivalent to
	      push-input followed by get-line.

       redisplay (unbound) (^R) (^R)
	      Redisplays the edit buffer.

       send-break (^G ESC-^G) (unbound) (unbound)
	      Abort the current editor function,  e.g.	execute-named-command,
	      or  the editor itself, e.g. if you are in vared. Otherwise abort
	      the parsing of the current line.

       run-help (ESC-H ESC-h) (unbound) (unbound)
	      Push the buffer onto the buffer stack, and execute  the  command
	      `run-help	 cmd',	where cmd is the current command.  run-help is
	      normally aliased to man.

       vi-set-buffer (unbound) (") (unbound)
	      Specify a buffer to be used in the following command.  There are
	      35  buffers  that can be specified: the 26 `named' buffers "a to
	      "z and the nine `queued' buffers "1 to "9.   The	named  buffers
	      can also be specified as "A to "Z.

	      When a buffer is specified for a cut command, the text being cut
	      replaces the previous contents of the specified  buffer.	 If  a
	      named buffer is specified using a capital, the newly cut text is
	      appended to the buffer instead of overwriting it.

	      If no buffer is specified for a cut command, "1 is used, and the
	      contents of "1 to "8 are each shifted along one buffer; the con‐
	      tents of "9 is lost.

       vi-set-mark (unbound) (m) (unbound)
	      Set the specified mark at the cursor position.

       set-mark-command (^@) (unbound) (unbound)
	      Set the mark at the cursor position.

       spell-word (ESC-$ ESC-S ESC-s) (unbound) (unbound)
	      Attempt spelling correction on the current word.

       undefined-key
	      This command is executed when a key sequence that is  not	 bound
	      to any command is typed.	By default it beeps.

       undo (^_ ^Xu ^X^U) (unbound) (unbound)
	      Incrementally undo the last text modification.

       redo   Incrementally redo undone text modifications.

       vi-undo-change (unbound) (u) (unbound)
	      Undo  the last text modification.	 If repeated, redo the modifi‐
	      cation.

       what-cursor-position (^X=) (unbound) (unbound)
	      Print the character under the cursor, its code as an octal, dec‐
	      imal  and hexadecimal number, the current cursor position within
	      the buffer and the column of the cursor in the current line.

       where-is
	      Read the name of an editor command and and print the listing  of
	      key sequences that invoke the specified command.

       which-command (ESC-?) (unbound) (unbound)
	      Push  the	 buffer onto the buffer stack, and execute the command
	      `which-command  cmd'.  where  cmd	 is   the   current   command.
	      which-command is normally aliased to whence.

       vi-digit-or-beginning-of-line (unbound) (0) (unbound)
	      If the last command executed was a digit as part of an argument,
	      continue the argument.  Otherwise, execute vi-beginning-of-line.

zsh 4.0.4		       October 26, 2001			     ZSHZLE(1)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server UnixWare

List of man pages available for UnixWare

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net