ncurses man page on SmartOS

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

ncurses(3X)							   ncurses(3X)

       ncurses - CRT screen handling and optimization package

       #include <curses.h>

       The  ncurses  library  routines	give  the  user a terminal-independent
       method of updating  character  screens  with  reasonable	 optimization.
       This  implementation  is	 ``new	curses'' (ncurses) and is the approved
       replacement for 4.4BSD classic curses,  which  has  been	 discontinued.
       This describes ncurses version 5.9 (patch 20110404).

       The  ncurses  library emulates the curses library of System V Release 4
       UNIX, and XPG4 (X/Open Portability Guide) curses	 (also	known  as  XSI
       curses).	  XSI  stands  for  X/Open  System  Interfaces Extension.  The
       ncurses library is freely redistributable in source form.   Differences
       from  the SVr4 curses are summarized under the EXTENSIONS and PORTABIL‐
       ITY sections below and described in detail  in  the  respective	EXTEN‐
       SIONS, PORTABILITY and BUGS sections of individual man pages.

       The  ncurses  library  also provides many useful extensions, i.e., fea‐
       tures which cannot be implemented by a simple add-on library but	 which
       require access to the internals of the library.

       A  program  using  these	 routines  must	 be  linked with the -lncurses
       option, or (if it  has  been  generated)	 with  the  debugging  library
       -lncurses_g.   (Your  system  integrator	 may also have installed these
       libraries under the names  -lcurses  and	 -lcurses_g.)	The  ncurses_g
       library	generates  trace logs (in a file called 'trace' in the current
       directory) that describe curses	actions.   See	also  the  section  on

       The  ncurses package supports: overall screen, window and pad manipula‐
       tion; output to windows and pads; reading terminal input; control  over
       terminal	 and  curses  input and output options; environment query rou‐
       tines; color manipulation; use of soft label keys;  terminfo  capabili‐
       ties; and access to low-level terminal-manipulation routines.

       The  library uses the locale which the calling program has initialized.
       That is normally done with setlocale:

	     setlocale(LC_ALL, "");

       If the locale is not initialized, the library assumes  that  characters
       are  printable  as in ISO-8859-1, to work with certain legacy programs.
       You should initialize the locale and not rely on	 specific  details  of
       the library when the locale has not been setup.

       The  function  initscr  or  newterm  must  be  called to initialize the
       library before any of the other routines that  deal  with  windows  and
       screens are used.  The routine endwin must be called before exiting.

       To  get	character-at-a-time  input  without echoing (most interactive,
       screen oriented programs want this), the following sequence  should  be

	     initscr(); cbreak(); noecho();

       Most programs would additionally use the sequence:

	     intrflush(stdscr, FALSE);
	     keypad(stdscr, TRUE);

       Before a curses program is run, the tab stops of the terminal should be
       set and its initialization strings, if defined, must be	output.	  This
       can be done by executing the tput init command after the shell environ‐
       ment variable TERM has been exported.  tset(1) is  usually  responsible
       for doing this.	[See terminfo(5) for further details.]

       The  ncurses  library  permits  manipulation of data structures, called
       windows, which can be thought of as two-dimensional arrays  of  charac‐
       ters representing all or part of a CRT screen.  A default window called
       stdscr, which is the size of the terminal screen, is supplied.	Others
       may be created with newwin.

       Note  that  curses  does not handle overlapping windows, that's done by
       the panel(3X) library.  This means that you can either  use  stdscr  or
       divide the screen into tiled windows and not using stdscr at all.  Mix‐
       ing the two will result in unpredictable, and undesired, effects.

       Windows are referred to by variables declared as WINDOW *.  These  data
       structures  are	manipulated with routines described here and elsewhere
       in the ncurses manual pages.  Among those, the most basic routines  are
       move  and  addch.  More general versions of these routines are included
       with names beginning with w, allowing the user  to  specify  a  window.
       The routines not beginning with w affect stdscr.

       After using routines to manipulate a window, refresh is called, telling
       curses to make the user's CRT screen look like stdscr.  The  characters
       in a window are actually of type chtype, (character and attribute data)
       so that other information about the character may also be  stored  with
       each character.

       Special windows called pads may also be manipulated.  These are windows
       which are not constrained to the size of the screen and whose  contents
       need  not  be completely displayed.  See curs_pad(3X) for more informa‐

       In addition to drawing characters on the screen, video  attributes  and
       colors  may  be	supported,  causing  the characters to show up in such
       modes as underlined, in reverse video, or in color  on  terminals  that
       support	such  display  enhancements.   Line  drawing characters may be
       specified to be output.	On input, curses is  also  able	 to  translate
       arrow and function keys that transmit escape sequences into single val‐
       ues.  The video attributes, line drawing characters, and	 input	values
       use  names,  defined  in	 <curses.h>, such as A_REVERSE, ACS_HLINE, and

       If the environment variables LINES and COLUMNS are set, or if the  pro‐
       gram  is executing in a window environment, line and column information
       in the environment will override information read  by  terminfo.	  This
       would affect a program running in an AT&T 630 layer, for example, where
       the size of a screen is changeable (see ENVIRONMENT).

       If the environment variable TERMINFO  is	 defined,  any	program	 using
       curses  checks  for  a local terminal definition before checking in the
       standard place.	For example, if TERM is set to att4424, then the  com‐
       piled terminal definition is found in


       (The  a is copied from the first letter of att4424 to avoid creation of
       huge directories.)  However,  if	 TERMINFO  is  set  to	$HOME/myterms,
       curses first checks


       and if that fails, it then checks


       This  is	 useful	 for developing experimental definitions or when write
       permission in /opt/local/share/lib/terminfo is not available.

       The integer variables LINES and COLS are defined in <curses.h> and will
       be  filled  in  by  initscr with the size of the screen.	 The constants
       TRUE and FALSE have the values 1 and 0, respectively.

       The curses routines also define the WINDOW * variable curscr  which  is
       used  for  certain  low-level  operations like clearing and redrawing a
       screen containing garbage.  The curscr can be used in only a  few  rou‐

   Routine and Argument Names
       Many  curses routines have two or more versions.	 The routines prefixed
       with w require a window argument.  The routines prefixed with p require
       a pad argument.	Those without a prefix generally use stdscr.

       The  routines  prefixed with mv require a y and x coordinate to move to
       before performing the appropriate action.  The mv routines imply a call
       to  move before the call to the other routine.  The coordinate y always
       refers to the row (of the window), and x always refers to  the  column.
       The upper left-hand corner is always (0,0), not (1,1).

       The  routines prefixed with mvw take both a window argument and x and y
       coordinates.  The window argument is always specified before the	 coor‐

       In  each case, win is the window affected, and pad is the pad affected;
       win and pad are always pointers to type WINDOW.

       Option setting routines require a Boolean flag bf with the  value  TRUE
       or  FALSE;  bf  is always of type bool.	Most of the data types used in
       the library routines, such as WINDOW,  SCREEN,  bool,  and  chtype  are
       defined	in  <curses.h>.	  Types used for the terminfo routines such as
       TERMINAL are defined in <term.h>.

       This manual page describes functions which may appear in any configura‐
       tion  of	 the  library.	 There	are  two  common configurations of the

		   the "normal" library, which handles 8-bit characters.   The
		   normal  (8-bit)  library  stores  characters	 combined with
		   attributes in chtype data.

		   Attributes alone (no corresponding character) may be stored
		   in  chtype  or the equivalent attr_t data.  In either case,
		   the data is stored in something like an integer.

		   Each cell (row and column) in  a  WINDOW  is	 stored	 as  a

		   the so-called "wide" library, which handles multibyte char‐
		   acters (see the section on ALTERNATE CONFIGURATIONS).   The
		   "wide"  library includes all of the calls from the "normal"
		   library.  It adds about one third  more  calls  using  data
		   types which store multibyte characters:

			corresponds  to	 chtype.   However  it is a structure,
			because more data is stored than can fit into an inte‐
			ger.   The  characters	are  large enough to require a
			full integer value - and there may be  more  than  one
			character  per	cell.	The video attributes and color
			are stored in separate fields of the structure.

			Each cell (row and column) in a WINDOW is stored as  a

			stores	a  "wide" character.  Like chtype, this may be
			an integer.

			stores a wchar_t or WEOF - not the same,  though  both
			may have the same size.

		   The	"wide" library provides new functions which are analo‐
		   gous to functions in the "normal" library.  There is a nam‐
		   ing	convention which relates many of the normal/wide vari‐
		   ants: a "_w" is inserted into the name.  For example,  wad‐
		   dch becomes wadd_wch.

   Routine Name Index
       The  following table lists each curses routine and the name of the man‐
       ual page on which it is	described.   Routines  flagged	with  `*'  are
       ncurses-specific, not described by XPG4 or present in SVr4.

       Routines	 that return an integer return ERR upon failure and an integer
       value other than ERR upon successful completion, unless otherwise noted
       in the routine descriptions.

       All  macros  return  the	 value	of  the	 w  version, except setscrreg,
       wsetscrreg, getyx,  getbegyx,  and  getmaxyx.   The  return  values  of
       setscrreg,  wsetscrreg,	getyx,	getbegyx,  and	getmaxyx are undefined
       (i.e., these should not be used as the right-hand  side	of  assignment

       Routines that return pointers return NULL on error.

       The  following  environment symbols are useful for customizing the run‐
       time behavior of the ncurses library.  The  most	 important  ones  have
       been already discussed in detail.

	    The	 debugging  library  checks  this  environment symbol when the
	    application has redirected output to a file.  The symbol's numeric
	    value  is  used  for  the baudrate.	 If no value is found, ncurses
	    uses 9600.	This allows testers to construct repeatable test-cases
	    that take into account costs that depend on baudrate.

       CC   When  set,	change occurrences of the command_character (i.e., the
	    cmdch capability) of the loaded terminfo entries to the  value  of
	    this symbol.  Very few terminfo entries provide this feature.

	    Because this name is also used in development environments to rep‐
	    resent the C compiler's name, ncurses ignores it if	 it  does  not
	    happen to be a single character.

	    Specify  the width of the screen in characters.  Applications run‐
	    ning in a windowing environment usually are	 able  to  obtain  the
	    width  of  the window in which they are executing.	If neither the
	    COLUMNS value nor the terminal's screen size is available, ncurses
	    uses  the  size  which  may	 be specified in the terminfo database
	    (i.e., the cols capability).

	    It is important that your application use a correct size  for  the
	    screen.   This is not always possible because your application may
	    be running on a host which does not honor NAWS (Negotiations About
	    Window  Size),  or	because you are temporarily running as another
	    user.   However,  setting  COLUMNS	and/or	LINES  overrides   the
	    library's  use of the screen size obtained from the operating sys‐

	    Either COLUMNS or LINES symbols may	 be  specified	independently.
	    This is mainly useful to circumvent legacy misfeatures of terminal
	    descriptions, e.g., xterm  which  commonly	specifies  a  65  line
	    screen.   For best results, lines and cols should not be specified
	    in a terminal description for terminals which are  run  as	emula‐

	    Use	 the  use_env function to disable all use of external environ‐
	    ment (including system calls) to determine the screen size.

	    Specifies the total time, in milliseconds, for which ncurses  will
	    await  a  character	 sequence,  e.g., a function key.  The default
	    value, 1000 milliseconds, is enough for most uses.	However, it is
	    made a variable to accommodate unusual applications.

	    The	 most  common instance where you may wish to change this value
	    is to work with slow hosts, e.g., running on a  network.   If  the
	    host  cannot read characters rapidly enough, it will have the same
	    effect as if the terminal did not send characters rapidly  enough.
	    The library will still see a timeout.

	    Note that xterm mouse events are built up from character sequences
	    received from the xterm.  If your application makes heavy  use  of
	    multiple-clicking,	you  may  wish	to lengthen this default value
	    because the timeout applies to the composed multi-click  event  as
	    well as the individual clicks.

	    In	addition to the environment variable, this implementation pro‐
	    vides a global variable with the same name.	 Portable applications
	    should  not rely upon the presence of ESCDELAY in either form, but
	    setting the environment variable rather than the  global  variable
	    does not create problems when compiling an application.

       HOME Tells  ncurses where your home directory is.  That is where it may
	    read and write auxiliary terminal descriptions:


	    Like COLUMNS, specify the height of the screen in characters.  See
	    COLUMNS for a detailed description.

	    This applies only to the OS/2 EMX port.  It specifies the order of
	    buttons on the mouse.  OS/2 numbers	 a  3-button  mouse  inconsis‐
	    tently from other platforms:

	    1 = left
	    2 = right
	    3 = middle.

	    This  symbol  lets	you  customize	the mouse.  The symbol must be
	    three numeric digits 1-3 in any order, e.g., 123 or 321.  If it is
	    not specified, ncurses uses 132.

	    Override  the  compiled-in	assumption that the terminal's default
	    colors are white-on-black (see default_colors(3X)).	 You  may  set
	    the	 foreground  and background color values with this environment
	    variable by proving a 2-element list: foreground,background.   For
	    example,  to tell ncurses to not assume anything about the colors,
	    set this to "-1,-1".  To make it green-on-black, set it to	"2,0".
	    Any	 positive  value from zero to the terminfo max_colors value is

	    This applies only to ncurses configured to use the GPM interface.

	    If present, the environment variable is a list of one or more ter‐
	    minal  names  against  which  the  TERM  environment  variable  is
	    matched.  Setting it to an empty value disables the GPM interface;
	    using the built-in support for xterm, etc.

	    If	the  environment  variable  is absent, ncurses will attempt to
	    open GPM if TERM contains "linux".

	    Ncurses may use tabs as part of the cursor movement	 optimization.
	    In some cases, your terminal driver may not handle these properly.
	    Set this environment variable to disable  the  feature.   You  can
	    also adjust your stty settings to avoid the problem.

	    Some  terminals  use a magic-cookie feature which requires special
	    handling to make highlighting and other video  attributes  display
	    properly.	You  can  suppress the highlighting entirely for these
	    terminals by setting this environment variable.

	    Most of the terminal descriptions in  the  terminfo	 database  are
	    written  for  real "hardware" terminals.  Many people use terminal
	    emulators which run in a windowing	environment  and  use  curses-
	    based  applications.   Terminal emulators can duplicate all of the
	    important aspects of a hardware terminal, but they do not have the
	    same  limitations.	 The  chief  limitation of a hardware terminal
	    from the standpoint of  your  application  is  the	management  of
	    dataflow,  i.e., timing.  Unless a hardware terminal is interfaced
	    into a terminal concentrator (which does  flow  control),  it  (or
	    your  application) must manage dataflow, preventing overruns.  The
	    cheapest solution (no hardware cost) is for	 your  program	to  do
	    this  by  pausing  after operations that the terminal does slowly,
	    such as clearing the display.

	    As a result, many terminal descriptions (including the vt100) have
	    delay times embedded.  You may wish to use these descriptions, but
	    not want to pay the performance penalty.

	    Set the NCURSES_NO_PADDING symbol to  disable  all	but  mandatory
	    padding.   Mandatory  padding is used as a part of special control
	    sequences such as flash.

	    Normally ncurses enables buffered output during terminal  initial‐
	    ization.   This  is	 done (as in SVr4 curses) for performance rea‐
	    sons.  For testing purposes, both of ncurses and certain  applica‐
	    tions, this feature is made optional.  Setting the NCURSES_NO_SET‐
	    BUF variable disables output buffering, leaving the output in  the
	    original (usually line buffered) mode.

	    During  initialization,  the  ncurses  library  checks for special
	    cases where VT100 line-drawing (and	 the  corresponding  alternate
	    character set capabilities) described in the terminfo are known to
	    be missing.	 Specifically, when running in	a  UTF-8  locale,  the
	    Linux  console  emulator  and the GNU screen program ignore these.
	    Ncurses checks the TERM environment variable for these.  For other
	    special  cases,  you  should set this environment variable.	 Doing
	    this tells ncurses to use Unicode values which correspond  to  the
	    VT100  line-drawing	 glyphs.   That	 works	for  the special cases
	    cited, and is likely to work for terminal emulators.

	    When setting this variable, you should set it to a nonzero	value.
	    Setting  it to zero (or to a nonnumber) disables the special check
	    for "linux" and "screen".

	    As an alternative to the environment variable, ncurses checks  for
	    an	extended terminfo capability U8.  This is a numeric capability
	    which can be compiled using tic -x.	 For example

	    # linux console, if patched to provide working
	    # VT100 shift-in/shift-out, with corresponding font.
	    linux-vt100|linux console with VT100 line-graphics,
		 U8#0, use=linux,

	    # uxterm with vt100Graphics resource set to false
	    xterm-utf8|xterm relying on UTF-8 line-graphics,
		 U8#1, use=xterm,

	    The name "U8" is chosen to be two characters, to permit it	to  be
	    used by applications that use ncurses' termcap interface.

	    During  initialization,  the  ncurses debugging library checks the
	    NCURSES_TRACE symbol.  If it  is  defined,	to  a  numeric	value,
	    ncurses  calls  the	 trace function, using that value as the argu‐

	    The argument values, which are defined in curses.h,	 provide  sev‐
	    eral types of information.	When running with traces enabled, your
	    application will write the file trace to the current directory.

       TERM Denotes your terminal  type.   Each	 terminal  type	 is  distinct,
	    though many are similar.

	    If	the  ncurses library has been configured with termcap support,
	    ncurses will check for a terminal's description in termcap form if
	    it is not available in the terminfo database.

	    The	 TERMCAP  symbol  contains either a terminal description (with
	    newlines stripped out), or a file name telling where the  informa‐
	    tion  denoted  by the TERM symbol exists.  In either case, setting
	    it directs ncurses to ignore the usual place for this information,
	    e.g., /etc/termcap.

	    Overrides  the directory in which ncurses searches for your termi‐
	    nal description.  This is the simplest, but not the	 only  way  to
	    change  the list of directories.  The complete list of directories
	    in order follows:

	    ·	the last directory to which ncurses wrote, if any, is searched

	    ·	the directory specified by the TERMINFO symbol

	    ·	$HOME/.terminfo

	    ·	directories listed in the TERMINFO_DIRS symbol

	    ·	one  or	 more  directories whose names are configured and com‐
		piled	   into	     the      ncurses	   library,	 e.g.,

	    Specifies  a  list	of directories to search for terminal descrip‐
	    tions.  The list is separated by colons (i.e., ":") on Unix, semi‐
	    colons  on OS/2 EMX.  All of the terminal descriptions are in ter‐
	    minfo form, which makes a subdirectory named for the first	letter
	    of the terminal names therein.

	    If	TERMCAP	 does  not  hold  a  file name then ncurses checks the
	    TERMPATH symbol.  This is a list of filenames separated by	spaces
	    or	colons	(i.e.,	":")  on Unix, semicolons on OS/2 EMX.	If the
	    TERMPATH symbol is not set, ncurses looks in the files  /etc/term‐
	    cap, /usr/share/misc/termcap and $HOME/.termcap, in that order.

       The library may be configured to disregard the following variables when
       the current user is the superuser (root), or if	the  application  uses
       setuid  or setgid permissions: $TERMINFO, $TERMINFO_DIRS, $TERMPATH, as
       well as $HOME.

       Several different configurations are possible, depending on the config‐
       ure  script  options  used when building ncurses.  There are a few main
       options whose effects are visible to the applications  developer	 using

	    The standard include for ncurses is as noted in SYNOPSIS:

	    #include <curses.h>

	    This  option  is  used to avoid filename conflicts when ncurses is
	    not the main implementation of curses of the computer.  If ncurses
	    is	installed disabling overwrite, it puts its headers in a subdi‐
	    rectory, e.g.,

	    #include <ncurses/curses.h>

	    It also omits a  symbolic  link  which  would  allow  you  to  use
	    -lcurses to build executables.

	    The	 configure  script  renames  the  library  and	(if the --dis‐
	    able-overwrite option is used) puts the header files in a  differ‐
	    ent subdirectory.  All of the library names have a "w" appended to
	    them, i.e., instead of


	    you link with


	    You must also define _XOPEN_SOURCE_EXTENDED when compiling for the
	    wide-character  library to use the extended (wide-character) func‐
	    tions.  The curses.h file which is installed for the  wide-charac‐
	    ter library is designed to be compatible with the normal library's
	    header.  Only the size of the WINDOW structure differs,  and  very
	    few	 applications  require more than a pointer to WINDOWs.	If the
	    headers  are  installed  allowing  overwrite,  the	wide-character
	    library's  headers should be installed last, to allow applications
	    to be built using either library from the same set of headers.




	    The shared and normal (static) library names differ by their  suf‐
	    fixes,  e.g., and libncurses.a.  The debug and pro‐
	    filing libraries add a "_g" and a "_p" to the root	names  respec‐
	    tively, e.g., libncurses_g.a and libncurses_p.a.

	    The	 trace	function normally resides in the debug library, but it
	    is sometimes useful to configure this in the shared library.  Con‐
	    figure  scripts  should  check for the function's existence rather
	    than assuming it is always in the debug library.

	    directory containing initialization files for the  terminal	 capa‐
	    bility  database /opt/local/share/lib/terminfo terminal capability

       terminfo(5) and related pages whose names begin	"curs_"	 for  detailed
       routine descriptions.

       The  ncurses library can be compiled with an option (-DUSE_GETCAP) that
       falls back to the old-style /etc/termcap file  if  the  terminal	 setup
       code  cannot  find a terminfo entry corresponding to TERM.  Use of this
       feature is not recommended, as it essentially includes an entire	 term‐
       cap  compiler  in the ncurses startup code, at significant cost in core
       and startup cycles.

       The ncurses library includes facilities for capturing mouse  events  on
       certain	terminals  (including  xterm).	 See the curs_mouse(3X) manual
       page for details.

       The ncurses library includes facilities for responding to window resiz‐
       ing events, e.g., when running in an xterm.  See the resizeterm(3X) and
       wresize(3X) manual pages for details.  In addition, the library may  be
       configured with a SIGWINCH handler.

       The  ncurses library extends the fixed set of function key capabilities
       of terminals by allowing the application designer to define  additional
       key  sequences at runtime.  See the define_key(3X) key_defined(3X), and
       keyok(3X) manual pages for details.

       The ncurses library can exploit the  capabilities  of  terminals	 which
       implement  the  ISO-6429	 SGR  39  and  SGR 49 controls, which allow an
       application to reset the terminal to its original foreground and	 back‐
       ground colors.  From the users' perspective, the application is able to
       draw colored text on a background whose	color  is  set	independently,
       providing  better  control  over color contrasts.  See the default_col‐
       ors(3X) manual page for details.

       The ncurses library includes a function for directing application  out‐
       put   to	  a   printer  attached	 to  the  terminal  device.   See  the
       curs_print(3X) manual page for details.

       The ncurses library is intended to be BASE-level	 conformant  with  XSI
       Curses.	 The  EXTENDED	XSI Curses functionality (including color sup‐
       port) is supported.

       A small number of local differences (that  is,  individual  differences
       between	the XSI Curses and ncurses calls) are described in PORTABILITY
       sections of the library man pages.

       This implementation also contains several extensions:

       ·   The routine has_key is not part of XPG4, nor is it present in SVr4.
	   See the curs_getch(3X) manual page for details.

       ·   The	routine	 slk_attr  is  not  part of XPG4, nor is it present in
	   SVr4.  See the curs_slk(3X) manual page for details.

       ·   The routines getmouse, mousemask,  ungetmouse,  mouseinterval,  and
	   wenclose  relating  to  mouse interfacing are not part of XPG4, nor
	   are they present in SVr4.  See the curs_mouse(3X) manual  page  for

       ·   The	routine	 mcprint was not present in any previous curses imple‐
	   mentation.  See the curs_print(3X) manual page for details.

       ·   The routine wresize is not part of XPG4, nor is it present in SVr4.
	   See the wresize(3X) manual page for details.

       ·   The WINDOW structure's internal details can be hidden from applica‐
	   tion programs.  See curs_opaque(3X) for the discussion of is_scrol‐
	   lok, etc.

       ·   This	 implementation	 can be configured to provide rudimentary sup‐
	   port for multi-threaded  applications.   See	 curs_threads(3X)  for

       ·   This	 implementation	 can  also  be	configured to provide a set of
	   functions which improve the ability	to  manage  multiple  screens.
	   See curs_sp_funcs(3X) for details.

       In  historic  curses  versions, delays embedded in the capabilities cr,
       ind, cub1, ff and tab activated corresponding delay bits	 in  the  UNIX
       tty driver.  In this implementation, all padding is done by sending NUL
       bytes.  This method is slightly more expensive, but narrows the	inter‐
       face  to	 the  UNIX  kernel  significantly  and increases the package's
       portability correspondingly.

       The header file <curses.h>  automatically  includes  the	 header	 files
       <stdio.h> and <unctrl.h>.

       If  standard  output from a ncurses program is re-directed to something
       which is not a tty, screen updates will be directed to standard	error.
       This was an undocumented feature of AT&T System V Release 3 curses.

       Zeyd M. Ben-Halim, Eric S. Raymond, Thomas E. Dickey.  Based on pcurses
       by Pavel Curtis.


List of man pages available for SmartOS

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]
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