


      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



      NNNNAAAAMMMMEEEE
           terminfo - terminal capability data base

      SSSSYYYYNNNNTTTTAAAAXXXX
           /usr/lib/terminfo/*/*

      DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
           TTTTeeeerrrrmmmmiiiinnnnffffoooo is a directory of files that describe terminal
           capabilities.  The capabilities are read by programs like
           vi(1) and curses(3x).  The files list the capabilities and
           how operations are performed, and the padding requirements
           and initialization sequences of various terminal devices.

           TTTTeeeerrrrmmmmiiiinnnnffffoooo entries consist of fields separated by `,'.  White
           space after each `,' is ignored.

           The first entry for a terminal contains the names by which
           the device is known, each separated by  a `|' character.
           The first name in the first entry is the most common
           abbreviation for the terminal; the next names are synonyms
           for the terminal name; the last name fully identifies the
           terminal.  All names but the last should be in lowercase and
           contain no blanks; the last name may contain uppercase and
           blanks.

           Terminal names (except for the last, verbose name) are
           selected 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, except that synonyms may be chosen that do not
           conflict with other names.  Modes that the hardware can be
           in, or user preferences, should be indicated by appending a
           hyphen and an indicator of the mode.  Thus, a vt100 in 132
           column mode would be vt100-w.  The following suffixes should
           be used where possible:
            SSSSuuuuffffffffiiiixxxx                 MMMMeeeeaaaannnniiiinnnngggg                  EEEExxxxaaaammmmpppplllleeee
            -w       Wide mode (more than 80 columns)       vt100-w
            -am      With auto. 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)    c100-na
            -_np      Number of pages of memory              c100-4p
            -rv      Reverse video                          c100-rv

      CCCCAAAAPPPPAAAABBBBIIIILLLLIIIITTTTIIIIEEEESSSS
           The variable is the name by which the programmer (at the
           terminfo level) accesses the capability.  The capname is the
           short name used in the text of the database, and is used by
           a person updating the database.  The i.code is the two-
           letter internal code used in the compiled database, and
           always corresponds to the old tttteeeerrrrmmmmccccaaaapppp capability name.




      Page 1                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           Capability names have no hard length limit, but an informal
           limit of 5 characters has been adopted to keep them short
           and to allow the tabs in the source file ccccaaaappppssss to line up
           nicely.  Whenever possible, names are chosen to be the same
           as or similar to the ANSI X3.64-1979 standard.  Semantics
           are also intended to match those of the specification.

           (P)  indicates that padding may be specified

           (G)  indicates that the string is passed through tparm, with
                parms as given (#_i).

           (*)  indicates that padding may be based on the number of
                lines affected

           (#9_i8) indicates the _i8th9 parameter.


             VVVVaaaarrrriiiiaaaabbbblllleeee           CCCCaaaapppp----     IIII....                    DDDDeeeessssccccrrrriiiippppttttiiiioooonnnn
             BBBBoooooooolllleeeeaaaannnnssss           nnnnaaaammmmeeee    CCCCooooddddeeee
      auto_left_margin,         bw      bw     cub1 wraps from column 0 to last column
      auto_right_margin,        am      am     Terminal has automatic margins
      beehive_glitch,           xsb     xb     Beehive (f1=escape, f2=ctrl C)
      ceol_standout_glitch,     xhp     xs     Standout not erased by overwriting (hp)
      eat_newline_glitch,       xenl    xn     newline ignored after 80 cols (Concept)
      erase_overstrike,         eo      eo     Can erase overstrikes with a blank
      generic_type,             gn      gn     Generic line type (e.g.,, dialup, switch).
      hard_copy,                hc      hc     Hardcopy terminal
      has_meta_key,             km      km     Has a meta key (shift, sets parity bit)
      has_status_line,          hs      hs     Has extra "status line"
      insert_null_glitch,       in      in     Insert mode distinguishes nulls
      memory_above,             da      da     Display may be retained above the screen
      memory_below,             db      db     Display may be retained below the screen
      move_insert_mode,         mir     mi     Safe to move while in insert mode
      move_standout_mode,       msgr    ms     Safe to move in standout modes
      over_strike,              os      os     Terminal overstrikes
      status_line_esc_ok,       eslok   es     Escape can be used on the status line
      teleray_glitch,           xt      xt     Tabs ruin, magic so char (Teleray 1061)
      tilde_glitch,             hz      hz     Hazeltine; can not print ~'s
      transparent_underline,    ul      ul     underline character overstrikes
      xon_xoff,                 xon     xo     Terminal uses xon/xoff handshaking

      NNNNuuuummmmbbbbeeeerrrrssss::::
      columns,                  cols    co     Number of columns in a line
      init_tabs,                it      it     Tabs initially every # spaces
      lines,                    lines   li     Number of lines on screen or page
      lines_of_memory,          lm      lm     Lines of memory if > lines.  0 means varies
      magic_cookie_glitch,      xmc     sg     Number of blank chars left by smso or
                                               rmso
      padding_baud_rate,        pb      pb     Lowest baud where cr/nl padding is needed
      virtual_terminal,         vt      vt     Virtual terminal number (UNIX system)
      width_status_line,        wsl     ws     No. columns in status line



      Page 2                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))




      SSSSttttrrrriiiinnnnggggssss::::
      back_tab,                 cbt     bt     Back tab (P)
      bell,                     bel     bl     Audible signal (bell) (P)
      carriage_return,          cr      cr     Carriage return (P*)
      change_scroll_region,     csr     cs     change to lines #1 through #2 (vt100)
                                               (PG)
      clear_all_tabs,           tbc     ct     Clear all tab stops (P)
      clear_screen,             clear   cl     Clear screen and home cursor (P*)
      clr_eol,                  el      ce     Clear to end of line (P)
      clr_eos,                  ed      cd     Clear to end of display (P*)
      column_address,           hpa     ch     Set cursor column (PG)
      command_character,        cmdch   CC     Term. settable cmd char in prototype
      cursor_address,           cup     cm     Screen rel. cursor motion row #1
                                               col #2 (PG)
      cursor_down,              cud1    do     Down one line
      cursor_home,              home    ho     Home cursor (if no cup)
      cursor_invisible,         civis   vi     Make cursor invisible
      cursor_left,              cub1    le     Move cursor left one space
      cursor_mem_address,       mrcup   CM     Memory relative cursor addressing
      cursor_normal,            cnorm   ve     Make cursor appear normal (undo vs/vi)
      cursor_right,             cuf1    nd     Non-destructive space (cursor right)
      cursor_to_ll,             ll      ll     Last line, first column (if no cup)
      cursor_up,                cuu1    up     Upline (cursor up)
      cursor_visible,           cvvis   vs     Make cursor very visible
      delete_character,         dch1    dc     Delete character (P*)
      delete_line,              dl1     dl     Delete line (P*)
      dis_status_line,          dsl     ds     Disable status line
      down_half_line,           hd      hd     Half-line down (forward 1/2 linefeed)
      enter_alt_charset_mode,   smacs   as     Start alternate character set (P)
      enter_blink_mode,         blink   mb     Turn on blinking
      enter_bold_mode,          bold    md     Turn on bold (extra bright) mode
      enter_ca_mode,            smcup   ti     String to begin programs that use cup
      enter_delete_mode,        smdc    dm     Delete mode (enter)
      enter_dim_mode,           dim     mh     Turn on half-bright mode
      enter_insert_mode,        smir    im     Insert mode (enter);
      enter_protected_mode,     prot    mp     Turn on protected mode
      enter_reverse_mode,       rev     mr     Turn on reverse video mode
      enter_secure_mode,        invis   mk     Turn on blank mode (chars invisible)
      enter_standout_mode,      smso    so     Begin stand out mode
      enter_underline_mode,     smul    us     Start underscore mode
      erase_chars               ech     ec     Erase #1 characters (PG)
      exit_alt_charset_mode,    rmacs   ae     End alternate character set (P)
      exit_attribute_mode,      sgr0    me     Turn off all attributes
      exit_ca_mode,             rmcup   te     String to end programs that use cup
      exit_delete_mode,         rmdc    ed     End delete mode
      exit_insert_mode,         rmir    ei     End insert mode
      exit_standout_mode,       rmso    se     End stand out mode
      exit_underline_mode,      rmul    ue     End underscore mode
      flash_screen,             flash   vb     Visible bell (may not move cursor)
      form_feed,                ff      ff     Hardcopy terminal page eject (P*)
      from_status_line,         fsl     fs     Return from status line



      Page 3                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



      init_1string,             is1     i1     Terminal initialization string
      init_2string,             is2     i2     Terminal initialization string
      init_3string,             is3     i3     Terminal initialization string
      init_file,                if      if     Name of file containing is
      insert_character,         ich1    ic     Insert character (P)
      insert_line,              il1     al     Add new blank line (P*)
      insert_padding,           ip      ip     Insert pad after character inserted (p*)
      key_backspace,            kbs     kb     Sent by backspace key
      key_catab,                ktbc    ka     Sent by clear-all-tabs key
      key_clear,                kclr    kC     Sent by clear screen or erase key
      key_ctab,                 kctab   kt     Sent by clear-tab key
      key_dc,                   kdch1   kD     Sent by delete character key
      key_dl,                   kdl1    kL     Sent by delete line key
      key_down,                 kcud1   kd     Sent by terminal down arrow key
      key_eic,                  krmir   kM     Sent by rmir or smir in insert mode
      key_eol,                  kel     kE     Sent by clear-to-end-of-line key
      key_eos,                  ked     kS     Sent by clear-to-end-of-screen key
      key_f0,                   kf0     k0     Sent by function key f0
      key_f1,                   kf1     k1     Sent by function key f1
      key_f10,                  kf10    ka     Sent by function key f10
      key_f2,                   kf2     k2     Sent by function key f2
      key_f3,                   kf3     k3     Sent by function key f3
      key_f4,                   kf4     k4     Sent by function key f4
      key_f5,                   kf5     k5     Sent by function key f5
      key_f6,                   kf6     k6     Sent by function key f6
      key_f7,                   kf7     k7     Sent by function key f7
      key_f8,                   kf8     k8     Sent by function key f8
      key_f9,                   kf9     k9     Sent by function key f9
      key_home,                 khome   kh     Sent by home key
      key_ic,                   kich1   kI     Sent by ins char/enter ins mode key
      key_il,                   kil1    kA     Sent by insert line
      key_left,                 kcub1   kl     Sent by terminal left arrow key
      key_ll,                   kll     kH     Sent by home-down key
      key_npage,                knp     kN     Sent by next-page key
      key_ppage,                kpp     kP     Sent by previous-page key
      key_right,                kcuf1   kr     Sent by terminal right arrow key
      key_sf,                   kind    kF     Sent by scroll-forward/down key
      key_sr,                   kri     kR     Sent by scroll-backward/up key
      key_stab,                 khts    kT     Sent by set-tab key
      key_up,                   kcuu1   ku     Sent by terminal up arrow key
      keypad_local,             rmkx    ke     Out of "keypad transmit" mode
      keypad_xmit,              smkx    ks     Put terminal in "keypad transmit" mode
      lab_f0,                   lf0     l0     Labels on function key f0 if not f0
      lab_f1,                   lf1     l1     Labels on function key f1 if not f1
      lab_f10,                  lf10    la     Labels on function key f10 if not f10
      lab_f2,                   lf2     l2     Labels on function key f2 if not f2
      lab_f3,                   lf3     l3     Labels on function key f3 if not f3
      lab_f4,                   lf4     l4     Labels on function key f4 if not f4
      lab_f5,                   lf5     l5     Labels on function key f5 if not f5
      lab_f6,                   lf6     l6     Labels on function key f6 if not f6
      lab_f7,                   lf7     l7     Labels on function key f7 if not f7
      lab_f8,                   lf8     l8     Labels on function key f8 if not f8



      Page 4                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



      lab_f9,                   lf9     l9     Labels on function key f9 if not f9
      meta_on,                  smm     mm     Turn on "meta mode" (8th bit)
      meta_off,                 rmm     mo     Turn off "meta mode"
      newline,                  nel     nw     Newline (behaves like cr followed by lf)
      pad_char,                 pad     pc     Pad character (rather than null)
      parm_dch,                 dch     DC     Delete #1 chars (PG*)
      parm_delete_line,         dl      DL     Delete #1 lines (PG*)
      parm_down_cursor,         cud     DO     Move cursor down #1 lines (PG*)
      parm_ich,                 ich     IC     Insert #1 blank chars (PG*)
      parm_index,               indn    SF     Scroll forward #1 lines (PG)
      parm_insert_line,         il      AL     Add #1 new blank lines (PG*)
      parm_left_cursor,         cub     LE     Move cursor left #1 spaces (PG)
      parm_right_cursor,        cuf     RI     Move cursor right #1 spaces (PG*)
      parm_rindex,              rin     SR     Scroll backward #1 lines (PG)
      parm_up_cursor,           cuu     UP     Move cursor up #1 lines (PG*)
      pkey_key,                 pfkey   pk     Prog funct key #1 to type string #2
      pkey_local,               pfloc   pl     Prog funct key #1 to execute string #2
      pkey_xmit,                pfx     px     Prog funct key #1 to xmit string #2
      print_screen,             mc0     ps     Print contents of the screen
      prtr_off,                 mc4     pf     Turn off the printer
      prtr_on,                  mc5     po     Turn on the printer
      repeat_char,              rep     rp     Repeat char #1 #2 times.  (PG*)
      reset_1string,            rs1     r1     Reset terminal completely to sane modes.
      reset_2string,            rs2     r2     Reset terminal completely to sane modes.
      reset_3string,            rs3     r3     Reset terminal completely to sane modes.
      reset_file,               rf      rf     Name of file containing reset string
      restore_cursor,           rc      rc     Restore cursor to position of last sc
      row_address,              vpa     cv     Vertical position absolute (set row) (PG)
      save_cursor,              sc      sc     Save cursor position (P)
      scroll_forward,           ind     sf     Scroll text up (P)
      scroll_reverse,           ri      sr     Scroll text down (P)
      set_attributes,           sgr     sa     Define the video attributes (PG9)
      set_tab,                  hts     st     Set a tab in all rows, current column
      set_window,               wind    wi     Current window is lines #1-#2 cols #3-#4
      tab,                      ht      ta     Tab to next 8 space hardware tab stop
      to_status_line,           tsl     ts     Go to status line, column #1
      underline_char,           uc      uc     Underscore one char and move past it
      up_half_line,             hu      hu     Half-line up (reverse 1/2 linefeed)
      init_prog,                iprog   iP     Path name of program for init
      key_a1,                   ka1     K1     Upper left of keypad
      key_a3,                   ka3     K3     Upper right of keypad
      key_b2,                   kb2     K2     Center of keypad
      key_c1,                   kc1     K4     Lower left of keypad
      key_c3,                   kc3     K5     Lower right of keypad
      prtr_non,                 mc5p    pO     Turn on the printer for #1 bytes

           AAAA SSSSaaaammmmpppplllleeee EEEEnnnnttttrrrryyyy

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




      Page 5                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



         concept100|c100|concept|c104|c100-4p|concept 100,
            am, bel=^G, blank=\EH, blink=\EC, clear=^L$<2*>, cnorm=\Ew,
            cols#80, cr=^M$<9>, cub1=^H, cud1=^J, cuf1=\E=,
            cup=\Ea%p1%' '%+%c%p2%' '%+%c,
            cuu1=\E;, cvvis=\EW, db, dch1=\E^A$<16*>, dim=\EE, dl1=\E^B$<3*>,
            ed=\E^C$<16*>, el=\E^U$<16>, eo, flash=\Ek$<20>\EK, ht=\t$<8>,
            il1=\E^R$<3*>, in, ind=^J, .ind=^J$<9>, ip=$<16*>,
            is2=\EU\Ef\E7\E5\E8\El\ENH\EK\E\200\Eo&\200\Eo\47\E,
            kbs=^h, kcub1=\E>, kcud1=\E<, kcuf1=\E=, kcuu1=\E;,
            kf1=\E5, kf2=\E6, kf3=\E7, khome=\E?,
            lines#24, mir, pb#9600, prot=\EI, rep=\Er%p1%c%p2%' '%+%c$<.2*>,
            rev=\ED, rmcup=\Ev    $<6>\Ep\r\n, rmir=\E\200, rmkx=\Ex,
            rmso=\Ed\Ee, rmul=\Eg, rmul=\Eg, sgr0=\EN\200,
            smcup=\EU\Ev  8p\Ep\r, smir=\E^P, smkx=\EX, smso=\EE\ED,
            smul=\EG, tabs, ul, vt#8, xenl,

           Entries may continue onto multiple lines by placing white
           space at the beginning of each line except the first.
           Comments may be included on lines beginning with ``#''.
           Capabilities in _t_e_r_m_i_n_f_o are of three types:  Boolean
           capabilities which indicate that the terminal has some
           particular feature, numeric capabilities giving the size of
           the terminal or the size of particular delays, and string
           capabilities, which give a sequence which can be used to
           perform particular terminal operations.

           TTTTyyyyppppeeeessss ooooffff CCCCaaaappppaaaabbbbiiiilllliiiittttiiiieeeessss

           All capabilities have mnemonic names.  The automatic margin
           feature of the Concept is called aaaammmm.  Numeric capabilities,
           such as column-width, are indicated by a mnemonic, then the
           `#' character, and then the numeric value.  For example,
           ccccoooollll####88880000 indicates 80 columns.

           String-valued capabilities, such as the character string to
           achieve a function, are indicated by a mnemonic, then the
           `=' character, and then the string value.  For example,
           eeeellll====^^^^yyyy (control-y clears display to end of line).  A delay in
           milliseconds may appear anywhere in such a capability,
           enclosed in $<..> brackets, as in eeeellll=\EK$<3>, and padding
           characters are supplied by _t_p_u_t_s to provide this delay.  The
           delay can be either a number like `20', or a number followed
           by an `*' like `3*'.  A `*' indicates that the padding
           required is proportional to the number of lines affected by
           the operation and the amount given is the per-affected-unit
           padding required.  (In the case of insert character, the
           factor is still the number of _l_i_n_e_s affected.  This is
           always one unless the terminal has xxxxeeeennnnllll and the software
           uses it.) When a `*' is specified, it is sometimes useful to
           give a delay of the form `3.5' to specify a delay per unit
           to tenths of milliseconds.  (Only one decimal place is
           allowed.)



      Page 6                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           A number of escape sequences are provided in the string-
           valued capabilities for easy encoding of characters there.
           Both \\\\EEEE and \\\\eeee map to an ESCAPE character, ^^^^xxxx maps to a
           control-x, where x is any character, and the sequences \\\\nnnn \\\\llll
           \\\\rrrr \\\\tttt \\\\bbbb \\\\ffff \\\\ssss give a newline, linefeed, return, tab,
           backspace, formfeed, and space.  Other escapes include \^
           for ^, \\ for \, \, for comma, \: for :, and \0 for null.
           (\0 will produce \200, which does not terminate a string but
           behaves as a null character on most terminals.) Finally,
           characters may be given as three octal digits after a \\\\.

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

           PPPPrrrreeeeppppaaaarrrriiiinnnngggg DDDDeeeessssccccrrrriiiippppttttiiiioooonnnnssss

           To write your own description file, copy a similar terminfo
           file.  Build the file piece by piece, testing it with vi(1)
           as you go.  (A very unusual terminal may expose deficiencies
           in the ability of the terminfo file to describe it, or bugs
           in vi(1).)

           To test a new terminal description, set the environment
           variable TERMINFO to the pathname of a directory under which
           the compiled description you are working on resides.  Your
           terminfo directory structure should duplicate the structure
           under /_u_s_r/_l_i_b/_t_e_r_m_i_n_f_o.  For instance, if
           TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO====////uuuussssrrrr////mmmmaaaarrrrkkkk////mmmmyyyytttteeeerrrrmmmmssss, and the terminal type is vt100,
           then programs such as vi(1) will look for the vt100 entry in
           /_u_s_r/_m_a_r_k/_m_y_t_e_r_m_s/_v before looking in /_u_s_r/_l_i_b/_t_e_r_m_i_n_f_o/_v.
           To get the padding for insert-line correct (if the terminal
           manufacturer did not document it) a severe test is to edit
           ////eeeettttcccc////ppppaaaasssssssswwwwdddd at 9600 baud, delete about 16 lines from the
           middle of the screen, then hit the `u' key several times
           quickly.  If the terminal craps out, more padding is usually
           needed.  A similar test can be used for insert-character.

           BBBBaaaassssiiiicccc CCCCaaaappppaaaabbbbiiiilllliiiittttiiiieeeessss

           The number of columns on each line for the terminal is given
           by the ccccoooollllssss numeric capability.  If the terminal is a CRT,
           then the number of lines on the screen is given by the lllliiiinnnneeeessss
           capability.  If the terminal wraps around to the beginning
           of the next line when it reaches the right margin, then it
           should have the aaaammmm capability.  If the terminal can clear
           its screen, leaving the cursor in the home position, then
           this is given by the cccclllleeeeaaaarrrr string capability.  If the
           terminal overstrikes rather than clearing a position when a
           character is struck over, then it should have the oooossss
           capability.  If the terminal is a printing terminal with no
           soft copy unit, give it both hhhhcccc and oooossss.  (oooossss applies to



      Page 7                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           storage scope terminals, such as TEKTRONIX 4010 series, as
           well as 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 ccccrrrr.  (Normally this will be carriage return,
           control-M.) If there is a code to produce an audible signal
           (bell, beep, etc) give this as bbbbeeeellll.

           If there is a code to move the cursor one position to the
           left (such as backspace) that capability should be given as
           ccccuuuubbbb1111.  Similarly, codes to move to the right, up, and down
           should be given as ccccuuuuffff1111, ccccuuuuuuuu1111, and ccccuuuudddd1111.  These local cursor
           motions should not alter the text they pass over, for
           example, you would not normally use `ccccuuuuffff1111= ' because the
           space would erase the character moved over.

           A very important point here is that the local cursor motions
           encoded in _t_e_r_m_i_n_f_o are undefined at the left and top edges
           of a CRT terminal.  Programs should never attempt to
           backspace around the left edge, unless bbbbwwww is given, and
           never attempt to go up locally off the top.  In order to
           scroll text up, a program will go to the bottom left corner
           of the screen and send the iiiinnnndddd (index) string.

           To scroll text down, a program goes to the top left corner
           of the screen and sends the rrrriiii (reverse index) string.  The
           strings iiiinnnndddd and rrrriiii are undefined when not on their
           respective corners of the screen.

           Parameterized versions of the scrolling sequences are iiiinnnnddddnnnn
           and rrrriiiinnnn which have the same semantics as iiiinnnndddd and rrrriiii except
           that they take one parameter, and scroll that many lines.
           They are also undefined except at the appropriate edge of
           the screen.

           The aaaammmm capability tells whether the cursor sticks at the
           right edge of the screen when text is output, but this does
           not necessarily apply to a ccccuuuuffff1111 from the last column.  The
           only local motion which is defined from the left edge is if
           bbbbwwww is given, then a ccccuuuubbbb1111 from the left edge will move to the
           right edge of the previous row.  If bbbbwwww is not given, the
           effect is undefined.  This is useful for drawing a box
           around the edge of the screen, for example.  If the terminal
           has switch selectable automatic margins, the _t_e_r_m_i_n_f_o file
           usually assumes that this is on; i.e., aaaammmm.  If the terminal
           has a command which moves to the first column of the next
           line, that command can be given as nnnneeeellll (newline).  It does
           not matter if the command clears the remainder of the
           current line, so if the terminal has no ccccrrrr and llllffff it may
           still be possible to craft a working nnnneeeellll out of one or both
           of them.

           These capabilities suffice to describe teletypestyle and



      Page 8                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           screen-type terminals.  Thus, the model 33 teletype is
           described as

           33|tty33|tty|model 33 teletype,
           bel=^G, cols#72, cr=^M, cud1=^J, hc, ind=^J, os,

           while the Lear Siegler ADM-3 is described as

           adm3|3|lsi adm3,
           am, bel=^G, clear=^Z, cols#80, cr=^M, cub1=^H, cud1=^J,
           ind=^J, lines#24,

           PPPPaaaarrrraaaammmmeeeetttteeeerrrriiiizzzzeeeedddd SSSSttttrrrriiiinnnnggggssss

           Cursor addressing and other strings requiring parameters in
           the terminal are described by a parameterized string
           capability, with printf(3S)-like escapes %%%% xxxx in it.  For
           example, to address the cursor, the ccccuuuupppp capability is given,
           using two parameters:  the row and column to address 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 mmmmrrrrccccuuuupppp.

           The parameter mechanism uses a stack and special %%%% codes to
           manipulate it.  Typically a sequence will push one of the
           parameters onto the stack and then print it in some format.
           Often more complex operations are necessary.

           The %%%% encodings have the following meanings:

                %%        outputs `%'
                %d        print pop() as in printf
                %2d       print pop() like %2d
                %3d       print pop() like %3d
                %02d
                %03d      as in printf
                %c        print pop() gives %c
                %s        print pop() gives %s

                %p[1-9]   push ith parm
                %P[a-z]   set variable [a-z] to pop()
                %g[a-z]   get variable [a-z] and push it
                %'c'      char constant c
                %{nn}     integer constant nn

                %+ %- %* %/ %m
                          arithmetic (%m is mod): push(pop() op pop())
                %& %| %^  bit operations: push(pop() op pop())
                %= %> %<  logical operations: push(pop() op pop())
                %! %~     unary operations push(op pop())
                %i        add 1 to first two parms (for ANSI terminals)



      Page 9                                                   (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



                %? expr %t thenpart %e elsepart %;
                          if-then-else, %e elsepart is optional.
                          else-if's are possible ala Algol 68:
                          %? c918 %t b918 %e c928 %t b928 %e c938 %t b938 %e c948 %t b948 %e %;
                          c9i8 are conditions, b9i8 are bodies.

           Binary operations are in postfix form with the operands in
           the usual order.  That is, to get x-5 one would use
           "%gx%{5}% -".

           Consider the HP2645, 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 rows and columns is inverted here, and
           that the row and column are printed as two digits.  Thus its
           ccccuuuupppp capability is cup=6\E&%p2%2dc%p1%2dY.

           The Microterm ACT-IV needs the current row and column sent
           preceded by a ^^^^TTTT, with the row and column simply encoded in
           binary, cup=^T%p1%c%p2%c.  Terminals which use %c need to be
           able to backspace the cursor (ccccuuuubbbb1111), and to move the cursor
           up one line on the screen (ccccuuuuuuuu1111).  This is necessary because
           it is not always safe to transmit \\\\nnnn ^^^^DDDD and \\\\rrrr, as the
           system may change or discard them.  (The library routines
           dealing with terminfo set tty modes so that tabs are never
           expanded, so \t is safe to send.  This turns out to be
           essential for the Ann Arbor 4080.)

           A final example is the LSI ADM-3a, which uses row and column
           offset by a blank character, thus cup=\E=%p1%' '%+%c%p2%'
           '%+%c.  After sending `\E=', this pushes the first
           parameter, pushes the ASCII value for a space (32), adds
           them (pushing the sum on the stack in place of the two
           previous values) and outputs that value as a character.
           Then the same is done for the second parameter.  More
           complex arithmetic is possible using the stack.

           If the terminal has row or column absolute cursor
           addressing, these can be given as single parameter
           capabilities hhhhppppaaaa (horizontal position absolute) and vvvvppppaaaa
           (vertical position absolute).  Sometimes these are shorter
           than the more general two parameter sequence (as with the
           hp2645) and can be used in preference to ccccuuuupppp .... If there are
           parameterized local motions (e.g., move _n spaces to the
           right) these can be given as ccccuuuudddd, ccccuuuubbbb, ccccuuuuffff, and ccccuuuuuuuu with a
           single parameter indicating how many spaces to move.  These
           are primarily useful if the terminal does not have ccccuuuupppp, such
           as the TEKTRONIX 4025.

           CCCCuuuurrrrssssoooorrrr MMMMoooottttiiiioooonnnnssss

           If the terminal has a fast way to home the cursor (to very
           upper left corner of screen) then this can be given as hhhhoooommmmeeee;



      Page 10                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           similarly a fast way of getting to the lower left-hand
           corner can be given as llllllll; this may involve going up with
           ccccuuuuuuuu1111 from the home position, but a program should never do
           this itself (unless llllllll 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
           addressing to (0,0):  to the top left corner of the screen,
           not of memory.  (Thus, the \EH sequence on HP terminals
           cannot be used for hhhhoooommmmeeee.)

           AAAArrrreeeeaaaa CCCClllleeeeaaaarrrrssss

           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 eeeellll.  If the terminal can clear from the current
           position to the end of the display, then this should be
           given as eeeedddd.  EEEEdddd is only defined from the first column of a
           line.  (Thus, it can be simulated by a request to delete a
           large number of lines, if a true eeeedddd is not available.)

           IIIInnnnsssseeeerrrrtttt////ddddeeeelllleeeetttteeee lllliiiinnnneeee

           If the terminal can open a new blank line before the line
           where the cursor is, this should be given as iiiillll1111; this is
           done only from the first position of a line.  The cursor
           must then appear on the newly blank line.  If the terminal
           can delete the line which the cursor is on, then this should
           be given as ddddllll1111; this is done only from the first position
           on the line to be deleted.  Versions of iiiillll1111 and ddddllll1111 which
           take a single parameter and insert or delete that many lines
           can be given as iiiillll and ddddllll.  If the terminal has a settable
           scrolling region (like the vt100) the command to set this
           can be described with the ccccssssrrrr 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 sssscccc and rrrrcccc (save and
           restore cursor) commands are also useful.  Inserting lines
           at the top or bottom of the screen can also be done using rrrriiii
           or iiiinnnndddd 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 wwwwiiiinnnndddd.  The four parameters are the
           starting and ending lines in memory and the starting and
           ending columns in memory, in that order.

           If the terminal can retain display memory above, then the ddddaaaa
           capability should be given; if display memory can be
           retained below, then ddddbbbb should be given.  These indicate
           that deleting a line or scrolling may bring non-blank lines



      Page 11                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           up from below or that scrolling back with rrrriiii may bring down
           non-blank lines.

           IIIInnnnsssseeeerrrrtttt////DDDDeeeelllleeeetttteeee CCCChhhhaaaarrrraaaacccctttteeeerrrr

           There are two basic kinds of intelligent terminals with
           respect to insert/delete character which can be described
           using _t_e_r_m_i_n_f_o. 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 and 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, you have the second
           type of terminal, and should give the capability iiiinnnn, which
           stands for insert null.  While these are two logically
           separate attributes (one line vs. multiline insert mode, and
           special treatment of untyped spaces) we have seen no
           terminals whose insert mode cannot be described with the
           single attribute.

           Terminfo can describe both terminals which have an insert
           mode, and terminals which send a simple sequence to open a
           blank position on the current line.  Give as ssssmmmmiiiirrrr the
           sequence to get into insert mode.  Give as rrrrmmmmiiiirrrr the sequence
           to leave insert mode.  Now give as iiiicccchhhh1111 any sequence needed
           to be sent just before sending the character to be inserted.
           Most terminals with a true insert mode will not give iiiicccchhhh1111;
           terminals which send a sequence to open a screen position
           should give it here.  (If your terminal has both, insert
           mode is usually preferable to iiiicccchhhh1111.  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 iiiipppp (a string option).  Any other
           sequence which may need to be sent after an insert of a
           single character may also be given in iiiipppp.  If your terminal
           needs both to be placed into an `insert mode' and a special
           code to precede each inserted character, then both ssssmmmmiiiirrrr/rrrrmmmmiiiirrrr
           and iiiicccchhhh1111 can be given, and both will be used.  The iiiicccchhhh
           capability, with one parameter, _n, will repeat the effects
           of iiiicccchhhh1111 _n times.



      Page 12                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           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 mmmmiiiirrrr to speed up inserting in this case.  Omitting
           mmmmiiiirrrr will affect only speed.   Some terminals (notably
           Datamedia's) must not have mmmmiiiirrrr because of the way their
           insert mode works.

           Finally, you can specify ddddcccchhhh1111 to delete a single character,
           ddddcccchhhh with one parameter, _n, to delete _n _c_h_a_r_a_c_t_e_r_s, and
           delete mode by giving ssssmmmmddddcccc and rrrrmmmmddddcccc to enter and exit delete
           mode (any mode the terminal needs to be placed in for ddddcccchhhh1111
           to work).

           A command to erase _n characters (equivalent to outputting _n
           blanks without moving the cursor) can be given as eeeecccchhhh with
           one parameter.

           HHHHiiiigggghhhhlllliiiigggghhhhttttiiiinnnngggg,,,, UUUUnnnnddddeeeerrrrlllliiiinnnniiiinnnngggg,,,, aaaannnndddd VVVViiiissssiiiibbbblllleeee BBBBeeeellllllllssss

           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
           _s_t_a_n_d_o_u_t _m_o_d_e, 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 ssssmmmmssssoooo
           and rrrrmmmmssssoooo, respectively.  If the code to change into or out
           of standout mode leaves one or even two blank spaces on the
           screen, as the TVI 912 and Teleray 1061 do, then xxxxmmmmcccc should
           be given to tell how many spaces are left.

           Codes to begin underlining and end underlining can be given
           as ssssmmmmuuuullll and rrrrmmmmuuuullll respectively.  If the terminal has a code
           to underline the current character and move the cursor one
           space to the right, such as the Microterm Mime, this can be
           given as uuuucccc.

           Other capabilities to enter various highlighting modes
           include bbbblllliiiinnnnkkkk (blinking) bbbboooolllldddd (bold or extra bright) ddddiiiimmmm
           (dim or half-bright) iiiinnnnvvvviiiissss (blanking or invisible text) pppprrrrooootttt
           (protected) rrrreeeevvvv (reverse video) ssssggggrrrr0000 (turn off _a_l_l attribute
           modes) ssssmmmmaaaaccccssss (enter alternate character set mode) and rrrrmmmmaaaaccccssss
           (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
           modes, this should be given as ssssggggrrrr (set attributes), taking
           9 parameters.  Each parameter is either 0 or 1, as the
           corresponding attribute is on or off.  The 9 parameters are,



      Page 13                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           in order:  standout, underline, reverse, blink, dim, bold,
           blank, protect, alternate character set.  Not all modes need
           be supported by ssssggggrrrr, only those for which corresponding
           separate attribute commands exist.

           Terminals with the ``magic cookie'' glitch (xxxxmmmmcccc) deposit
           special ``cookies'' when they receive mode-setting
           sequences, which affect the display algorithm rather than
           having extra bits for each character.  Some terminals, such
           as the HP 2621, automatically leave standout mode when they
           move to a new line or the cursor is addressed.  Programs
           using standout mode should exit standout mode before moving
           the cursor or sending a newline, unless the mmmmssssggggrrrr capability,
           asserting that it is safe to move in standout mode, is
           present.

           If the terminal has a way of flashing the screen to indicate
           an error quietly (a bell replacement) then this can be given
           as ffffllllaaaasssshhhh; 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 make, for example, a non-
           blinking underline into an easier to find block or blinking
           underline) give this sequence as ccccvvvvvvvviiiissss.  If there is a way
           to make the cursor completely invisible, give that as cccciiiivvvviiiissss.
           The capability ccccnnnnoooorrrrmmmm should be given which undoes the
           effects of both of these modes.

           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 ssssmmmmccccuuuupppp and rrrrmmmmccccuuuupppp.  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 one screen-sized window must be fixed
           into the terminal for cursor addressing to work properly.
           This is also used for the TEKTRONIX 4025, where ssssmmmmccccuuuupppp sets
           the command character to be the one used by terminfo.

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











      Page 14                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           KKKKeeeeyyyyppppaaaadddd

           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 (this applies, for example, to the unshifted
           HP 2621 keys).  If the keypad can be set to transmit or not
           transmit, give these codes as ssssmmmmkkkkxxxx and rrrrmmmmkkkkxxxx.  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 kkkkccccuuuubbbb1111,,,, kkkkccccuuuuffff1111,,,, kkkkccccuuuuuuuu1111,,,, kkkkccccuuuudddd1111,,,, and kkkkhhhhoooommmmeeee
           respectively.  If there are function keys such as f0, f1,
           ..., f10, the codes they send can be given as kkkkffff0000,,,, kkkkffff1111,,,, ............,,,,
           kkkkffff11110000.  If these keys have labels other than the default f0
           through f10, the labels can be given as llllffff0000,,,, llllffff1111,,,, ............,,,, llllffff11110000.
           The codes transmitted by certain other special keys can be
           given:  kkkkllllllll (home down), kkkkbbbbssss (backspace), kkkkttttbbbbcccc (clear all
           tabs), kkkkccccttttaaaabbbb (clear the tab stop in this column), kkkkccccllllrrrr
           (clear screen or erase key), kkkkddddcccchhhh1111 (delete character), kkkkddddllll1111
           (delete line), kkkkrrrrmmmmiiiirrrr (exit insert mode), kkkkeeeellll (clear to end
           of line), kkkkeeeedddd (clear to end of screen), kkkkiiiicccchhhh1111 (insert
           character or enter insert mode), kkkkiiiillll1111 (insert line), kkkknnnnpppp
           (next page), kkkkpppppppp (previous page), kkkkiiiinnnndddd (scroll
           forward/down), kkkkrrrriiii (scroll backward/up), kkkkhhhhttttssss (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, the other
           five keys can be given as kkkkaaaa1111, kkkkaaaa3333, kkkkbbbb2222, kkkkcccc1111, and kkkkcccc3333.
           These keys are useful when the effects of a 3 by 3
           directional pad are needed.

           TTTTaaaabbbbssss aaaannnndddd IIIInnnniiiittttiiiiaaaalllliiiizzzzaaaattttiiiioooonnnn

           If the terminal has hardware tabs, the command to advance to
           the next tab stop can be given as hhhhtttt (usually control I).  A
           ``backtab'' command which moves leftward to the next tab
           stop can be given as ccccbbbbtttt.  By convention, if the teletype
           modes indicate that tabs are being expanded by the computer
           rather than being sent to the terminal, programs should not
           use hhhhtttt or ccccbbbbtttt even if they are present, since the user may
           not have the tab stops properly set.  If the terminal has
           hardware tabs which are initially set every _n spaces when
           the terminal is powered up, the numeric parameter iiiitttt is
           given, showing the number of spaces the tabs are set to.
           This is normally used by the _t_s_e_t command to determine
           whether to set the 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 terminfo
           description can assume that they are properly set.

           Other capabilities include iiiissss1111, iiiissss2222, and iiiissss3333, initialization
           strings for the terminal, iiiipppprrrroooogggg, the path name of a program
           to be run to initialize the terminal, and iiiiffff, the name of a



      Page 15                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           file containing long initialization strings.  These strings
           are expected to set the terminal into modes consistent with
           the rest of the terminfo description.  They are normally
           sent to the terminal, by the _t_s_e_t program, each time the
           user logs in.  They will be printed in the following order:
           iiiissss1111; iiiissss2222; setting tabs using ttttbbbbcccc and hhhhttttssss; iiiiffff; running the
           program iiiipppprrrroooogggg; and finally iiiissss3333.  Most initialization is done
           with iiiissss2222.  Special terminal modes can be set up without
           duplicating strings by putting the common sequences in iiiissss2222
           and special cases in iiiissss1111 and iiiissss3333.  A pair of sequences that
           does a harder reset from a totally unknown state can be
           analogously given as rrrrssss1111, rrrrssss2222, rrrrffff, and rrrrssss3333, analogous to iiiissss2222
           and iiiiffff.  These strings are output by the _r_e_s_e_t program,
           which is used when the terminal gets into a wedged state.
           Commands are normally placed in rrrrssss2222 and rrrrffff 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 iiiissss2222, 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 there are commands to set and clear tab stops, they can
           be given as ttttbbbbcccc (clear all tab stops) and hhhhttttssss (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 iiiissss2222 or iiiiffff.

           Delays

           Certain capabilities control padding in the teletype driver.
           These are primarily needed by hard copy terminals, and are
           used by the _t_s_e_t program to set teletype modes
           appropriately.  Delays embedded in the capabilities ccccrrrr, iiiinnnndddd,
           ccccuuuubbbb1111, ffffffff, and ttttaaaabbbb will cause the appropriate delay bits to
           be set in the teletype driver.  If ppppbbbb (padding baud rate) is
           given, these values can be ignored at baud rates below the
           value of ppppbbbb.

           MMMMiiiisssscccceeeellllllllaaaannnneeeeoooouuuussss

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

           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, into which one can cursor address normally (such as
           the Heathkit h19's 25th line, or the 24th line of a vt100
           which is set to a 23-line scrolling region), the capability
           hhhhssss should be given.  Special strings to go to the beginning



      Page 16                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           of the status line and to return from the status line can be
           given as ttttssssllll and ffffssssllll.  (ffffssssllll must leave the cursor position
           in the same place it was before ttttssssllll.  If necessary, the sssscccc
           and rrrrcccc strings can be included in ttttssssllll and ffffssssllll to get this
           effect.) The parameter ttttssssllll takes one parameter, which is the
           column number of the status line the cursor is to be moved
           to.  If escape sequences and other special commands, such as
           tab, work while in the status line, the flag eeeessssllllooookkkk can be
           given.  A string which turns off the status line (or
           otherwise erases its contents) should be given as ddddssssllll.  If
           the terminal has commands to save and restore the position
           of the cursor, give them as sssscccc and rrrrcccc.  The status line is
           normally assumed to be the same width as the rest of the
           screen, e.g., ccccoooollllssss.  If the status line is a different width
           (possibly because the terminal does not allow an entire line
           to be loaded) the width, in columns, can be indicated with
           the numeric parameter wwwwssssllll.

           If the terminal can move up or down half a line, this can be
           indicated with hhhhuuuu (half-line up) and hhhhdddd (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 ffffffff (usually control L).

           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 rrrreeeepppp.  The first parameter is the
           character to be repeated and the second is the number of
           times to repeat it.  Thus, tparm(repeat_char, 'x', 10) is
           the same as `xxxxxxxxxx'.

           If the terminal has a settable command character, such as
           the TEKTRONIX 4025, this can be indicated with ccccmmmmddddcccchhhh.  A
           prototype command character is chosen which is used in all
           capabilities.  This character is given in the ccccmmmmddddcccchhhh
           capability to identify it.  The following convention is
           supported on some UNIX systems:  The environment is to be
           searched for a CCCCCCCC variable, and if found, all occurrences of
           the prototype character are replaced with the character in
           the environment variable.

           Terminal descriptions that do not represent a specific kind
           of known terminal, such as _s_w_i_t_c_h, _d_i_a_l_u_p, _p_a_t_c_h, and
           _n_e_t_w_o_r_k, should include the ggggnnnn (generic) capability so that
           programs can complain that they do not know how to talk to
           the terminal.  (This capability does not apply to _v_i_r_t_u_a_l
           terminal descriptions for which the escape sequences are
           known.)

           If the terminal uses xon/xoff handshaking for flow control,
           give xxxxoooonnnn.  Padding information should still be included so



      Page 17                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



           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, this
           fact can be indicated with kkkkmmmm.  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 ssssmmmmmmmm and rrrrmmmmmmmm.

           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 llllmmmm.  A value of llllmmmm#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
           virtual terminal protocol, the terminal number can be given
           as vvvvtttt.

           Media copy strings which control an auxiliary printer
           connected to the terminal can be given as mmmmcccc0000:  print the
           contents of the screen, mmmmcccc4444:  turn off the printer, and mmmmcccc5555:
           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 mmmmcccc5555pppp 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
           mmmmcccc4444, is transparently passed to the printer while an mmmmcccc5555pppp is
           in effect.

           Strings to program function keys can be given as ppppffffkkkkeeeeyyyy,
           ppppfffflllloooocccc, and ppppffffxxxx.  Each of these strings takes two parameters:
           the function key number to program (from 0 to 10) and the
           string to program it with.  Function key numbers out of this
           range may program undefined keys in a terminal dependent
           manner.  The difference between the capabilities is that
           ppppffffkkkkeeeeyyyy causes pressing the given key to be the same as the
           user typing the given string; ppppfffflllloooocccc causes the string to be
           executed by the terminal in local; and ppppffffxxxx causes the string
           to be transmitted to the computer.

           GGGGlllliiiittttcccchhhheeeessss aaaannnndddd BBBBrrrraaaaiiiinnnnddddaaaammmmaaaaggggeeee

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

           Terminals which ignore a linefeed immediately after an aaaammmm
           wrap, such as the Concept and vt100, should indicate xxxxeeeennnnllll.




      Page 18                                                  (9010-E)






      TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))                 ((((UUUUNNNNIIIIXXXX 5555....2222))))                TTTTEEEERRRRMMMMIIIINNNNFFFFOOOO((((4444))))



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

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

           The Beehive Superbee, which is unable to correctly transmit
           the escape or control C characters, has xxxxssssbbbb, indicating that
           the f1 key is used for escape and f2 for control C.  (Only
           certain Superbees have this problem, depending on the ROM.)

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

           SSSSiiiimmmmiiiillllaaaarrrr TTTTeeeerrrrmmmmiiiinnnnaaaallllssss

           If there are two very similar terminals, one can be defined
           as being just like the other with certain exceptions.  The
           string capability uuuusssseeee can be given with the name of the
           similar terminal.  The capabilities given before uuuusssseeee
           override those in the terminal type invoked by uuuusssseeee.  A
           capability can be cancelled by placing xxxxxxxx@@@@ to the left of
           the capability definition, where xx is the capability.  For
           example, the entry

                2621-nl, smkx@, rmkx@, use=2621,

           defines a 2621-nl that does not have the ssssmmmmkkkkxxxx or rrrrmmmmkkkkxxxx
           capabilities, and 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 preferences.

      FFFFIIIILLLLEEEESSSS
           /usr/lib/terminfo/?/*    files containing terminal
           descriptions

      SSSSEEEEEEEE AAAALLLLSSSSOOOO
           tic(1), curses(3X), printf(3S), term(4), term(5).













      Page 19                                                  (9010-E)



