termcap - terminal capability data base




     Termcap is a data base describing terminals, used,  e.g.,  by  vi(1)  and
     curses(3).   Terminals  are  described  in  termcap  by  giving  a set of
     capabilities  that  they  have  and  by  describing  how  operations  are
     performed.    Padding   requirements  and  initialization  sequences  are
     included in termcap.

     Entries in termcap consist of a  number  of  `:'-separated  fields.   The
     first  entry  for  each  terminal  gives the names that are known for the
     terminal, separated by `|' characters.  The  first  name  is  always  two
     characters  long  and  is  used by older systems which store the terminal
     type in a 16-bit word in a system-wide data base.  The second name  given
     is  the  most  common  abbreviation for the terminal, the last name given
     should be a long name fully identifying the terminal, and all others  are
     understood  as  synonyms  for the terminal name.  All names but the first
     and last should be in lower case and contain no blanks; the last name may
     well contain upper case and blanks for readability.

     Terminal names (except for the last,  verbose  entry)  should  be  chosen
     using the following conventions.  The particular piece of hardware making
     up the terminal should have a root name chosen, thus "hp2621".  This name
     should  not  contain  hyphens.  Modes that the hardware can be in or user
     preferences should be indicated by appending a hyphen and an indicator of
     the  mode.   Therefore,  a "vt100" in 132-column mode would be "vt100-w".
     The following suffixes should be used where possible:

     Suffix      Meaning                                     Example
     -w          Wide mode (more than 80 columns)            vt100-w
     -am         With automatic margins (usually default)    vt100-am
     -nam        Without automatic margins                   vt100-nam
     -n          Number of lines on the screen               aaa-60
     -na         No arrow keys (leave them in local)         concept100-na
     -np         Number of pages of memory                   concept100-4p
     -rv         Reverse video                               concept100-rv


     The characters in the  Notes  field  in  the  table  have  the  following
     meanings (more than one may apply to a capability):

     N      indicates numeric parameter(s)
     P      indicates that padding may be specified
     *      indicates that padding  may  be  based  on  the  number  of  lines

     o      indicates capability is obsolete

     "Obsolete" capabilities have no terminfo  equivalents,  since  they  were
     considered  useless, or are subsumed by other capabilities.  New software
     should not rely on them at all.

     Name  Type  Notes  Description
     ae    str   (P)    End alternate character set
     AL    str   (NP*)  Add n new blank lines
     al    str   (P*)   Add new blank line
     am    bool         Terminal has automatic margins
     as    str   (P)    Start alternate character set
     bc    str   (o)    Backspace if not ^H
     bl    str   (P)    Audible signal (bell)
     bs    bool  (o)    Terminal can backspace with ^H
     bt    str   (P)    Back tab
     bw    bool         le (backspace) wraps from column 0 to last column
     CC    str          Terminal settable command character in prototype
     cd    str   (P*)   Clear to end of display
     ce    str   (P)    Clear to end of line
     ch    str   (NP)   Set cursor column (horizontal position)
     cl    str   (P*)   Clear screen and home cursor
     CM    str   (NP)   Memory-relative cursor addressing
     cm    str   (NP)   Screen-relative cursor motion
     co    num          Number of columns in a line (See BUGS section below)
     cr    str   (P)    Carriage return
     cs    str   (NP)   Change scrolling region (VT100)
     ct    str   (P)    Clear all tab stops
     cv    str   (NP)   Set cursor row (vertical position)
     da    bool         Display may be retained above the screen
     dB    num   (o)    Milliseconds of bs delay needed (default 0)
     db    bool         Display may be retained below the screen
     DC    str   (NP*)  Delete n characters
     dC    num   (o)    Milliseconds of cr delay needed (default 0)
     dc    str   (P*)   Delete character
     dF    num   (o)    Milliseconds of ff delay needed (default 0)
     DL    str   (NP*)  Delete n lines
     dl    str   (P*)   Delete line
     dm    str          Enter delete mode
     dN    num   (o)    Milliseconds of nl delay needed (default 0)
     DO    str   (NP*)  Move cursor down n lines
     do    str          Down one line
     ds    str          Disable status line
     dT    num   (o)    Milliseconds of horizontal tab delay  needed  (default
     dV    num   (o)    Milliseconds of vertical tab delay needed (default 0)
     ec    str   (NP)   Erase n characters
     ed    str          End delete mode
     ei    str          End insert mode
     eo    bool         Can erase overstrikes with a blank
     EP    bool  (o)    Even parity
     es    bool         Escape can be used on the status line
     ff    str   (P*)   Hardcopy terminal page eject
     fs    str          Return from status line
     gn    bool         Generic line type (e.g. dialup, switch)
     hc    bool         Hardcopy terminal
     HD    bool  (o)    Half-duplex
     hd    str          Half-line down (forward 1/2 linefeed)
     ho    str   (P)    Home cursor
     hs    bool         Has extra "status line"
     hu    str          Half-line up (reverse 1/2 linefeed)
     hz    bool         Cannot print ~s (Hazeltine)
     i1-i3 str          Terminal initialization strings (terminfo only)
     IC    str   (NP*)  Insert n blank characters
     ic    str   (P*)   Insert character
     if    str          Name of file containing initialization string
     im    str          Enter insert mode
     in    bool         Insert mode distinguishes nulls
     iP    str          Pathname of program for initialization (terminfo only)
     ip    str   (P*)   Insert pad after character inserted
     is    str          Terminal initialization string (termcap only)
     it    num          Tabs initially every n positions
     K1    str          Sent by keypad upper left
     K2    str          Sent by keypad upper right
     K3    str          Sent by keypad center
     K4    str          Sent by keypad lower left
     K5    str          Sent by keypad lower right
     k0-k9 str          Sent by function keys 0-9
     kA    str          Sent by insert-line key
     ka    str          Sent by clear-all-tabs key
     kb    str          Sent by backspace key
     kC    str          Sent by clear-screen or erase key
     kD    str          Sent by delete-character key
     kd    str          Sent by down-arrow key
     kE    str          Sent by clear-to-end-of-line key
     ke    str          Out of "keypad transmit" mode
     kF    str          Sent by scroll-forward/down key
     kH    str          Sent by home-down key
     kh    str          Sent by home key
     kI    str          Sent by insert-character or enter-insert-mode key
     kL    str          Sent by delete-line key
     kl    str          Sent by left-arrow key
     kM    str          Sent by insert key while in insert mode
     km    bool         Has a "meta" key (shift, sets parity bit)
     kN    str          Sent by next-page key
     kn    num   (o)    Number of function (k0-k9) keys (default 0)
     ko    str   (o)    Termcap entries for other non-function keys
     kP    str          Sent by previous-page key
     kR    str          Sent by scroll-backward/up key
     kr    str          Sent by right-arrow key
     kS    str          Sent by clear-to-end-of-screen key
     ks    str          Put terminal in "keypad transmit" mode
     kT    str          Sent by set-tab key
     kt    str          Sent by clear-tab key
     ku    str          Sent by up-arrow key
     l0-l9 str          Labels on function keys if not "fn"
     LC    bool  (o)    Lower-case only
     LE    str   (NP)   Move cursor left n positions
     le    str   (P)    Move cursor left one position
     li    num          Number of lines on screen or page  (See  BUGS  section
     ll    str          Last line, first column
     lm    num          Lines of memory if > li (0 means varies)
     ma    str   (o)    Arrow key map (used by vi version 2 only)
     mb    str          Turn on blinking attribute
     md    str          Turn on bold (extra bright) attribute
     me    str          Turn off all attributes
     mh    str          Turn on half-bright attribute
     mi    bool         Safe to move while in insert mode
     mk    str          Turn on blank attribute (characters invisible)
     ml    str   (o)    Memory lock on above cursor
     mm    str          Turn on "meta mode" (8th bit)
     mo    str          Turn off "meta mode"
     mp    str          Turn on protected attribute
     mr    str          Turn on reverse-video attibute
     ms    bool         Safe to move in standout modes
     mu    str   (o)    Memory unlock (turn off memory lock)
     nc    bool  (o)    No correctly-working  cr  (Datamedia  2500,  Hazeltine
     nd    str          Non-destructive space (cursor right)
     NL    bool  (o)    \n is newline, not line feed
     nl    str   (o)    Newline character if not \n
     ns    bool  (o)    Terminal is a CRT but doesn't scroll
     nw    str   (P)    Newline (behaves like cr followed by do)
     OP    bool  (o)    Odd parity
     os    bool         Terminal overstrikes
     pb    num          Lowest baud where delays are required
     pc    str          Pad character (default NUL)
     pf    str          Turn off the printer
     pk    str          Program function key n  to  type  string  s  (terminfo
     pl    str          Program function key n to execute string  s  (terminfo
     pO    str   (N)    Turn on the printer for n bytes
     po    str          Turn on the printer
     ps    str          Print contents of the screen
     pt    bool  (o)    Has hardware tabs (may need to be set with is)
     px    str          Program function key n to transmit string s  (terminfo
     r1-r3 str          Reset terminal  completely  to  sane  modes  (terminfo
     rc    str   (P)    Restore cursor to position of last sc
     rf    str          Name of file containing reset codes
     RI    str   (NP)   Move cursor right n positions
     rp    str   (NP*)  Repeat character c n times
     rs    str          Reset terminal completely to sane modes (termcap only)
     sa    str   (NP)   Define the video attributes
     sc    str   (P)    Save cursor position
     se    str          End standout mode
     SF    str   (NP*)  Scroll forward n lines
     sf    str   (P)    Scroll text up
     sg    num          Number of garbage chars left by so or se (default 0)
     so    str          Begin standout mode
     SR    str   (NP*)  Scroll backward n lines
     sr    str   (P)    Scroll text down
     st    str          Set a tab in all rows, current column
     ta    str   (P)    Tab to next 8-position hardware tab stop
     tc    str          Entry of similar terminal - must be last
     te    str          String to end programs that use termcap
     ti    str          String to begin programs that use termcap
     ts    str   (N)    Go to status line, column n
     UC    bool  (o)    Upper-case only
     uc    str          Underscore one character and move past it
     ue    str          End underscore mode
     ug    num          Number of garbage chars left by us or ue (default 0)
     ul    bool         Underline character overstrikes
     UP    str   (NP*)  Move cursor up n lines
     up    str          Upline (cursor up)
     us    str          Start underscore mode
     vb    str          Visible bell (must not move cursor)
     ve    str          Make cursor appear normal (undo vs/vi)
     vi    str          Make cursor invisible
     vs    str          Make cursor very visible
     vt    num          Virtual terminal number (not supported on all systems)
     wi    str   (N)    Set current window
     ws    num          Number of columns in status line
     xb    bool         Beehive (f1=ESC, f2=^C)
     xn    bool         Newline ignored after 80 cols (Concept)
     xo    bool         Terminal uses xoff/xon (DC3/DC1) handshaking
     xr    bool  (o)    Return acts like ce cr nl (Delta Data)
     xs    bool         Standout not erased by overwriting (Hewlett-Packard)
     xt    bool         Tabs ruin, magic so char (Teleray 1061)
     xx    bool  (o)    Tektronix 4025 insert-line

     A Sample Entry

     The following entry, which describes the Concept-100, is among  the  more
     complex entries in the termcap file as of this writing.

     ca|concept100|c100|concept|c104|concept100-4p|HDS Concept-100:\
       :al=3*\E^R:am:bl=^G:cd=16*\E^C:ce=16\E^U:cl=2*^L:cm=\Ea%+ %+ :\
       :mr=\ED:nd=\E=:pb#9600:rp=0.2*\Er%.%+ :se=\Ed\Ee:sf=^J:so=\EE\ED:\
       :.ta=8\t:te=\Ev    \200\200\200\200\200\200\Ep\r\n:\
       :ti=\EU\Ev  8p\Ep\r:ue=\Eg:ul:up=\E;:us=\EG:\

     Entries may continue onto multiple lines  by  giving  a  \  as  the  last
     character  of  a  line,  and empty fields may be included for readability
     (here between the last field on a line and the first field on the  next).
     Comments may be included on lines beginning with "#".

     Types of Capabilities

     Capabilities in termcap are of three types: Boolean  capabilities,  which
     indicate particular features that the terminal has; numeric capabilities,
     giving the size of the display or  the  size  of  other  attributes;  and
     string  capabilities,  which give character sequences that can be used to
     perform particular terminal operations.  All capabilities have two-letter
     codes.   For  instance,  the  fact that the Concept has automatic margins
     (i.e., an automatic return and  linefeed  when  the  end  of  a  line  is
     reached)   is   indicated  by  the  Boolean  capability  am.   Hence  the
     description of the Concept includes am.

     Numeric capabilities are followed by the character `#'  then  the  value.
     In  the  example  above  co,  which  indicates  the number of columns the
     display has, gives the value `80' for the Concept.

     Finally, string-valued capabilities,  such  as  ce  (clear-to-end-of-line
     sequence)  are given by the two-letter code, an `=', then a string ending
     at the next following `:'.  A delay in milliseconds may appear after  the
     `='  in such a capability, which causes padding characters to be supplied
     by tputs after the remainder of the string is sent to provide this delay.
     The  delay  can be either a number, e.g. `20', or a number followed by an
     `*',  i.e.,  `3*'.   An  `*'  indicates  that  the  padding  required  is
     proportional  to  the  number of lines affected by the operation, and the
     amount given is the per-affected-line padding required.  (In the case  of
     insert-character,  the factor is still the number of lines affected; this
     is always 1 unless the terminal has in and the software uses  it.)   When
     an  `*'  is specified, it is sometimes useful to give a delay of the form
     `3.5' to specify a delay per line to tenths of milliseconds.   (Only  one
     decimal place is allowed.)

     A  number  of  escape  sequences  are  provided  in   the   string-valued
     capabilities  for  easy encoding of control characters there.  \E maps to
     an ESC character, ^X maps to a control-X for any appropriate X,  and  the
     sequences  \n  \r  \t  \b \f map to linefeed, return, tab, backspace, and
     formfeed, respectively.  Finally, characters may be given as three  octal
     digits  after  a \, and the characters ^ and \ may be given as \^ and \\.
     If it is necessary to place a : in a capability it  must  be  escaped  in
     octal  as  \072.  If it is necessary to place a NUL character in a string
     capability it must be encoded as \200.   (The  routines  that  deal  with
     termcap use C strings and strip the high bits of the output very late, so
     that a \200 comes out as a \000 would.)

     Sometimes individual capabilities must be commented out.  To do this, put
     a  period  before the capability name.  For example, see the first cr and
     ta in the example above.

     Preparing Descriptions

     We now outline how  to  prepare  descriptions  of  terminals.   The  most
     effective  way  to  prepare  a  terminal  description is by imitating the
     description  of  a  similar  terminal  in  termcap  and  to  build  up  a
     description  gradually,  using partial descriptions with vi to check that
     they are correct.  Be aware that  a  very  unusual  terminal  may  expose
     deficiencies in the ability of the termcap file to describe it or bugs in
     vi.   To  easily  test  a  new  terminal  description  you  can  set  the
     environment   variable  TERMCAP  to  the  absolute  pathname  of  a  file
     containing the description you are working  on  and  programs  will  look
     there  rather  than  in  /etc/termcap.   TERMCAP  can  also be set to the
     termcap entry itself to  avoid  reading  the  file  when  starting  up  a

     To get the padding for insert-line right (if  the  terminal  manufacturer
     did  not  document it), a severe test is to use vi to edit /etc/passwd at
     9600 baud, delete roughly 16 lines from the middle of  the  screen,  then
     hit  the  `u'  key several times quickly.  If the display messes up, more
     padding is usually needed.  A  similar  test  can  be  used  for  insert-

     Basic Capabilities

     The number of columns on each line of the display  is  given  by  the  co
     numeric capability.  If the display is a CRT, then the number of lines on
     the screen is given by the li capability.  If the display wraps around to
     the  beginning of the next line when the cursor reaches the right margin,
     then it should have the am capability.  If the  terminal  can  clear  its
     screen, the code to do this is given by the cl string capability.  If the
     terminal overstrikes (rather than clearing the position when a  character
     is  overwritten), it should have the os capability.  If the terminal is a
     printing terminal, with no soft copy unit, give it both hc and  os.   (os
     applies to storage scope terminals, such as the Tektronix 4010 series, as
     well as to hard copy and APL terminals.)  If there is a code to move  the
     cursor  to  the left edge of the current row, give this as cr.  (Normally
     this will be carriage-return, ^M.)  If there is  a  code  to  produce  an
     audible signal (bell, beep, etc.), give this as bl.

     If there is a code (such as backspace) to move the cursor one position to
     the  left,  that  capability  should be given as le.  Similarly, codes to
     move to the right, up, and down should  be  given  as  nd,  up,  and  do,
     respectively.   These local cursor motions should not alter the text they
     pass over; for example, you would not  normally  use  "nd= "  unless  the
     terminal  has  the  os  capability,  because  the  space  would erase the
     character moved over.

     A very important point here is that the local cursor motions  encoded  in
     termcap  have  undefined  behavior  at  the  left  and top edges of a CRT
     display.  Programs should never attempt  to  backspace  around  the  left
     edge,  unless  bw  is given, and never attempt to go up off the top using
     local cursor motions.

     In order to scroll text up, a program goes to the bottom left  corner  of
     the  screen  and  sends  the  sf  (index) string.  To scroll text down, a
     program goes to the top left corner  of  the  screen  and  sends  the  sr
     (reverse  index)  string.   The strings sf and sr have undefined behavior
     when not on  their  respective  corners  of  the  screen.   Parameterized
     versions  of  the  scrolling sequences are SF and SR, which have the same
     semantics as sf and sr except that they take  one  parameter  and  scroll
     that  many  lines.   They  also  have  undefined  behavior  except at the
     appropriate corner of the screen.

     The am capability tells whether the cursor sticks at the  right  edge  of
     the screen when text is output there, but this does not necessarily apply
     to nd from the last column.  Leftward local motion is  defined  from  the
     left  edge only when bw is given; then an le from the left edge will move
     to the right edge of the previous row.  This is useful for drawing a  box
     around  the edge of the screen, for example.  If the terminal has switch-
     selectable automatic margins, the  termcap  description  usually  assumes
     that  this  feature  is on, i.e., am.  If the terminal has a command that
     moves to the first column of the next line, that command can be given  as
     nw  (newline).   It is permissible for this to clear the remainder of the
     current line, so if the terminal has no correctly-working CR  and  LF  it
     may still be possible to craft a working nw out of one or both of them.

     These  capabilities  suffice  to  describe   hardcopy   and   "glass-tty"
     terminals.  Thus the Teletype model 33 is described as

       T3|tty33|33|tty|Teletype model 33:\

     and the Lear Siegler ADM-3 is described as

       l3|adm3|3|LSI ADM-3:\

     Parameterized Strings

     Cursor addressing and other strings requiring parameters are described by
     a  parameterized string capability, with printf(3)-like escapes %x in it,
     while other characters are passed through  unchanged.   For  example,  to
     address  the cursor the cm capability is given, using two parameters: the
     row and column to move to.  (Rows and columns are numbered from zero  and
     refer  to  the  physical  screen  visible  to the user, not to any unseen
     memory.  If the terminal has memory-relative cursor addressing, that  can
     be indicated by an analogous CM capability.)

     The % encodings have the following meanings:

             %%      output `%'
             %d      output value as in printf %d
             %2      output value as in printf %2d
             %3      output value as in printf %3d
             %.      output value as in printf %c
             %+x     add x to value, then do %.
             %>xy    if value > x then add y, no output
             %r      reverse order of two parameters, no output
             %i      increment by one, no output
             %n      exclusive-or all parameters with 0140 (Datamedia 2500)
             %B      BCD (16*(value/10)) + (value%10), no output
             %D      Reverse coding (value - 2*(value%16)), no  output  (Delta

     Consider the Hewlett-Packard 2645, which, to get to row 3 and column  12,
     needs  to  be sent "\E&a12c03Y" padded for 6 milliseconds.  Note that the
     order of the row and column coordinates is reversed here and that the row
     and  column  are  sent  as two-digit integers.  Thus its cm capability is

     The Microterm ACT-IV needs the current row and column sent simply encoded
     in binary preceded by a ^T, "cm=^T%.%.".  Terminals that use "%." need to
     be able to backspace the cursor (le) and to move the cursor up  one  line
     on  the  screen (up).  This is necessary because it is not always safe to
     transmit \n, ^D, and \r, as  the  system  may  change  or  discard  them.
     (Programs  using  termcap  must  set  terminal modes so that tabs are not
     expanded, so \t is safe to send.  This turns out to be essential for  the
     Ann Arbor 4080.)

     A final example is the Lear Siegler ADM-3a, which offsets row and  column
     by a blank character, thus "cm=\E=%+ %+ ".

     Row or column absolute cursor addressing can be given as single parameter
     capabilities  ch (horizontal position absolute) and cv (vertical position
     absolute).  Sometimes these  are  shorter  than  the  more  general  two-
     parameter  sequence (as with the Hewlett-Packard 2645) and can be used in
     preference to cm.  If there are parameterized local motions (e.g., move n
     positions  to  the right) these can be given as DO, LE, RI, and UP with a
     single parameter indicating  how  many  positions  to  move.   These  are
     primarily  useful if the terminal does not have cm, such as the Tektronix

     Cursor Motions

     If the terminal has a fast way to home the cursor (to the very upper left
     corner of the screen), this can be given as ho.  Similarly, a fast way of
     getting to the lower left-hand corner  can  be  given  as  ll;  this  may
     involve  going  up  with  up from the home position, but a program should
     never do this itself (unless ll does), because it can make no  assumption
     about the effect of moving up from the home position.  Note that the home
     position is the same as cursor address (0,0): to the top left  corner  of
     the  screen,  not  of memory.  (Therefore, the "\EH" sequence on Hewlett-
     Packard terminals cannot be used for ho.)

     Area Clears

     If the terminal can clear from the current position to  the  end  of  the
     line, leaving the cursor where it is, this should be given as ce.  If the
     terminal can clear from the current position to the end of  the  display,
     this  should  be  given  as  cd.   cd must only be invoked from the first
     column of a line.  (Therefore, it can be simulated by a request to delete
     a large number of lines, if a true cd is not available.)

     Insert/Delete Line

     If the terminal can open a new blank line before the line containing  the
     cursor,  this  should  be given as al; this must be invoked only from the
     first position of a line.  The cursor must then appear at the left of the
     newly blank line.  If the terminal can delete the line that the cursor is
     on, this should be given as dl; this must only be  used  from  the  first
     position  on  the line to be deleted.  Versions of al and dl which take a
     single parameter and insert or delete that many lines can be given as  AL
     and  DL.   If  the  terminal  has  a  settable scrolling region (like the
     VT100), the command to set this can be described with the cs  capability,
     which  takes  two  parameters:  the top and bottom lines of the scrolling
     region.  The  cursor  position  is,  alas,  undefined  after  using  this
     command.  It is possible to get the effect of insert or delete line using
     this command -- the sc and rc (save and restore cursor) commands are also
     useful.   Inserting  lines at the top or bottom of the screen can also be
     done using sr or sf on many terminals without a true insert/delete  line,
     and is often faster even on terminals with those features.

     If the terminal has the ability to define a  window  as  part  of  memory
     which all commands affect, it should be given as the parameterized string
     wi.  The four parameters are the starting and ending lines in memory  and
     the starting and ending columns in memory, in that order.  (This terminfo
     capability is described  for  completeness.   It  is  unlikely  that  any
     termcap-using program will support it.)

     If the terminal can retain display memory above the screen, then  the  da
     capability should be given; if display memory can be retained below, then
     db should be given.  These indicate that deleting a line or scrolling may
     bring  non-blank  lines  up from below or that scrolling back with sr may
     bring down non-blank lines.

     Insert/Delete Character

     There are two basic  kinds  of  intelligent  terminals  with  respect  to
     insert/delete  character  that  can be described using termcap.  The most
     common insert/delete character operations affect only the  characters  on
     the  current  line  and shift characters off the end of the line rigidly.
     Other terminals, such as the Concept-100 and the Perkin Elmer Owl, make a
     distinction between typed and untyped blanks on the screen, shifting upon
     an insert or delete only to an untyped  blank  on  the  screen  which  is
     either  eliminated  or expanded to two untyped blanks.  You can determine
     the kind of terminal you have by clearing the  screen  then  typing  text
     separated  by  cursor  motions.   Type  "abc    def"  using  local cursor
     motions (not spaces) between the "abc" and the "def".  Then position  the
     cursor  before  the "abc" and put the terminal in insert mode.  If typing
     characters causes the rest of the line to shift rigidly and characters to
     fall  off the end, then your terminal does not distinguish between blanks
     and untyped positions.  If the "abc" shifts over to the "def" which  then
     move together around the end of the current line and onto the next as you
     insert, then you have the second type of terminal  and  should  give  the
     capability  in,  which  stands  for  "insert  null".  While these are two
     logically separate attributes (one line vs. multi-line insert  mode,  and
     special  treatment  of  untyped  spaces), we have seen no terminals whose
     insert mode cannot be described with the single attribute.

     Termcap can  describe  both  terminals  that  have  an  insert  mode  and
     terminals  that  send  a  simple sequence to open a blank position on the
     current line.  Give as im the sequence to get into insert mode.  Give  as
     ei  the  sequence to leave insert mode.  Now give as ic any sequence that
     needs to be sent  just  before  each  character  to  be  inserted.   Most
     terminals  with a true insert mode will not give ic; terminals that use a
     sequence to open a  screen  position  should  give  it  here.   (If  your
     terminal  has both, insert mode is usually preferable to ic.  Do not give
     both  unless  the  terminal  actually  requires  both  to  be   used   in
     combination.)  If post-insert padding is needed, give this as a number of
     milliseconds in ip (a string option).  Any other sequence that  may  need
     to be sent after insertion of a single character can also be given in ip.
     If your terminal needs to be placed into an `insert  mode'  and  needs  a
     special code preceding each inserted character, then both  im/ei  and  ic
     can  be  given,  and  both  will  be  used.   The IC capability, with one
     parameter n, will repeat the effects of ic n times.

     It is occasionally necessary to move  around  while  in  insert  mode  to
     delete  characters  on  the  same line (e.g., if there is a tab after the
     insertion position).  If your terminal  allows  motion  while  in  insert
     mode,  you can give the capability mi to speed up inserting in this case.
     Omitting mi will affect only speed.  Some terminals (notably Datamedia's)
     must not have mi because of the way their insert mode works.

     Finally, you can specify dc to delete a single  character,  DC  with  one
     parameter  n  to delete n characters, and delete mode by giving dm and ed
     to enter and exit delete mode (which is any mode the terminal needs to be
     placed in for dc to work).

     Highlighting, Underlining, and Visible Bells

     If your terminal has one or more kinds of display attributes,  these  can
     be  represented  in  a  number  of different ways.  You should choose one
     display form as standout mode, representing a good  high-contrast,  easy-
     on-the-eyes  format  for  highlighting error messages and other attention
     getters.  (If you have a choice, reverse video plus half-bright is  good,
     or  reverse  video alone.)  The sequences to enter and exit standout mode
     are given as so and se, respectively.  If the code to change into or  out
     of  standout  mode  leaves  one  or  even  two  blank  spaces  or garbage
     characters on the screen, as the TVI 912 and Teleray  1061  do,  then  sg
     should be given to tell how many characters are left.

     Codes to begin underlining and end underlining can be given as us and ue,
     respectively.   Underline mode change garbage is specified by ug, similar
     to sg.  If the terminal has a code to underline the current character and
     move  the  cursor  one position to the right, such as the Microterm Mime,
     this can be given as uc.

     Other  capabilities  to  enter  various  highlighting  modes  include  mb
     (blinking),  md  (bold  or  extra  bright),  mh  (dim or half-bright), mk
     (blanking or invisible text), mp  (protected),  mr  (reverse  video),  me
     (turn  off all attribute modes), as (enter alternate character set mode),
     and ae (exit alternate character set mode).   Turning  on  any  of  these
     modes singly may or may not turn off other modes.

     If there is a sequence to set arbitrary combinations of mode, this should
     be  given as sa (set attributes), taking 9 parameters.  Each parameter is
     either 0 or 1, as the corresponding attributes  is  on  or  off.   The  9
     parameters are, in order: standout, underline, reverse, blink, dim, bold,
     blank, protect, and alternate character  set.   Not  all  modes  need  be
     supported  by  sa,  only those for which corresponding attribute commands
     exist.  (It is unlikely that a termcap-using program  will  support  this
     capability, which is defined for compatibility with terminfo.)
     Terminals with the "magic cookie"  glitches  (sg  and  ug),  rather  than
     maintaining extra attribute bits for each character cell, instead deposit
     special "cookies", or  "garbage  characters",  when  they  receive  mode-
     setting sequences, which affect the display algorithm.

     Some terminals, such as the  Hewlett-Packard  2621,  automatically  leave
     standout  mode  when  they  move  to  a  new  line  or when the cursor is
     addressed.  Programs using standout mode should  exit  standout  mode  on
     such  terminals  before  moving  the  cursor  or  sending  a newline.  On
     terminals where this is not  a  problem,  the  ms  capability  should  be
     present to say that this overhead is unnecessary.

     If the terminal has a way of flashing the screen  to  indicate  an  error
     quietly  (a  bell replacement), this can be given as vb; it must not move
     the cursor.

     If the cursor needs to be made more visible than normal when it is not on
     the bottom line (to change, for example, a non-blinking underline into an
     easier-to-find block or blinking underline), give this  sequence  as  vs.
     If  there  is a way to make the cursor completely invisible, give that as
     vi.  The capability ve, which undoes the effects of both of these  modes,
     should also be given.

     If your  terminal  correctly  displays  underlined  characters  (with  no
     special codes needed) even though it does not overstrike, then you should
     give the capability ul.  If overstrikes are erasable with a  blank,  this
     should be indicated by giving eo.


     If the terminal has a keypad that  transmits  codes  when  the  keys  are
     pressed,  this information can be given.  Note that it is not possible to
     handle terminals where the keypad only works in local mode (this applies,
     for  example, to the unshifted Hewlett-Packard 2621 keys).  If the keypad
     can be set to transmit or not transmit, give these codes as  ks  and  ke.
     Otherwise  the  keypad  is assumed to always transmit.  The codes sent by
     the left-arrow, right-arrow, up-arrow, down-arrow, and home keys  can  be
     given  as  kl,  kr,  ku, kd, and kh, respectively.  If there are function
     keys such as f0, f1, ..., f9, the codes they send can  be  given  as  k0,
     k1,...,  k9.  If these keys have labels other than the default f0 through
     f9, the labels can be given as l0, l1,..., l9.  The codes transmitted  by
     certain other special keys can be given:  kH (home down), kb (backspace),
     ka (clear all tabs), kt (clear the tab stop in this  column),  kC  (clear
     screen  or  erase),  kD  (delete  character),  kL (delete line), kM (exit
     insert mode), kE (clear to end of line), kS (clear to end of screen),  kI
     (insert  character  or  enter  insert  mode),  kA (insert line), kN (next
     page),  kP  (previous  page),  kF  (scroll  forward/down),   kR   (scroll
     backward/up),  and  kT  (set a tab stop in this column).  In addition, if
     the keypad has a 3 by 3 array of keys including the four arrow keys, then
     the  other  five keys can be given as K1, K2, K3, K4, and K5.  These keys
     are useful when the effects of a 3 by 3 directional pad are needed.   The
     obsolete  ko  capability  formerly used to describe "other" function keys
     has been completely supplanted by the above capabilities.

     The ma entry is also used to indicate arrow keys on terminals  that  have
     single-character  arrow keys.  It is obsolete but still in use in version
     2  of  vi  which  must  be  run  on  some  minicomputers  due  to  memory
     limitations.   This  field  is redundant with kl, kr, ku, kd, and kh.  It
     consists of groups of two characters.  In each group, the first character
     is what an arrow key sends, and the second character is the corresponding
     vi command.  These commands are h for kl, j for kd, k for ku, l  for  kr,
     and  H  for  kh.   For  example,  the  Mime  would have "ma=^Hh^Kj^Zk^Xl"
     indicating arrow keys left (^H), down (^K),  up  (^Z),  and  right  (^X).
     (There is no home key on the Mime.)

     Tabs and Initialization

     If the terminal needs to be in a special mode when running a program that
     uses  these  capabilities,  the  codes to enter and exit this mode can be
     given as ti and te.  This arises, for example, from  terminals  like  the
     Concept  with  more  than  one  page of memory.  If the terminal has only
     memory-relative  cursor  addressing  and   not   screen-relative   cursor
     addressing,  a  screen-sized  window  must  be fixed into the display for
     cursor addressing to work properly.  This is also used for the  Tektronix
     4025, where ti sets the command character to be the one used by termcap.

     Other capabilities include is, an initialization string for the terminal,
     and if, the name of a file containing long initialization strings.  These
     strings are expected to set the terminal into modes consistent  with  the
     rest  of the termcap description.  They are normally sent to the terminal
     by the tset program each time the user logs in.  They will be printed  in
     the  following  order:  is; setting tabs using ct and st; and finally if.
     (Terminfo uses i1-i2 instead of is and runs the program iP and prints  i3
     after the other initializations.)  A pair of sequences that does a harder
     reset from a totally unknown state can be analogously given as rs and if.
     These  strings  are  output  by the reset program, which is used when the
     terminal gets into a wedged state.  (Terminfo uses r1-r3 instead of  rs.)
     Commands  are  normally placed in rs and rf only if they produce annoying
     effects on the screen  and  are  not  necessary  when  logging  in.   For
     example,  the command to set the VT100 into 80-column mode would normally
     be part of is, but it causes an annoying glitch of the screen and is  not
     normally needed since the terminal is usually already in 80-column mode.

     If the terminal has hardware tabs, the command to advance to the next tab
     stop  can  be  given as ta (usually ^I).  A "backtab" command which moves
     leftward to the previous tab stop can be given as bt.  By convention,  if
     the  terminal  driver modes indicate that tab stops are being expanded by
     the computer rather than being sent to the terminal, programs should  not
     use  ta  or  bt even if they are present, since the user may not have the
     tab stops properly set.  If the  terminal  has  hardware  tabs  that  are
     initially set every n positions when the terminal is powered up, then the
     numeric  parameter  it  is given, showing the number of positions between
     tab stops.  This is normally  used  by  the  tset  command  to  determine
     whether to set the driver mode for hardware tab expansion, and whether to
     set the tab stops.  If the terminal has tab stops that can  be  saved  in
     nonvolatile  memory,  the  termcap  description  can assume that they are
     properly set.

     If there are commands to set and clear tab stops, they can be given as ct
     (clear  all  tab  stops)  and st (set a tab stop in the current column of
     every row).  If a more complex sequence is needed to set  the  tabs  than
     can be described by this, the sequence can be placed in is or if.


     Certain capabilities control padding in the terminal driver.   These  are
     primarily  needed  by hardcopy terminals and are used by the tset program
     to set terminal driver  modes  appropriately.   Delays  embedded  in  the
     capabilities cr, sf, le, ff, and ta will cause the appropriate delay bits
     to be set in the terminal driver.  If pb (padding baud  rate)  is  given,
     these  values  can  be  ignored at baud rates below the value of pb.  For
     4.2BSD tset, the delays are given as numeric capabilities dC, dN, dB, dF,
     and dT instead.


     If the terminal requires other than a NUL (zero) character as a pad, this
     can be given as pc.  Only the first character of the pc string is used.

     If the terminal has commands to save and  restore  the  position  of  the
     cursor, give them as sc and rc.

     If the terminal has an extra "status line" that is not normally  used  by
     software, this fact can be indicated.  If the status line is viewed as an
     extra line below the bottom line, then the capability hs should be given.
     Special strings to go to a position in the status line and to return from
     the status line can be given as ts and fs.  (fs  must  leave  the  cursor
     position  in  the same place that it was before ts.  If necessary, the sc
     and rc strings can be included in ts and fs to  get  this  effect.)   The
     capability  ts  takes  one  parameter,  which is the column number of the
     status line to which the cursor is to be moved.  If escape sequences  and
     other  special  commands  such  as tab work while in the status line, the
     flag es can be given.  A string  that  turns  off  the  status  line  (or
     otherwise erases its contents) should be given as ds.  The status line is
     normally assumed to be the same width as the rest of  the  screen,  i.e.,
     co.   If  the  status  line  is  a  different width (possibly because the
     terminal does not allow an entire line to be loaded), then its  width  in
     columns can be indicated with the numeric parameter ws.

     If the terminal can move up or down half a line, this  can  be  indicated
     with hu (half-line up) and hd (half-line down).  This is primarily useful
     for superscripts and subscripts on hardcopy  terminals.   If  a  hardcopy
     terminal can eject to the next page (form feed), give this as ff (usually

     If there is a command to repeat a given character a given number of times
     (to  save time transmitting a large number of identical characters), this
     can be indicated with the parameterized string rp.  The  first  parameter
     is  the character to be repeated and the second is the number of times to
     repeat it.  (This is a terminfo feature that is unlikely to be  supported
     by a program that uses termcap.)

     If the terminal has a settable command character, such as  the  Tektronix
     4025,  this  can  be indicated with CC.  A prototype command character is
     chosen which is used in all capabilities.  This character is given in the
     CC  capability  to identify it.  The following convention is supported on
     some UNIX systems:  The environment is to be searched for a CC  variable,
     and  if found, all occurrences of the prototype character are replaced by
     the  character  in  the  environment  variable.   This  use  of  the   CC
     environment variable is a very bad idea, as it conflicts with make(1).

     Terminal descriptions that do not represent  a  specific  kind  of  known
     terminal,  such as switch, dialup, patch, and network, should include the
     gn (generic) capability so that programs can complain that  they  do  not
     know  how  to  talk  to the terminal.  (This capability does not apply to
     virtual terminal descriptions for which the escape sequences are known.)

     If the terminal uses xoff/xon (DC3/DC1)  handshaking  for  flow  control,
     give  xo.   Padding information should still be included so that routines
     can make better decisions about costs, but actual pad characters will not
     be transmitted.

     If the terminal has a "meta key" which acts as a shift key,  setting  the
     8th  bit  of  any  character transmitted, then this fact can be indicated
     with km.  Otherwise, software will assume that the 8th bit is parity  and
     it will usually be cleared.  If strings exist to turn this "meta mode" on
     and off, they can be given as mm and mo.

     If the terminal has more lines of memory than will fit on the  screen  at
     once,  the  number  of  lines  of  memory  can  be indicated with lm.  An
     explicit value of 0 indicates that the number of lines is not fixed,  but
     that there is still more memory than fits on the screen.

     If the terminal is one of those supported  by  the  UNIX  system  virtual
     terminal protocol, the terminal number can be given as vt.

     Media copy strings which control an auxiliary printer  connected  to  the
     terminal can be given as ps:  print the contents of the screen; pf:  turn
     off the printer; and po:  turn on the printer.  When the printer  is  on,
     all text sent to the terminal  will  be  sent  to  the  printer.   It  is
     undefined  whether the text is also displayed on the terminal screen when
     the printer is on.  A variation pO takes one  parameter  and  leaves  the
     printer  on  for  as  many characters as the value of the parameter, then
     turns the printer off.  The parameter should not exceed 255.   All  text,
     including  pf,  is  transparently  passed  to  the printer while pO is in

     Strings to program function keys can be given as pk, pl, and px.  Each of
     these  strings  takes  two parameters: the function key number to program
     (from 0 to 9) and the string to program it with.   Function  key  numbers
     out  of  this  range  may  program undefined keys in a terminal-dependent
     manner.  The differences  among  the  capabilities  are  that  pk  causes
     pressing  the  given  key  to  be  the  same as the user typing the given
     string; pl causes the string to be executed  by  the  terminal  in  local
     mode;  and  px  causes  the  string  to  be  transmitted to the computer.
     Unfortunately, due to lack of  a  definition  for  string  parameters  in
     termcap, only terminfo supports these capabilities.

     Glitches and Braindamage

     Hazeltine terminals, which do not allow `~' characters to  be  displayed,
     should indicate hz.

     The nc capability, now obsolete, formerly indicated Datamedia  terminals,
     which echo \r \n for carriage return then ignore a following linefeed.

     Terminals that ignore a linefeed immediately after an am  wrap,  such  as
     the Concept, should indicate xn.

     If ce is required to get rid  of  standout  (instead  of  merely  writing
     normal text on top of it), xs should be given.

     Teleray terminals, where tabs turn all characters moved over  to  blanks,
     should indicate xt (destructive tabs).  This glitch is also taken to mean
     that it is not possible to  position  the  cursor  on  top  of  a  "magic
     cookie",  and  that  to erase standout mode it is necessary to use delete
     and insert line.

     The Beehive Superbee, which is unable to correctly transmit the ESC or ^C
     characters, has xb, indicating that the "f1" key is used for ESC and "f2"
     for ^C.  (Only certain Superbees have  this  problem,  depending  on  the

     Other  specific  terminal  problems  may  be  corrected  by  adding  more
     capabilities of the form xx.

     Similar Terminals

     If there are two very similar terminals, one can be defined as being just
     like  the other with certain exceptions.  The string capability tc can be
     given with the name of the similar terminal.   This  capability  must  be
     last,  and  the combined length of the entries must not exceed 1024.  The
     capabilities given before tc override those in the terminal type  invoked
     by tc.  A capability can be canceled by placing xx@ to the left of the tc
     invocation, where xx is the capability.  For example, the entry


     defines a "2621-nl" that does not have the ks or ke  capabilities,  hence
     does  not  turn  on the function key labels when in visual mode.  This is
     useful for  different  modes  for  a  terminal,  or  for  different  user


     William Joy
     Mark Horton added underlining and keypad support


     /etc/termcap   file  containing  terminal  descriptions  /usr/etc/termcap
                    file containing more terminal descriptions (Minix-vmd)


     elvis(1), more(1), termcap(3), printf(3).


     Lines and columns are now stored by the kernel as well as in the  termcap
     entry.   Most  programs  now  use  the  kernel information primarily; the
     information in this file is used only if the kernel  does  not  have  any

     Not all programs support all entries.

     The Minix termcap(3)  does  not  understand  everything  described  here,
     unlike the one Minix-vmd uses.