Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
terminfo(4)			 File Formats			   terminfo(4)

       terminfo	- terminal and printer capability database


       The  terminfo  database	describes  the capabilities of devices such as
       terminals and printers. Devices are described in	terminfo source	 files
       by  specifying a	set of capabilities, by	quantifying certain aspects of
       the device, and by specifying character sequences that affect  particu-
       lar  results.  This  database is	often used by screen oriented applica-
       tions such as vi	and curses-based programs, as well as by  some	system
       commands	such as	ls and more. This usage	allows them to work with a va-
       riety of	devices	without	changes	to the programs.

       terminfo	descriptions are located in the	directory pointed  to  by  the
       environment  variable  TERMINFO or in /usr/share/lib/terminfo. terminfo
       descriptions are	generated by tic(1M).

       terminfo	source files consist of	one or more device descriptions.  Each
       description  consists  of  a  header (beginning in column 1) and	one or
       more lines that list the	features for  that  particular	device.	 Every
       line in a terminfo source file must end in a comma (,). Every line in a
       terminfo	source file except the header must be  indented	 with  one  or
       more white spaces (either spaces	or tabs).

       Entries in terminfo source files	consist	of a number of comma-separated
       fields. White space after each comma is ignored.	Embedded  commas  must
       be  escaped  by	using a	backslash. Each	device entry has the following

       alias1 |	alias2 | ... | aliasn |	fullname,
		capability1, capability2,

       The first line, commonly	referred to as the header line,	must begin  in
       column  one and must contain at least two aliases separated by vertical
       bars. The last field in the header line must be the  long name  of  the
       device and it may contain any string. Alias names must be unique	in the
       terminfo	database and they must conform to system file naming   conven-
       tions.  See  tic(1M).  They cannot, for example,	contain	white space or

       Every device must be assigned a name, such  as  "vt100".	 Device	 names
       (except	the  long  name)  should be chosen using the following conven-
       tions. The name should not contain hyphens  because  hyphens  are   re-
       served for use when adding suffixes that	indicate special modes.

       These  special  modes may be modes that the hardware can	be in, or user
       preferences. To assign a	special	mode to	a particular device, append  a
       suffix  consisting  of a	hyphen and an indicator	of the mode to the de-
       vice name. For example, the -w suffix means "wide mode".	  When	speci-
       fied,  it  allows for a width of	132 columns instead of the standard 80
       columns.	Therefore, if you want to use a	"vt100"	 device	 set  to  wide
       mode,  name the device "vt100-w". Use the following suffixes where pos-

	    Suffix		    Meaning		    Example
	    -w	      Wide mode	(more than 80 columns)	    5410-w
	    -am	      With  auto.  margins  (usually  de-   vt100-am
	    -nam      Without automatic	margins		    vt100-nam
	    -n	      Number of	lines on the screen	    2300-40
	    -na	      No arrow keys (leave them	in local)   c100-na
	    -np	      Number of	pages of memory		    c100-4p
	    -rv	      Reverse video			    4415-rv

       The terminfo reference manual page is organized in two sections:



       Capabilities  in	 terminfo  are	of  three types:  Boolean capabilities
       (which show that	a device has or	does not have a	 particular  feature),
       numeric	capabilities (which quantify particular	features of a device),
       and string capabilities (which provide sequences	that can  be  used  to
       perform particular operations on	devices).

       In  the following table,	a Variable is the name by which	a C programmer
       accesses	a capability (at the terminfo level). A	Capname	is  the	 short
       name  for  a  capability	 specified in the terminfo source file.	 It is
       used by a person	updating the source file and by	the  tput  command.  A
       Termcap	Code  is a two-letter sequence that corresponds	to the termcap
       capability name.	(Note that termcap is no longer	supported.)

       Capability names	have no	real length limit, but an  informal  limit  of
       five characters has been	adopted	to keep	them short. Whenever possible,
       capability names	are chosen to be the same as or	similar	to those spec-
       ified  by  the ANSI X3.64-1979 standard.	Semantics are also intended to
       match those of the ANSI standard.

       All string capabilities listed below may	have padding  specified,  with
       the exception of	those used for input. Input capabilities, listed under
       the Strings section in the following tables, have names beginning  with
       key_.  The  #i  symbol in the description field of the following	tables
       refers to the ith parameter.

				 Cap-	Termcap
       Variable			 name	Code	 Description

       auto_left_margin		 bw	bw	 cub1 wraps from column	0 to
						 last column
       auto_right_margin	 am	am	 Terminal has automatic	margins
       back_color_erase		 bce	be	 Screen	erased with background
       can_change		 ccc	cc	 Terminal can re-define	existing
       ceol_standout_glitch	 xhp	xs	 Standout not erased by
						 overwriting (hp)
       col_addr_glitch		 xhpa	YA	 Only positive motion
						 for hpa/mhpa caps
       cpi_changes_res		 cpix	YF	 Changing character pitch
						 changes resolution
       cr_cancels_micro_mode	 crxm	YB	 Using cr turns	off micro mode
       dest_tabs_magic_smso	 xt	xt	 Destructive tabs, magic
						 smso char (t1061)
       eat_newline_glitch	 xenl	xn	 Newline ignored after
						 80 columns (Concept)
       erase_overstrike		 eo	eo	 Can erase overstrikes with a
       generic_type		 gn	gn	 Generic line type
						 (for example, dialup, switch)
       hard_copy		 hc	hc	 Hardcopy terminal
       hard_cursor		 chts	HC	 Cursor	is hard	to see
       has_meta_key		 km	km	 Has a meta key	(shift,
						 sets parity bit)
       has_print_wheel		 daisy	YC	 Printer needs operator
						 to change character set
       has_status_line		 hs	hs	 Has extra "status line"
       hue_lightness_saturation	 hls	hl	 Terminal uses only HLS
						 color notation	(Tektronix)
       insert_null_glitch	 in	in	 Insert	mode distinguishes nulls
       lpi_changes_res		 lpix	YG	 Changing line pitch
						 changes resolution
       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
       move_standout_mode	 msgr	ms	 Safe to move in standout modes
       needs_xon_xoff		 nxon	nx	 Padding won't work,
						 xon/xoff required
       no_esc_ctlc		 xsb	xb	 Beehive (f1=escape, f2=ctrl C)
       no_pad_char		 npc	NP	 Pad character doesn't exist
       non_dest_scroll_region	 ndscr	ND	 Scrolling region
						 is nondestructive
       non_rev_rmcup		 nrrmc	NR	 smcup does not	reverse	rmcup
       over_strike		 os	os	 Terminal overstrikes
						 on hard-copy terminal
       prtr_silent		 mc5i	5i	 Printer won't echo on screen
       row_addr_glitch		 xvpa	YD	 Only positive motion
						 for vpa/mvpa caps
       semi_auto_right_margin	 sam	YE	 Printing in last column causes
       status_line_esc_ok	 eslok	es	 Escape	can be used on
						 the status line
       tilde_glitch		 hz	hz	 Hazeltine; can't print	tilde (~)
       transparent_underline	 ul	ul	 Underline character overstrikes
       xon_xoff			 xon	xo	 Terminal uses xon/xoff

			     Cap-    Termcap
       Variable		     name    Code     Description

       bit_image_entwining   bitwin  Yo	      Number of	passes for each
					      bit-map row
       bit_image_type	     bitype  Yp	      Type of bit image	device
       buffer_capacity	     bufsz   Ya	      Number of	bytes buffered
					      before printing
       buttons		     btns    BT	      Number of	buttons	on the mouse
       columns		     cols    co	      Number of	columns	in a line
       dot_horz_spacing	     spinh   Yc	      Spacing of dots horizontally
					      in dots per inch
       dot_vert_spacing	     spinv   Yb	      Spacing of pins vertically
					      in pins per inch
       init_tabs	     it	     it	      Tabs initially every # spaces
       label_height	     lh	     lh	      Number of	rows in	each label
       label_width	     lw	     lw	      Number of	columns	in each	label
       lines		     lines   li	      Number of	lines on a screen or
					      a	page
       lines_of_memory	     lm	     lm	      Lines of memory if > lines;
					      0	means varies
       max_attributes	     ma	     ma	      Maximum combined video attributes
					      terminal can display
       magic_cookie_glitch   xmc     sg	      Number of	blank characters
					      left by smso or rmso
       max_colors	     colors  Co	      Maximum number of	colors
					      on the screen
       max_micro_address     maddr   Yd	      Maximum value in
       max_micro_jump	     mjump   Ye	      Maximum value in parm_..._micro
       max_pairs	     pairs   pa	      Maximum number of
					      color-pairs on the screen
       maximum_windows	     Wnum    MW	      Maximum number of	definable windows
       micro_char_size	     mcs     Yf	      Character	step size when
					      in micro mode
       micro_line_size	     mls     Yg	      Line step	size when in micro mode
       no_color_video	     ncv     NC	      Video attributes that
					      can't be used with colors
       num_labels	     nlab    Nl	      Number of	labels on screen
       number_of_pins	     npins   Yh	      Number of	pins in	print-head
       output_res_char	     orc     Yi	      Horizontal resolution in
					      units per	character
       output_res_line	     orl     Yj	      Vertical resolution in units per
       output_res_horz_inch  orhi    Yk	      Horizontal resolution in
					      units per	inch
       output_res_vert_inch  orvi    Yl	      Vertical resolution in
					      units per	inch
       padding_baud_rate     pb	     pb	      Lowest baud rate
       print_rate	     cps     Ym	      Print rate in characters per second
					      where padding needed
       virtual_terminal	     vt	     vt	      Virtual terminal number (system)
       wide_char_size	     widcs   Yn	      Character	step size when
					      in double	wide mode
       width_status_line     wsl     ws	      Number of	columns	in status line

				  Cap-	 Termcap
       Variable			  name	 Code	  Description

       acs_chars		  acsc	 ac	  Graphic charset pairs	aAbBcC
       alt_scancode_esc		  scesa	 S8	  Alternate escape for
						  scancode emulation
						  (default is for vt100)
       back_tab			  cbt	 bt	  Back tab
       bell			  bel	 bl	  Audible signal (bell)
       bit_image_carriage_return  bicr	 Yv	  Move to beginning of
						  same row (use	tparm)
       bit_image_newline	  binel	 Zz	  Move to next row of
						  the bit image	(use tparm)
       bit_image_repeat		  birep	 Zy	  Repeat bit-image cell
						  #1 #2	times (use tparm)
       carriage_return		  cr	 cr	  Carriage return
       change_char_pitch	  cpi	 ZA	  Change number	of
						  characters per inch
       change_line_pitch	  lpi	 ZB	  Change number	of lines per inch
       change_res_horz		  chr	 ZC	  Change horizontal resolution
       change_res_vert		  cvr	 ZD	  Change vertical resolution
       change_scroll_region	  csr	 cs	  Change to lines #1
						  through #2 (vt100)
       char_padding		  rmp	 rP	  Like ip but when in replace
       char_set_names		  csnm	 Zy	  List of character set	names
       clear_all_tabs		  tbc	 ct	  Clear	all tab	stops
       clear_margins		  mgc	 MC	  Clear	all margins
						  (top,	bottom,	and sides)
       clear_screen		  clear	 cl	  Clear	screen and home	cursor
       clr_bol			  el1	 cb	  Clear	to beginning of
						  line,	inclusive
       clr_eol			  el	 ce	  Clear	to end of line
       clr_eos			  ed	 cd	  Clear	to end of display
       code_set_init		  csin	 ci	  Init sequence
						  for multiple codesets
       color_names		  colornm  Yw	  Give name for	color #1
       column_address		  hpa	 ch	  Horizontal position
       command_character	  cmdch	 CC	  Terminal settable cmd
						  character in prototype
       create_window		  cwin	 CW	  Define win #1	to go
						  from #2,#3to #4,#5
       cursor_address		  cup	 cm	  Move to row #1 col #2
       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 left one	space.
       cursor_mem_address	  mrcup	 CM	  Memory relative cursor
       cursor_normal		  cnorm	 ve	  Make cursor appear
						  normal (undo vs/vi)
       cursor_right		  cuf1	 nd	  Non-destructive space
						  (cursor or carriage 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
       define_bit_image_region	  defbi	 Yx	  Define rectangular bit-
						  image	region (use tparm)
       define_char		  defc	 ZE	  Define a character in
						  a character set
       delete_character		  dch1	 dc	  Delete character
       delete_line		  dl1	 dl	  Delete line
       device_type		  devt	 dv	  Indicate language/
						  codeset support
       dial_phone		  dial	 DI	  Dial phone number #1
       dis_status_line		  dsl	 ds	  Disable status line
       display_clock		  dclk	 DK	  Display time-of-day clock
       display_pc_char		  dispc	 S1	  Display PC character
       down_half_line		  hd	 hd	  Half-line down (forward
						  1/2 linefeed)
       ena_acs			  enacs	 eA	  Enable alternate character set
       end_bit_image_region	  endbi	 Yy	  End a	bit-image region
						  (use tparm)
       enter_alt_charset_mode	  smacs	 as	  Start	alternate character set
       enter_am_mode		  smam	 SA	  Turn on automatic margins
       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_doublewide_mode	  swidm	 ZF	  Enable double	wide printing
       enter_draft_quality	  sdrfq	 ZG	  Set draft quality print mode
       enter_insert_mode	  smir	 im	  Insert mode (enter)
       enter_italics_mode	  sitm	 ZH	  Enable italics
       enter_leftward_mode	  slm	 ZI	  Enable leftward carriage
       enter_micro_mode		  smicm	 ZJ	  Enable micro motion
       enter_near_letter_quality  snlq	 ZK	  Set near-letter quality print
       enter_normal_quality	  snrmq	 ZL	  Set normal quality
       enter_pc_charset_mode	  smpch	 S2	  Enter	PC character display mode
       enter_protected_mode	  prot	 mp	  Turn on protected mode
       enter_reverse_mode	  rev	 mr	  Turn on reverse video	mode
       enter_scancode_mode	  smsc	 S4	  Enter	PC scancode mode
       enter_scancode_mode	  smsc	 S4	  Enter	PC scancode mode
       enter_secure_mode	  invis	 mk	  Turn on blank	mode
						  (characters invisible)
       enter_shadow_mode	  sshm	 ZM	  Enable shadow	printing
       enter_standout_mode	  smso	 so	  Begin	standout mode
       enter_subscript_mode	  ssubm	 ZN	  Enable subscript printing
       enter_superscript_mode	  ssupm	 ZO	  Enable superscript printing
       enter_underline_mode	  smul	 us	  Start	underscore mode
       enter_upward_mode	  sum	 ZP	  Enable upward	carriage motion
       enter_xon_mode		  smxon	 SX	  Turn on xon/xoff handshaking
       erase_chars		  ech	 ec	  Erase	#1 characters
       exit_alt_charset_mode	  rmacs	 ae	  End alternate	character set
       exit_am_mode		  rmam	 RA	  Turn off automatic margins
       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_doublewide_mode	  rwidm	 ZQ	  Disable double wide printing
       exit_insert_mode		  rmir	 ei	  End insert mode
       exit_italics_mode	  ritm	 ZR	  Disable italics
       exit_leftward_mode	  rlm	 ZS	  Enable rightward (normal)
						  carriage motion
       exit_micro_mode		  rmicm	 ZT	  Disable micro	motion
       exit_pc_charset_mode	  rmpch	 S3	  Disable PC character
						  display mode
       exit_scancode_mode	  rmsc	 S5	  Disable PC scancode mode
       exit_shadow_mode		  rshm	 ZU	  Disable shadow printing
       exit_standout_mode	  rmso	 se	  End standout mode
       exit_subscript_mode	  rsubm	 ZV	  Disable subscript printing
       exit_superscript_mode	  rsupm	 ZW	  Disable superscript printing
       exit_underline_mode	  rmul	 ue	  End underscore mode
       exit_upward_mode		  rum	 ZX	  Enable downward (normal)
						  carriage motion
       exit_xon_mode		  rmxon	 RX	  Turn off xon/xoff handshaking
       fixed_pause		  pause	 PA	  Pause	for 2-3	seconds
       flash_hook		  hook	 fh	  Flash	the switch hook
       flash_screen		  flash	 vb	  Visible bell (may
						  not move cursor)
       form_feed		  ff	 ff	  Hardcopy terminal page eject
       from_status_line		  fsl	 fs	  Return from status line
       get_mouse		  getm	 Gm	  Curses should	get button events
       goto_window		  wingo	 WG	  Go to	window #1
       hangup			  hup	 HU	  Hang-up phone
       init_1string		  is1	 i1	  Terminal or printer
						  initialization string
       init_2string		  is2	 is	  Terminal or printer
						  initialization string
       init_3string		  is3	 i3	  Terminal or printer
						  initialization string
       init_file		  if	 if	  Name of initialization file
       init_prog		  iprog	 iP	  Path name of program
						  for initialization
       initialize_color		  initc	 Ic	  Initialize the
						  definition of	color
       initialize_pair		  initp	 Ip	  Initialize color-pair
       insert_character		  ich1	 ic	  Insert character
       insert_line		  il1	 al	  Add new blank	line
       insert_padding		  ip	 ip	  Insert pad after
						  character inserted

       The ``key_'' strings are	sent by	specific keys. The  ``key_''  descrip-
       tions  include  the macro, defined in <curses.h>, for the code returned
       by  the	curses	routine	 getch	when   the   key   is	pressed	  (see

			       Cap-    Termcap
       Variable		       name    Code	Description

       key_a1		       ka1     K1	KEY_A1,	upper left of keypad
       key_a3		       ka3     K3	KEY_A3,	upper right of keypad
       key_b2		       kb2     K2	KEY_B2,	center of keypad
       key_backspace	       kbs     kb	KEY_BACKSPACE, sent by
						backspace key
       key_beg		       kbeg    @1	KEY_BEG, sent by beg(inning) key
       key_btab		       kcbt    kB	KEY_BTAB, sent by back-tab key
       key_c1		       kc1     K4	KEY_C1,	lower left of keypad
       key_c3		       kc3     K5	KEY_C3,	lower right of keypad
       key_cancel	       kcan    @2	KEY_CANCEL, sent by cancel key
       key_catab	       ktbc    ka	KEY_CATAB, sent	by
						clear-all-tabs key
       key_clear	       kclr    kC	KEY_CLEAR, sent	by
						clear-screen or	erase key
       key_close	       kclo    @3	KEY_CLOSE, sent	by close key
       key_command	       kcmd    @4	KEY_COMMAND, sent by
						cmd (command) key
       key_copy		       kcpy    @5	KEY_COPY, sent by copy key
       key_create	       kcrt    @6	KEY_CREATE, sent by create key
       key_ctab		       kctab   kt	KEY_CTAB, sent by clear-tab key
       key_dc		       kdch1   kD	KEY_DC,	sent by	delete-character
       key_dl		       kdl1    kL	KEY_DL,	sent by	delete-line key
       key_down		       kcud1   kd	KEY_DOWN, sent by terminal
						down-arrow key
       key_eic		       krmir   kM	KEY_EIC, sent by rmir or smir in
						insert mode
       key_end		       kend    @7	KEY_END, sent by end key
       key_enter	       kent    @8	KEY_ENTER, sent	by enter/send
       key_eol		       kel     kE	KEY_EOL, sent by
						clear-to-end-of-line key
       key_eos		       ked     kS	KEY_EOS, sent by
						clear-to-end-of-screen key
       key_exit		       kext    @9	KEY_EXIT, sent by exit key
       key_f0		       kf0     k0	KEY_F(0), sent by function key f0
       key_f1		       kf1     k1	KEY_F(1), sent by function key f1
       key_f2		       kf2     k2	KEY_F(2), sent by function key f2
       key_f3		       kf3     k3	KEY_F(3), sent by function key f3
       key_fB		       kf4     k4	KEY_F(4), sent by function key fB
       key_f5		       kf5     k5	KEY_F(5), sent by function key f5
       key_f6		       kf6     k6	KEY_F(6), sent by function key f6
       key_f7		       kf7     k7	KEY_F(7), sent by function key f7
       key_f8		       kf8     k8	KEY_F(8), sent by function key f8
       key_f9		       kf9     k9	KEY_F(9), sent by function key f9

       key_f10		       kf10    k;	KEY_F(10), sent	by function key
       key_f11		       kf11    F1	KEY_F(11), sent	by function key
       key_f12		       kf12    F2	KEY_F(12), sent	by function key
       key_f13		       kf13    F3	KEY_F(13), sent	by function key
       key_f14		       kf14    F4	KEY_F(14), sent	by function key
       key_f15		       kf15    F5	KEY_F(15), sent	by function key
       key_f16		       kf16    F6	KEY_F(16), sent	by function key
       key_f17		       kf17    F7	KEY_F(17), sent	by function key
       key_f18		       kf18    F8	KEY_F(18), sent	by function key
       key_f19		       kf19    F9	KEY_F(19), sent	by function key
       key_f20		       kf20    FA	KEY_F(20), sent	by function key
       key_f21		       kf21    FB	KEY_F(21), sent	by function key
       key_f22		       kf22    FC	KEY_F(22), sent	by function key
       key_f23		       kf23    FD	KEY_F(23), sent	by function key
       key_f24		       kf24    FE	KEY_F(24), sent	by function key
       key_f25		       kf25    FF	KEY_F(25), sent	by function key
       key_f26		       kf26    FG	KEY_F(26), sent	by function key
       key_f27		       kf27    FH	KEY_F(27), sent	by function key
       key_f28		       kf28    FI	KEY_F(28), sent	by function key
       key_f29		       kf29    FJ	KEY_F(29), sent	by function key
       key_f30		       kf30    FK	KEY_F(30), sent	by function key
       key_f31		       kf31    FL	KEY_F(31), sent	by function key
       key_f32		       kf32    FM	KEY_F(32), sent	by function key
       key_f33		       kf33    FN	KEY_F(13), sent	by function key
       key_f34		       kf34    FO	KEY_F(34), sent	by function key
       key_f35		       kf35    FP	KEY_F(35), sent	by function key
       key_f36		       kf36    FQ	KEY_F(36), sent	by function key
       key_f37		       kf37    FR	KEY_F(37), sent	by function key
       key_f38		       kf38    FS	KEY_F(38), sent	by function key
       key_f39		       kf39    FT	KEY_F(39), sent	by function key
       key_fB0		       kf40    FU	KEY_F(40), sent	by function key
       key_fB1		       kf41    FV	KEY_F(41), sent	by function key
       key_fB2		       kf42    FW	KEY_F(42), sent	by function key
       key_fB3		       kf43    FX	KEY_F(43), sent	by function key
       key_fB4		       kf44    FY	KEY_F(44), sent	by function key
       key_fB5		       kf45    FZ	KEY_F(45), sent	by function key
       key_fB6		       kf46    Fa	KEY_F(46), sent	by function key
       key_fB7		       kf47    Fb	KEY_F(47), sent	by function key
       key_fB8		       kf48    Fc	KEY_F(48), sent	by function key
       key_fB9		       kf49    Fd	KEY_F(49), sent	by function key
       key_f50		       kf50    Fe	KEY_F(50), sent	by function key
       key_f51		       kf51    Ff	KEY_F(51), sent	by function key
       key_f52		       kf52    Fg	KEY_F(52), sent	by function key
       key_f53		       kf53    Fh	KEY_F(53), sent	by function key
       key_f54		       kf54    Fi	KEY_F(54), sent	by function key
       key_f55		       kf55    Fj	KEY_F(55), sent	by function key
       key_f56		       kf56    Fk	KEY_F(56), sent	by function key
       key_f57		       kf57    Fl	KEY_F(57), sent	by function key
       key_f58		       kf58    Fm	KEY_F(58), sent	by function key
       key_f59		       kf59    Fn	KEY_F(59), sent	by function key
       key_f60		       kf60    Fo	KEY_F(60), sent	by function key
       key_f61		       kf61    Fp	KEY_F(61), sent	by function key
       key_f62		       kf62    Fq	KEY_F(62), sent	by function key
       key_f63		       kf63    Fr	KEY_F(63), sent	by function key
       key_find		       kfnd    @0	KEY_FIND, sent by find key
       key_help		       khlp    %1	KEY_HELP, sent by help key
       key_home		       khome   kh	KEY_HOME, sent by home key
       key_ic		       kich1   kI	KEY_IC,	sent by	ins-char/enter
						ins-mode key
       key_il		       kil1    kA	KEY_IL,	sent by	insert-line key
       key_left		       kcub1   kl	KEY_LEFT, sent by
						terminal left-arrow key
       key_ll		       kll     kH	KEY_LL,	sent by	home-down key
       key_mark		       kmrk    %2	KEY_MARK, sent by
       key_message	       kmsg    %3	KEY_MESSAGE, sent by message key
       key_mouse	       kmous   Km	0631, Mouse event has occured
       key_move		       kmov    %4	KEY_MOVE, sent by move key
       key_next		       knxt    %5	KEY_NEXT, sent by next-object
       key_npage	       knp     kN	KEY_NPAGE, sent	by next-page
       key_open		       kopn    %6	KEY_OPEN, sent by open key
       key_options	       kopt    %7	KEY_OPTIONS, sent by options
       key_ppage	       kpp     kP	KEY_PPAGE, sent	by
						previous-page key
       key_previous	       kprv    %8	KEY_PREVIOUS, sent by
						previous-object	key
       key_print	       kprt    %9	KEY_PRINT, sent	by
						print or copy key
       key_redo		       krdo    %0	KEY_REDO, sent by redo key
       key_reference	       kref    &1	KEY_REFERENCE, sent by
						reference key
       key_refresh	       krfr    &2	KEY_REFRESH, sent by
						refresh	key
       key_replace	       krpl    &3	KEY_REPLACE, sent by
						replace	key
       key_restart	       krst    &4	KEY_RESTART, sent by
						restart	key
       key_resume	       kres    &5	KEY_RESUME, sent by resume key
       key_right	       kcuf1   kr	KEY_RIGHT, sent	by terminal
						right-arrow key
       key_save		       ksav    &6	KEY_SAVE, sent by save key
       key_sbeg		       kBEG    &9	KEY_SBEG, sent by
						shifted	beginning key
       key_scancel	       kCAN    &0	KEY_SCANCEL, sent by
						shifted	cancel key
       key_scommand	       kCMD    *1	KEY_SCOMMAND, sent by
						shifted	command	key
       key_scopy	       kCPY    *2	KEY_SCOPY, sent	by
						shifted	copy key
       key_screate	       kCRT    *3	KEY_SCREATE, sent by
						shifted	create key
       key_sdc		       kDC     *4	KEY_SDC, sent by
						shifted	delete-char key
       key_sdl		       kDL     *5	KEY_SDL, sent by
						shifted	delete-line key
       key_select	       kslt    *6	KEY_SELECT, sent by
						select key
       key_send		       kEND    *7	KEY_SEND, sent by
						shifted	end key
       key_seol		       kEOL    *8	KEY_SEOL, sent by
						shifted	clear-line key
       key_sexit	       kEXT    *9	KEY_SEXIT, sent	by
						shifted	exit key
       key_sf		       kind    kF	KEY_SF,	sent by
						scroll-forward/down key
       key_sfind	       kFND    *0	KEY_SFIND, sent	by
						shifted	find key
       key_shelp	       kHLP    #1	KEY_SHELP, sent	by
						shifted	help key
       key_shome	       kHOM    #2	KEY_SHOME, sent	by
						shifted	home key
       key_sic		       kIC     #3	KEY_SIC, sent by
						shifted	input key
       key_sleft	       kLFT    #4	KEY_SLEFT, sent	by
						shifted	left-arrow key
       key_smessage	       kMSG    %a	KEY_SMESSAGE, sent by
						shifted	message	key
       key_smove	       kMOV    %b	KEY_SMOVE, sent	by
						shifted	move key
       key_snext	       kNXT    %c	KEY_SNEXT, sent	by
						shifted	next key
       key_soptions	       kOPT    %d	KEY_SOPTIONS, sent by
						shifted	options	key
       key_sprevious	       kPRV    %e	KEY_SPREVIOUS, sent by
						shifted	prev key
       key_sprint	       kPRT    %f	KEY_SPRINT, sent by
						shifted	print key
       key_sr		       kri     kR	KEY_SR,	sent by
						scroll-backward/up key
       key_sredo	       kRDO    %g	KEY_SREDO, sent	by
						shifted	redo key
       key_sreplace	       kRPL    %h	KEY_SREPLACE, sent by
						shifted	replace	key
       key_sright	       kRIT    %i	KEY_SRIGHT, sent by shifted
						right-arrow key
       key_srsume	       kRES    %j	KEY_SRSUME, sent by
						shifted	resume key
       key_ssave	       kSAV    !1	KEY_SSAVE, sent	by
						shifted	save key
       key_ssuspend	       kSPD    !2	KEY_SSUSPEND, sent by
						shifted	suspend	key
       key_stab		       khts    kT	KEY_STAB, sent by
						set-tab	key
       key_sundo	       kUND    !3	KEY_SUNDO, sent	by
						shifted	undo key
       key_suspend	       kspd    &7	KEY_SUSPEND, sent by
						suspend	key
       key_undo		       kund    &8	KEY_UNDO, sent by undo key
       key_up		       kcuu1   ku	KEY_UP,	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_f2		       lf2     l2	Labels on function key
						f2 if not f2
       lab_f3		       lf3     l3	Labels on function key
						f3 if not f3
       lab_fB		       lfB     l4	Labels on function key
						fB if not fB
       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
       lab_f9		       lf9     l9	Labels on function key
						f9 if not f9
       lab_f10		       lf10    la	Labels on function key
						f10 if not f10
       label_format	       fln     Lf	Label format
       label_off	       rmln    LF	Turn off soft labels
       label_on		       smln    LO	Turn on	soft labels
       meta_off		       rmm     mo	Turn off "meta mode"
       meta_on		       smm     mm	Turn on	"meta mode" (8th bit)
       micro_column_address    mhpa    ZY	Like column_address
						for micro adjustment
       micro_down	       mcud1   ZZ	Like cursor_down
						for micro adjustment
       micro_left	       mcub1   Za	Like cursor_left
						for micro adjustment
       micro_right	       mcuf1   Zb	Like cursor_right
						for micro adjustment
       micro_row_address       mvpa    Zc	Like row_address
						for micro adjustment
       micro_up		       mcuu1   Zd	Like cursor_up
						for micro adjustment
       mouse_info	       minfo   Mi	Mouse status information
       newline		       nel     nw	Newline	(behaves like
						cr followed by lf)
       order_of_pins	       porder  Ze	Matches	software bits
						to print-head pins
       orig_colors	       oc      oc	Set all	color(-pair)s
						to the original	ones
       orig_pair	       op      op	Set default color-pair
						to the original	one
       pad_char		       pad     pc	Pad character (rather than null)
       parm_dch		       dch     DC	Delete #1 chars
       parm_delete_line	       dl      DL	Delete #1 lines
       parm_down_cursor	       cud     DO	Move down #1 lines
       parm_down_micro	       mcud    Zf	Like parm_down_cursor
						for micro adjust
       parm_ich		       ich     IC	Insert #1 blank	chars
       parm_index	       indn    SF	Scroll forward #1 lines
       parm_insert_line	       il      AL	Add #1 new blank lines
       parm_left_cursor	       cub     LE	Move cursor left #1 spaces
       parm_left_micro	       mcub    Zg	Like parm_left_cursor
						for micro adjust
       parm_right_cursor       cuf     RI	Move right #1 spaces
       parm_right_micro	       mcuf    Zh	Like parm_right_cursor
						for micro adjust
       parm_rindex	       rin     SR	Scroll backward	#1 lines
       parm_up_cursor	       cuu     UP	Move cursor up #1 lines
       parm_up_micro	       mcuu    Zi	Like parm_up_cursor
						for micro adjust
       pc_term_options	       pctrm   S6	PC terminal options
       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_plab	       pfxl    xl	Prog key #1 to xmit
						string #2 and show string #3
       pkey_xmit	       pfx     px	Prog funct key #1 to
						xmit string #2
       plab_norm	       pln     pn	Prog label #1 to show
						string #2
       print_screen	       mc0     ps	Print contents of the screen
       prtr_non		       mc5p    pO	Turn on	the printer for	#1 bytes
       prtr_off		       mc4     pf	Turn off the printer
       prtr_on		       mc5     po	Turn on	the printer
       pulse		       pulse   PU	Select pulse dialing
       quick_dial	       qdial   QD	Dial phone number #1, without
						progress detection
       remove_clock	       rmclk   RC	Remove time-of-day clock
       repeat_char	       rep     rp	Repeat char #1 #2 times
       req_for_input	       rfi     RF	Send next input	char (for ptys)
       req_mouse_pos	       reqmp   RQ	Request	mouse position report
       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
       save_cursor	       sc      sc	Save cursor position
       scancode_escape	       scesc   S7	Escape for scancode emulation
       scroll_forward	       ind     sf	Scroll text up
       scroll_reverse	       ri      sr	Scroll text down
       select_char_set	       scs     Zj	Select character set
       set0_des_seq	       s0ds    s0	Shift into codeset 0
						(EUC set 0, ASCII)
       set1_des_seq	       s1ds    s1	Shift into codeset 1
       set2_des_seq	       s2ds    s2	Shift into codeset 2
       set3_des_seq	       s3ds    s3	Shift into codeset 3
						attributes #1-#6
       set_a_background	       setab   AB	Set background color
						using ANSI escape
       set_a_foreground	       setaf   AF	Set foreground color
						using ANSI escape
       set_attributes	       sgr     sa	Define the video
						attributes #1-#9
       set_background	       setb    Sb	Set current background color
       set_bottom_margin       smgb    Zk	Set bottom margin at
						current	line
       set_bottom_margin_parm  smgbp   Zl	Set bottom margin at
						line #1	or #2
						lines from bottom
       set_clock	       sclk    SC	Set time-of-day	clock
       set_color_band	       setcolor		YzChange to ribbon color #1
       set_color_pair	       scp     sp	Set current color-pair
       set_foreground	       setf    Sf	Set current foreground color1
       set_left_margin	       smgl    ML	Set left margin	at current line
       set_left_margin_parm    smglp   Zm	Set left (right) margin
						at column #1 (#2)
       set_lr_margin	       smglr   ML	Sets both left and right margins
       set_page_length	       slines  YZ	Set page length	to #1 lines
						(use tparm) of an inch
       set_right_margin	       smgr    MR	Set right margin at
						current	column
       set_right_margin_parm   smgrp   Zn	Set right margin at column #1
       set_tab		       hts     st	Set a tab in all rows,
						current	column
       set_tb_margin	       smgtb   MT	Sets both top and bottom margins
       set_top_margin	       smgt    Zo	Set top	margin at current line
       set_top_margin_parm     smgtp   Zp	Set top	(bottom) margin
						at line	#1 (#2)
       set_window	       wind    wi	Current	window is lines
						#1-#2 cols #3-#4
       start_bit_image	       sbim    Zq	Start printing bit image graphics
       start_char_set_def      scsd    Zr	Start definition of a character
       stop_bit_image	       rbim    Zs	End printing bit image graphics
       stop_char_set_def       rcsd    Zt	End definition of a character set
       subscript_characters    subcs   Zu	List of	``subscript-able''
       superscript_characters  supcs   Zv	List of	``superscript-able''
       tab		       ht      ta	Tab to next 8-space hardware tab
       these_cause_cr	       docr    Zw	Printing any of	these
						chars causes cr
       to_status_line	       tsl     ts	Go to status line, col #1
       tone		       tone    TO	Select touch tone dialing
       user0		       u0      u0	User string 0
       user1		       u1      u1	User string 1
       user2		       u2      u2	User string 2
       user3		       u3      u3	User string 3
       user4		       u4      u4	User string 4
       user5		       u5      u5	User string 5
       user6		       u6      u6	User string 6
       user7		       u7      u7	User string 7
       user8		       u8      u8	User string 8
       user9		       u9      u9	User string 9
       underline_char	       uc      uc	Underscore one char
						and move past it
       up_half_line	       hu      hu	Half-line up (reverse
						1/2 linefeed)
       wait_tone	       wait    WA	Wait for dial tone
       xoff_character	       xoffc   XF	X-off character
       xon_character	       xonc    XN	X-on character
       zero_motion	       zerom   Zx	No motion for the
						subsequent character

   Sample Entry
       The  following  entry,  which describes the AT&T	610 terminal, is among
       the more	complex	entries	in the terminfo	file as	of this	writing.

       610|610bct|ATT610|att610|AT&T610;80column;98key keyboard
	  am, eslok, hs, mir, msgr, xenl, xon,
	  cols#80, it#8, lh#2, lines#24, lw#8, nlab#8, wsl#80,
	  bel=^G, blink=\E[5m, bold=\E[1m, cbt=\E[Z,
	  civis=\E[?25l, clear=\E[H\E[J, cnorm=\E[?25h\E[?12l,
	  cr=\r, csr=\E[%i%p1%d;%p2%dr,	cub=\E[%p1%dD, cub1=\b,
	  cud=\E[%p1%dB, cud1=\E[B, cuf=\E[%p1%dC, cuf1=\E[C,
	  cup=\E[%i%p1%d;%p2%dH, cuu=\E[%p1%dA,	cuu1=\E[A,
	  cvvis=\E[?12;25h, dch=\E[%p1%dP, dch1=\E[P, dim=\E[2m,
	  dl=\E[%p1%dM,	dl1=\E[M, ed=\E[J, el=\E[K, el1=\E[1K,
	  flash=\E[?5h$<200>\E[?5l, fsl=\E8, home=\E[H,	ht=\t,
	  ich=\E[%p1%d@, il=\E[%p1%dL, il1=\E[L, ind=\ED, .ind=\ED$<9>,
	  is1=\E[8;0 | \E[?3;4;5;13;15l\E[13;20l\E[?7h\E[12h\E(B\E)0,
	  is2=\E[0m^O, is3=\E(B\E)0, kLFT=\E[\s@, kRIT=\E[\sA,
	  kbs=^H, kcbt=\E[Z, kclr=\E[2J, kcub1=\E[D, kcud1=\E[B,
	  kcuf1=\E[C, kcuu1=\E[A, kf1=\EOc, kf10=\ENp,
	  kf11=\ENq, kf12=\ENr,	kf13=\ENs, kf14=\ENt, kf2=\EOd,
	  kf3=\EOe, kf4=\EOf, kf5=\EOg,	kf6=\EOh, kf7=\EOi,
	  kf8=\EOj, kf9=\ENo, khome=\E[H, kind=\E[S, kri=\E[T,
	  ll=\E[24H, mc4=\E[?4i, mc5=\E[?5i, nel=\EE,
	  pln=\E[%p1%d;0;0;0q%p2%:-16.16s, rc=\E8, rev=\E[7m,
	  ri=\EM, rmacs=^O, rmir=\E[4l,	rmln=\E[2p, rmso=\E[m,
	  rmul=\E[m, rs2=\Ec\E[?3l, sc=\E7,
       %?%p3%p1% | %t;7%;%?%p7%t;8%;m%?%p9%t^N%e^O%;,
	  sgr0=\E[m^O, smacs=^N, smir=\E[4h, smln=\E[p,
	  smso=\E[7m, smul=\E[4m, tsl=\E7\E[25;%i%p1%dx,

   Types of Capabilities in the	Sample Entry
       The sample entry	shows the formats for the three	types of terminfo  ca-
       pabilities  listed:   Boolean,  numeric,	 and  string. All capabilities
       specified in the	terminfo source	file must be followed by  commas,  in-
       cluding	the  last  capability  in  the source file. In terminfo	source
       files, capabilities are referenced by their capability names (as	 shown
       in the previous tables).

       Boolean	capabilities are specified simply by their comma separated cap

       Numeric capabilities are	followed by the	character `#' and then a posi-
       tive  integer  value. Thus, in the sample, cols (which shows the	number
       of columns available on a device) is assigned the value 80 for the AT&T
       610.  (Values for numeric capabilities may be specified in decimal, oc-
       tal, or hexadecimal, using normal C programming language	conventions.)

       Finally,	string-valued capabilities such	as el (clear to	 end  of  line
       sequence) are listed by a two- to five-character	capname, an `=', and a
       string ended by the next	occurrence of a	comma. A delay in milliseconds
       may appear anywhere in such a capability, preceded by $ and enclosed in
       angle brackets, as in el=\EK$<3>. Padding characters  are  supplied  by
       tput.  The  delay can be	any of the following:  a number, a number fol-
       lowed by	an asterisk, such as 5*, a number followed by a	slash, such as
       5/,  or	a  number  followed by both, such as 5*/. A `*'	shows 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 re-
       quired. (In the case of insert characters, the factor is	still the num-
       ber  of	lines  affected. This is always	1 unless the device has	in 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.)

       A `/' indicates that the	padding	is mandatory. If a device has xon  de-
       fined,  the  padding  information is advisory and will only be used for
       cost estimates or when the device is in	raw  mode.  Mandatory  padding
       will  be	 transmitted  regardless  of  the  setting of xon.  If padding
       (whether	advisory or mandatory) is specified for	bel or flash, however,
       it will always be used, regardless of whether xon is specified.

       terminfo	 offers	 notation for encoding special characters. Both	\E and
       \e map to an ESCAPE character, ^x maps to a control x for any appropri-
       ate x, and the sequences	\n, \l,	\r, \t,	\b, \f,	and \s give a newline,
       linefeed, return, tab, backspace, formfeed,  and	 space,	 respectively.
       Other  escapes  include:	\^ for caret (^); \\ for backslash (\);	\, for
       comma (,); \: for colon (:); and	\0 for null. (\0 will actually produce
       \200, which does	not terminate a	string but behaves as a	null character
       on most devices,	providing CS7 is specified.  (See  stty(1)).  Finally,
       characters  may	be  given as three octal digits	after a	backslash (for
       example,	\123).

       Sometimes individual capabilities must be commented out.	 To  do	 this,
       put  a  period  before the capability name. For example,	see the	second
       ind in the example above. Note that capabilities	are defined in a left-
       to-right	order and, therefore, a	prior definition will override a later

   Preparing Descriptions
       The most	effective way to prepare a device description is by  imitating
       the  description	 of a similar device in	terminfo and building up a de-
       scription gradually, using partial descriptions with vi to  check  that
       they  are correct. Be aware that	a very unusual device may expose defi-
       ciencies	in the ability of the terminfo file to describe	it or the  in-
       ability	of  vi to work with that device. To test a new device descrip-
       tion, set the environment variable TERMINFO to the pathname of a	direc-
       tory  containing	 the  compiled description you are working on and pro-
       grams will look there rather than in  /usr/share/lib/terminfo.  To  get
       the padding for insert-line correct (if the device manufacturer did not
       document	it) a severe test is to	comment	out xon, edit a	large file  at
       9600 baud with vi, delete 16 or so lines	from the middle	of the screen,
       and then	press the u key	several	times quickly. If the display is  cor-
       rupted,	more padding is	usually	needed.	A similar test can be used for

   Section 1-1:	Basic Capabilities
       The number of columns on	each line for the device is given by the  cols
       numeric	capability.  If	 the  device  has a screen, then the number of
       lines on	the screen is given by the lines  capability.  If  the	device
       wraps  around  to  the  beginning  of the next line when	it reaches the
       right margin, then it should have the am	capability.  If	 the  terminal
       can  clear  its	screen,	 leaving the cursor in the home	position, then
       this is given by	the clear string capability.  If  the  terminal	 over-
       strikes	(rather	 than  clearing	 a position when a character is	struck
       over) then it should have the os	capability. If the device is a	print-
       ing  terminal, with no soft copy	unit, specify both hc and os. If there
       is a way	to move	the cursor to the left edge of the current row,	 spec-
       ify  this as cr.	(Normally this will be carriage	return,	control	M.) If
       there is	a way to produce an audible signal (such as a bell or a	beep),
       specify	it as bel. If, like most devices, the device uses the xon-xoff
       flow-control protocol, specify xon.

       If there	is a way to move the cursor one	position to the	left (such  as
       backspace),  that  capability  should  be given as cub1.	Similarly, se-
       quences to move to the right, up, and down should  be  given  as	 cuf1,
       cuu1, and cud1, respectively. These local cursor	motions	must not alter
       the text	they pass over;	 for  example,	you  would  not	 normally  use
       ``cuf1=\s'' because the space would erase the character moved over.

       A very important	point here is that the local cursor motions encoded in
       terminfo	are undefined at the left and top edges	of a screen  terminal.
       Programs	should never attempt to	backspace around the left edge,	unless
       bw is specified,	and should never attempt to go up locally off the top.
       To  scroll  text	 up,  a	 program goes to the bottom left corner	of the
       screen and sends	the ind	(index)	string.

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

       Parameterized versions of the scrolling sequences  are  indn  and  rin.
       These  versions have the	same semantics as ind and ri, except that they
       take one	parameter and scroll the number	of lines specified by that pa-
       rameter.	 They are also undefined except	at the appropriate edge	of the

       The am 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 cuf1 from the last column. Backward motion from the left edge of  the
       screen  is  possible only when bw is specified. In this case, cub1 will
       move to the right edge of the previous row. If bw is not	given, the ef-
       fect  is	undefined. This	is useful for drawing a	box around the edge of
       the screen, for example.	If the device has switch selectable  automatic
       margins,	 am  should  be	specified in the terminfo source file. In this
       case, initialization strings should turn	on this	option,	 if  possible.
       If  the device has a command that moves to the first column of the next
       line, that command can be given as nel (newline). It does not matter if
       the  command clears the remainder of the	current	line, so if the	device
       has no cr and lf	it may still be	possible to craft a working nel	out of
       one or both of them.

       These  capabilities  suffice to describe	hardcopy and screen terminals.
       Thus the	AT&T 5320 hardcopy terminal is described as follows:

       5320|att5320|AT&T 5320 hardcopy terminal,
	  am, hc, os,
	  bel=^G, cr=\r, cub1=\b, cnd1=\n,
	  dch1=\E[P, dl1=\E[M,

       while the Lear Siegler ADM-3 is described as

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

   Section 1-2:	Parameterized Strings
       Cursor addressing and other strings requiring parameters	are  described
       by  a parameterized string capability, with printf-like escapes (%x) in
       it. For example,	to address the cursor, the cup	capability  is	given,
       using  two parameters: the row and column to address to.	(Rows and col-
       umns are	numbered from zero and refer to	the physical screen visible to
       the  user,  not to any unseen memory.) If the terminal has memory rela-
       tive cursor addressing, that can	be indicated by	mrcup.

       The parameter mechanism uses a stack and	special	% codes	to  manipulate
       the stack in the	manner of Reverse Polish Notation (postfix). 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.
       Operations are in postfix form with the operands	in  the	 usual	order.
       That  is,  to  subtract	5  from	 the  first  parameter,	 one would use

       The % encodings have the	following meanings:

       %%				       outputs `%'

       %[[:]flags][width[.precision]][doxXs]   as in printf, flags  are	 [-+#]
					       and space

       %c				       print pop gives %c

       %p[1-9]				       push ith	parm

       %P[a-z]				       set  dynamic  variable [a-z] to

       %g[a-z]				       get dynamic variable [a-z]  and
					       push it

       %P[A-Z]				       set  static  variable  [a-z] to

       %g[A-Z]				       get static variable  [a-z]  and
					       push it

       %'c'				       push char constant c

       %{nn}				       push decimal constant nn

       %l				       push strlen(pop)

       %+ %- %*	%/ %m			       arithmetic    (%m    is	 mod):
					       push(pop	integer2 op pop	 inte-

       %& %| %^				       bit operations:	push(pop inte-
					       ger2 op pop integer1)

       %= %> %<				       logical	operations:   push(pop
					       integer2	op pop integer1)

       %A %O				       logical operations:  and, or

       %! %~				       unary operations:  push(op pop)

       %i				       (for  ANSI  terminals) add 1 to
					       first   parm,   if   one	  parm
					       present,	or first two parms, if
					       more than one parm present

       %? expr %t thenpart %e elsepart %;      if-then-else,  %e  elsepart  is
					       optional;  else-if's are	possi-
					       ble ala Algol 68: %?  c1	%t  b1
					       %e  c2  %t b2 %e	c3 %t b3 %e c4
					       %t b4 %e	 b5%;  ci  are	condi-
					       tions, bi are bodies.

       If  the	``-'' flag is used with	``%[doxXs]'', then a colon (:) must be
       placed between the ``%''	and the	``-'' to differentiate the  flag  from
       the binary ``%-'' operator, for example ``%:-16.16s''.

       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 rows	and columns is inverted	here, and that the row
       and column are zero-padded as two digits. Thus its cup  capability  is:

       The Micro-Term ACT-IV needs the current row and column sent preceded by
       a  ^T,  with  the  row	and   column   simply	encoded	  in   binary,
       ``cup=^T%p1%c%p2%c''.  Devices  that  use  ``%c''  need	to  be able to
       backspace the cursor (cub1), and	to move	the cursor up one line on  the
       screen  (cuu1).	This  is  necessary  because  it is not	always safe to
       transmit	\n, ^D,	and \r,	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%'\s'%+%c%p2%'\s'%+%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 charac-
       ter. Then the same is done  for	the  second  parameter.	 More  complex
       arithmetic is possible using the	stack.

   Section 1-3:	Cursor Motions
       If  the	terminal has a fast way	to home	the cursor (to very upper left
       corner of screen) then this can be given	as home; similarly a fast  way
       of  getting  to the lower left-hand corner can be given as ll; this may
       involve going up	with cuu1 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 addressing	to (0,0): to the top left cor-
       ner of the screen, not of memory.  (Thus, the \EH sequence on  Hewlett-
       Packard	terminals  cannot  be used for home without losing some	of the
       other features on the terminal.)

       If the device has row or	column absolute-cursor addressing,  these  can
       be  given as single parameter capabilities hpa (horizontal position ab-
       solute) and vpa	(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  cup.  If	 there
       are  parameterized  local  motions  (for	 example, move n spaces	to the
       right) these can	be given as cud, cub, cuf, and cuu with	a  single  pa-
       rameter	indicating how many spaces to move. These are primarily	useful
       if the device does not have cup,	such as	the Tektronix 4025.

       If the device 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	smcup and rmcup. This arises,  for  example,  from  terminals,
       such  as	 the Concept, with more	than one page of memory. If the	device
       has only	memory relative	cursor addressing and not screen relative cur-
       sor addressing, a one screen-sized window must be fixed into the	device
       for cursor addressing to	work properly. This is also used for the  Tek-
       tronix  4025, where smcup sets the command character to be the one used
       by terminfo. If the smcup sequence will not restore the screen after an
       rmcup  sequence	is  output  (to	 the state prior to outputting rmcup),
       specify nrrmc.

   Section 1-4:	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	el. If
       the terminal can	clear from the beginning of the	line  to  the  current
       position	 inclusive,  leaving  the  cursor  where it is,	this should be
       given as	el1. If	the terminal can clear from the	 current  position  to
       the end of the display, then this should	be given as ed.	ed is only de-
       fined 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 ed is not	avail-

   Section 1-5:	Insert/Delete Line
       If the terminal can open	a new blank line before	 the  line  where  the
       cursor  is,  this  should  be  given as il1; 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 dl1; this is done only from	the first  po-
       sition  on the line to be deleted. Versions of il1 and dl1 which	take a
       single parameter	and insert or delete that many lines can be  given  as
       il and dl.

       If  the	terminal has a settable	destructive scrolling region (like the
       VT100) the command to set this can be described with the	 csr  capabil-
       ity,  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 ri or	ind on	many  terminals	 without  a  true  in-
       sert/delete line, and is	often faster even on terminals with those fea-

       To determine whether a terminal has destructive	scrolling  regions  or
       non-destructive	scrolling  regions,  create  a scrolling region	in the
       middle of the screen, place data	on the bottom line  of	the  scrolling
       region, move the	cursor to the top line of the scrolling	region,	and do
       a reverse index (ri) followed by	a delete line (dl1) or index (ind). If
       the data	that was originally on the bottom line of the scrolling	region
       was restored into the scrolling region by the dl1 or ind, then the ter-
       minal has non-destructive scrolling regions. Otherwise, it has destruc-
       tive scrolling regions. Do not specify csr if the terminal has  non-de-
       structive scrolling regions, unless ind,	ri, indn, rin, dl, and dl1 all
       simulate	destructive scrolling.

       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 wind. 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 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 a
       full screen may bring non-blank lines up	from below or  that  scrolling
       back with ri may	bring down non-blank lines.

   Section 1-6:	Insert/Delete Character
       There  are two basic kinds of intelligent terminals with	respect	to in-
       sert/delete character operations	which can be described using terminfo.
       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 ter-
       minal, and should give the capability in,  which	 stands	 for  ``insert
       null.''	While  these  are  two logically separate attributes (one line
       versus 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 that have an insert	mode and  ter-
       minals  which  send  a  simple sequence to open a blank position	on the
       current line. Give as smir the sequence to get into insert  mode.  Give
       as  rmir	 the  sequence	to leave insert	mode. Now give as ich1 any se-
       quence needed to	be sent	just before sending the	character  to  be  in-
       serted. Most terminals with a true insert mode will not give ich1; ter-
       minals that send	a sequence to open a screen position  should  give  it
       here.  (If your terminal	has both, insert mode is usually preferable to
       ich1. 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 padding in ip (a string option). Any  other  se-
       quence  which may need to be sent after an insert of a single character
       may also	be given in ip.	If your	terminal needs both to be placed  into
       an `insert mode'	and a special code to precede each inserted character,
       then both smir/rmir and ich1 can	be given, and both will	be  used.  The
       ich capability, with one	parameter, n, will insert n blanks.

       If  padding  is	necessary between characters typed while not in	insert
       mode, give this as a number of milliseconds padding in rmp.

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

       Finally,	you can	specify	dch1 to	delete a single	 character,  dch  with
       one  parameter,	n,  to	delete n characters, and delete	mode by	giving
       smdc and	rmdc to	enter and exit delete  mode  (any  mode	 the  terminal
       needs to	be placed in for dch1 to work).

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

   Section 1-7:	Highlighting, Underlining, and Visible Bells
       Your device may have one	or more	kinds of display attributes that allow
       you  to	highlight  selected characters when they appear	on the screen.
       The following display modes (shown with the names  by  which  they  are
       set)  may be available: a blinking screen (blink), bold or extra-bright
       characters (bold), dim or half-bright characters	(dim), blanking	or in-
       visible	text  (invis),	protected  text	(prot),	a reverse-video	screen
       (rev), and an alternate character set (smacs to	enter  this  mode  and
       rmacs  to exit it). (If a command is necessary before you can enter al-
       ternate character set mode, give	the sequence in	enacs or  "enable  al-
       ternate-character-set"  mode.) Turning on any of	these modes singly may
       or may not turn off other modes.

       sgr0 should be used to turn off all video enhancement capabilities.  It
       should  always  be specified because it represents the only way to turn
       off some	capabilities, such as dim or blink.

       You should choose one display method as standout	mode  and  use	it  to
       highlight  error	 messages and other kinds of text to which you want to
       draw attention. Choose a	form of	display	that provides strong  contrast
       but  that  is  easy on the eyes.	(We recommend reverse-video plus half-
       bright or reverse-video alone.) The sequences to	enter and exit	stand-
       out  mode  are  given  as  smso	and rmso, 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 xmc should be
       given to	tell how many spaces are left.

       Sequences to begin underlining and end underlining can be specified  as
       smul and	rmul , respectively. If	the device has a sequence to underline
       the current character and to move the cursor one	 space	to  the	 right
       (such as	the Micro-Term MIME), this sequence can	be specified as	uc.

       Terminals  with	the  ``magic  cookie''	glitch	(xmc)  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 Hewlett-Packard 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 msgr 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	flash; it must
       not move	the cursor. A good flash can be	done by	 changing  the	screen
       into  reverse  video,  pad for 200 ms, then return the screen to	normal

       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
       cvvis.  The  boolean  chts  should also be given.  If there is a	way to
       make the	cursor completely invisible, give that as civis. The  capabil-
       ity  cnorm  should be given which undoes	the effects of either of these

       If your terminal	generates underlined characters	by using the underline
       character  (with	 no  special sequences needed) even though it does not
       otherwise overstrike characters,	then you should	specify	the capability
       ul.  For	 devices on which a character overstriking another leaves both
       characters on the screen, specify the capability	os. If overstrikes are
       erasable	with a blank, then this	should be indicated by specifying eo.

       If  there  is  a	 sequence to set arbitrary combinations	of modes, this
       should be given as sgr (set attributes),	taking nine  parameters.  Each
       parameter is either 0 or	non-zero, as the corresponding attribute is on
       or off. The nine	parameters are,	in  order:  standout,  underline,  re-
       verse,  blink,  dim, bold, blank, protect, alternate character set. Not
       all modes need to be supported by sgr; only those for which correspond-
       ing separate attribute commands exist should be supported. For example,
       let's assume that the terminal in question needs	the  following	escape
       sequences to turn on various modes.

	   parameter	    attribute		  escape sequence
			    none		  \E[0m
	       p1	    standout		  \E[0;4;7m
	       p2	    underline		  \E[0;3m
	       p3	    reverse		  \E[0;4m
	       p4	     blink		  \E[0;5m
	       p5	    dim			  \E[0;7m
	       p6	    bold		  \E[0;3;4m
	       p7	    invis		  \E[0;8m
	       p8	    protect		  not available
	       p9	    altcharset		  ^O (off) ^N (on)

       Note that each escape sequence requires a 0 to turn off other modes be-
       fore turning on its own mode.  Also  note  that,	 as  suggested	above,
       standout	is set up to be	the combination	of reverse and dim.  Also, be-
       cause this terminal has no bold mode, bold is set up as the combination
       of  reverse  and	underline. In addition,	to allow combinations, such as
       underline+blink,	the sequence to	use would be \E[0;3;5m.	 The  terminal
       doesn't	have protect mode, either, but that cannot be simulated	in any
       way, so p8 is ignored. The altcharset mode is different in that	it  is
       either  ^O  or  ^N,  depending on whether it is off or on. If all modes
       were to be turned on, the sequence would	be \E[0;3;4;5;7;8m^N.

       Now look	at when	different sequences are	output.	 For  example,	;3  is
       output  when  either  p2	or p6 is true, that is,	if either underline or
       bold modes are turned on. Writing out the above sequences,  along  with
       their dependencies, gives the following:

	  sequence	    when to output	terminfo translation
       \E[0		 always			\E[0
       ;3		 if p2 or p6		%?%p2%p6%|%t;3%;
       ;4		 if p1 or p3 or	p6	%?%p1%p3%|%p6%|%t;4%;
       ;5		 if p4			%?%p4%t;5%;
       ;7		 if p1 or p5		%?%p1%p5%|%t;7%;
       ;8		 if p7			%?%p7%t;8%;
       m		 always			m
       ^N or ^O		 if p9 ^N, else	^O	%?%p9%t^N%e^O%;

       Putting this all	together into the sgr sequence gives:

       sgr=\E[0%?%p2%p6%|%t;3%;%?%p1%p3%|%p6%	   |%t;4%;%?%p5%t;5%;%?%p1%p5%

       Remember	that sgr and sgr0 must always be specified.

   Section 1-8:	Keypad
       If the device has a keypad that transmits sequences when	the  keys  are
       pressed,	 this  information  can	also be	specified. Note	that it	is not
       possible	to handle devices where	the keypad only	works in  local	 (this
       applies,	 for  example, to the unshifted	Hewlett-Packard	2621 keys). If
       the keypad can be set to	transmit or not	transmit,  specify  these  se-
       quences	as  smkx  and  rmkx. Otherwise the keypad is assumed to	always

       The sequences sent by the left arrow, right arrow, up arrow,  down  ar-
       row,  and  home	keys  can  be  given as	kcub1, kcuf1, kcuu1, kcud1,and
       khome, respectively. If there are function keys such as	f0,  f1,  ...,
       f63,  the  sequences they send can be specified as kf0, kf1, ..., kf63.
       If the first 11 keys have labels	other than the default f0 through f10,
       the  labels  can	be given as lf0, lf1, ..., lf10. The codes transmitted
       by certain other	special	keys  can  be  given:  kll  (home  down),  kbs
       (backspace),  ktbc  (clear all tabs), kctab (clear the tab stop in this
       column),	kclr (clear screen or erase key),  kdch1  (delete  character),
       kdl1  (delete  line),  krmir  (exit  insert mode), kel (clear to	end of
       line), ked (clear to end	of screen), kich1 (insert character  or	 enter
       insert mode), kil1 (insert line), knp (next page), kpp (previous	page),
       kind (scroll forward/down), kri (scroll backward/up), khts (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
       ka1,  ka3, kb2, kc1, and	kc3. These keys	are useful when	the effects of
       a 3 by 3	directional pad	are needed. Further keys are defined above  in
       the capabilities	list.

       Strings	to program function keys can be	specified as pfkey, pfloc, and
       pfx. A string to	program	screen labels should be	specified as pln. Each
       of  these strings takes two parameters: a function key identifier and a
       string to program it with. pfkey	causes pressing	the given  key	to  be
       the  same  as the user typing the given string; pfloc causes the	string
       to be executed by the terminal in local mode; and pfx causes the	string
       to be transmitted to the	computer. The capabilities nlab, lw and	lh de-
       fine the	number of programmable	screen	labels	and  their  width  and
       height.	If there are commands to turn the labels on and	off, give them
       in smln and rmln. smln is normally output after one  or	more  pln  se-
       quences to make sure that the change becomes visible.

   Section 1-9:	Tabs and Initialization
       If the device has hardware tabs,	the command to advance to the next tab
       stop can	be given as ht (usually	control	I). A ``backtab'' command that
       moves leftward to the next tab stop can be given	as cbt.	By convention,
       if tty modes show that tabs are being expanded by the  computer	rather
       than  being sent	to the device, programs	should not use ht or cbt (even
       if they are present) because the	user may not have the tab stops	 prop-
       erly  set. If the device	has hardware tabs that are initially set every
       n spaces	when the device	is powered up, the  numeric  parameter	it  is
       given,  showing	the number of spaces the tabs are set to. This is nor-
       mally used by tput init (see tput(1)) to	determine whether to  set  the
       mode  for  hardware  tab	expansion and whether to set the tab stops. If
       the device has tab stops	that can be saved in nonvolatile  memory,  the
       terminfo	 description  can  assume that they are	properly set. If there
       are commands to set and clear tab stops,	 they  can  be	given  as  tbc
       (clear  all tab stops) and hts (set a tab stop in the current column of
       every row).

       Other capabilities include: is1,	is2, and is3,  initialization  strings
       for the device; iprog, the path name of a program to be run to initial-
       ize the device; and if, the name	of a file containing long  initializa-
       tion  strings.  These strings are expected to set the device into modes
       consistent with the rest	of the terminfo	description. They must be sent
       to the device each time the user	logs in	and be output in the following
       order: run the program iprog; output is1; output	is2; set  the  margins
       using  mgc,  smgl  and  smgr; set the tabs using	tbc and	hts; print the
       file if;	and finally output is3.	This is	usually	done  using  the  init
       option of tput.

       Most  initialization  is	done with is2. Special device modes can	be set
       up without duplicating strings by putting the common sequences  in  is2
       and  special cases in is1 and is3. Sequences that do a reset from a to-
       tally unknown state can be given	as rs1,	rs2, rf, and rs3, analogous to
       is1,  is2, is3, and if. (The method using files,	if and rf, is used for
       a few terminals,	from /usr/share/lib/tabset/*; however, the recommended
       method  is  to use the initialization and reset strings.) These strings
       are output by tput reset, which is used when the	terminal gets  into  a
       wedged  state.  Commands	 are  normally placed in rs1, rs2, rs3,	and rf
       only if they produce annoying effects on	the screen and are not	neces-
       sary  when  logging in. For example, the	command	to set a terminal into
       80-column mode would normally be	part of	is2, but on some terminals  it
       causes  an annoying glitch on the screen	and is not normally needed be-
       cause the terminal is usually already in	80-column mode.

       If a more complex sequence is needed to set the tabs than  can  be  de-
       scribed by using	tbc and	hts, the sequence can be placed	in is2 or if.

       Any margin can be cleared with mgc. (For	instructions on	how to specify
       commands	to set and clear margins, see "Margins"	below  under  "PRINTER

   Section 1-10: Delays
       Certain	capabilities control padding in	the tty	driver.	These are pri-
       marily needed by	hard-copy terminals, and are used by tput init to  set
       tty  modes  appropriately. Delays embedded in the capabilities cr, ind,
       cub1, ff, and tab can be	used to	set the	appropriate delay bits	to  be
       set in the tty driver. If pb (padding baud rate)	is given, these	values
       can be ignored at baud rates below the value of pb.

   Section 1-11: Status	Lines
       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  ad-
       dress  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
       hs  should  be  given. Special strings that go to a given column	of the
       status line and return from the status line can be  given  as  tsl  and
       fsl.  (fsl  must	leave the cursor position in the same place it was be-
       fore tsl. If necessary, the sc and rc strings can be  included  in  tsl
       and  fsl	 to  get this effect.) The capability tsl takes	one parameter,
       which is	the column number of the status	line the cursor	is to be moved

       If escape sequences and other special commands, such as tab, work while
       in the status line, the flag eslok can be given.	A string  which	 turns
       off  the	status line (or	otherwise erases its contents) should be given
       as dsl. If the terminal has commands to save and	restore	 the  position
       of  the cursor, give them as sc and rc. The status line is normally as-
       sumed to	be the same width as the rest  of  the	screen,	 for  example,
       cols.  If  the  status  line is a different width (possibly because the
       terminal	does not allow an entire line to be loaded) the	width, in col-
       umns, can be indicated with the numeric parameter wsl.

   Section 1-12: Line Graphics
       If  the	device has a line drawing alternate character set, the mapping
       of glyph	to character would be given in acsc. The  definition  of  this
       string  is  based  on the alternate character set used in the DEC VT100
       terminal, extended slightly with	some characters	from the  AT&T	4410v1

       Glyph Name			   vt100+ Character
       arrow pointing right			  +
       arrow pointing left			  ,
       arrow pointing down			  .
       solid square block			  0
       lantern symbol				  I
       arrow pointing up			  -

       diamond					  `
       checker board (stipple)			  a
       degree symbol				  f
       plus/minus				  g
       board of	squares				  h
       lower right corner			  j
       upper right corner			  k
       upper left corner			  l
       lower left corner			  m
       plus					  n
       scan line 1				  o
       horizontal line				  q
       scan line 9				  s
       left tee					  t
       right tee				  u
       bottom tee				  v
       top tee					  w
       vertical	line				  x
       bullet					  ~

       The  best  way to describe a new	device's line graphics set is to add a
       third column to the above table with the	characters for the new	device
       that  produce the appropriate glyph when	the device is in the alternate
       character set mode. For example,

       Glyph Name		vt100+ Char	     New tty Char
       upper left corner	     l			  R
       lower left corner	     m			  F
       upper right corner	     k			  T
       lower right corner	     j			  G
       horizontal line		     q			  ,
       vertical	line		     x			  .

       Now write down the  characters  left  to	 right,	 as  in	 ``acsc=lRmFk-

       In addition, terminfo allows you	to define multiple character sets. See
       Section 2-5 for details.

   Section 1-13: Color Manipulation
       Let us define two methods of color manipulation:	 the Tektronix	method
       and the HP method. The Tektronix	method uses a set of N predefined col-
       ors (usually 8) from which a user can select "current"  foreground  and
       background  colors.  Thus  a  terminal can support up to	N colors mixed
       into N*N	color-pairs to be displayed on the screen at  the  same	 time.
       When  using an HP method	the user cannot	define the foreground indepen-
       dently of the background, or vice-versa.	Instead, the user must	define
       an  entire  color-pair at once. Up to M color-pairs, made from 2*M dif-
       ferent colors, can be defined this way. Most existing  color  terminals
       belong to one of	these two classes of terminals.

       The  numeric variables colors and pairs define the number of colors and
       color-pairs that	can be displayed on the	screen at the same time. If  a
       terminal	 can  change  the definition of	a color	(for example, the Tek-
       tronix 4100 and 4200 series terminals), this should be  specified  with
       ccc  (can change	color).	To change the definition of a color (Tektronix
       4200 method), use initc (initialize color). It requires four arguments:
       color  number  (ranging	from 0 to colors-1) and	three RGB (red,	green,
       and blue) values	or three  HLS  colors  (Hue,  Lightness,  Saturation).
       Ranges of RGB and HLS values are	terminal dependent.

       Tektronix  4100	series terminals only use HLS color notation. For such
       terminals (or dual-mode terminals to be operated	in HLS mode) one  must
       define	a  boolean  variable  hls;  that  would	 instruct  the	curses
       init_color routine to convert its RGB arguments to HLS  before  sending
       them  to	 the  terminal.	 The  last three arguments to the initc	string
       would then be HLS values.

       If a terminal can change	the definitions	of colors, but	uses  a	 color
       notation	 different  from  RGB  and HLS,	a mapping to either RGB	or HLS
       must be developed.

       To set current foreground or background to a  given  color,  use	 setaf
       (set ANSI foreground) and setab (set ANSI background). They require one
       parameter:  the number of the color. To	initialize  a  color-pair  (HP
       method),	 use  initp  (initialize  pair). It requires seven parameters:
       the number of a color-pair (range=0 to pairs-1),	and  six  RGB  values:
       three for the foreground	followed by three for the background. (Each of
       these groups of three should be in the order RGB.) When initc or	 initp
       are  used,  RGB	or  HLS	 arguments should be in	the order "red,	green,
       blue" or	"hue, lightness, saturation"), respectively. To	make a	color-
       pair  current,  use  scp	 (set color-pair). It takes one	parameter, the
       number of a color-pair.

       Some terminals (for example, most color	terminal  emulators  for  PCs)
       erase areas of the screen with current background color.	In such	cases,
       bce (background color erase) should be defined. The variable op (origi-
       nal  pair) contains a sequence for setting the foreground and the back-
       ground colors to	what they were at the terminal	start-up  time.	 Simi-
       larly, oc (original colors) contains a control sequence for setting all
       colors (for the Tektronix method) or color-pairs	(for the HP method) to
       the values they had at the terminal start-up time.

       Some  color terminals substitute	color for video	attributes. Such video
       attributes should not be	combined with colors. Information about	 these
       video  attributes  should be packed into	the ncv	(no color video) vari-
       able. There is a	one-to-one correspondence between the nine least  sig-
       nificant	 bits of that variable and the video attributes. The following
       table depicts this correspondence.


       When a particular video attribute should	not be used with  colors,  the
       corresponding ncv bit should be set to 1; otherwise it should be	set to
       zero. To	determine the information to pack into the ncv	variable,  you
       must  add together the decimal values corresponding to those attributes
       that cannot coexist with	colors.	For example, if	the terminal uses col-
       ors  to	simulate  reverse video	(bit number 2 and decimal value	4) and
       bold (bit number	5 and decimal value 32), the resulting value  for  ncv
       will be 36 (4 + 32).

   Section 1-14: Miscellaneous
       If  the	terminal requires other	than a null (zero) character as	a pad,
       then this can be	given as pad. Only the	first  character  of  the  pad
       string  is used.	If the terminal	does not have a	pad character, specify

       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 use-
       ful for superscripts and	subscripts on hardcopy terminals. If  a	 hard-
       copy  terminal  can eject to the	next page (form	feed), give this as ff
       (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 charac-
       ters) this can be indicated with	 the  parameterized  string  rep.  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	cmdch. A prototype  command  character
       is chosen which is used in all capabilities. This character is given in
       the cmdch capability to identify	it. The	following convention  is  sup-
       ported  on some systems:	If the environment variable CC exists, all oc-
       currences of the	prototype character are	replaced with the character in

       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 is one of those supported by the	system virtual
       terminal	protocol, the terminal number can be given as vt. A line-turn-
       around sequence to be transmitted before	doing reads should  be	speci-
       fied in rfi.

       If  the	device	uses  xon/xoff handshaking for flow control, give xon.
       Padding information should still	be included so that routines can  make
       better  decisions  about	 costs,	 but actual pad	characters will	not be
       transmitted. Sequences to turn on and off xon/xoff handshaking  may  be
       given  in  smxon	 and rmxon. If the characters used for handshaking are
       not ^S and ^Q, they may be specified with xonc and xoffc.

       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 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	smm and	rmm.

       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. A value
       of lm#0 indicates that the number of lines is not fixed,	but that there
       is still	more memory than fits on the screen.

       Media  copy strings which control an auxiliary printer connected	to the
       terminal	can be given as	mc0: print the contents	of  the	 screen,  mc4:
       turn off	the printer, and mc5: turn on the printer. When	the printer is
       on, all text sent to the	terminal will be sent to the printer. A	varia-
       tion,  mc5p, 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. If the text is not displayed on
       the terminal screen when	 the  printer  is  on,	specify	 mc5i  (silent
       printer).  All  text,  including	 mc4,  is  transparently passed	to the
       printer while an	mc5p is	in effect.

   Section 1-15: Special Cases
       The working model used by terminfo fits most terminals reasonably well.
       However,	 some  terminals do not	completely match that model, requiring
       special support by terminfo. These are not meant	to be construed	as de-
       ficiencies  in  the  terminals;	they  are just differences between the
       working model and the actual hardware. They may be unusual devices  or,
       for some	reason,	do not have all	the features of	the terminfo model im-

       Terminals that cannot display tilde (~)	characters,  such  as  certain
       Hazeltine terminals, should indicate hz.

       Terminals  that ignore a	linefeed immediately after an am wrap, such as
       the Concept 100,	should indicate	xenl. Those terminals whose cursor re-
       mains  on  the  right-most  column until	another	character has been re-
       ceived, rather than wrapping immediately	upon receiving the  right-most
       character, such as the VT100, should also indicate xenl.

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

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

       Those Beehive Superbee terminals	which do not transmit  the  escape  or
       control-C characters, should specify xsb, indicating that the f1	key is
       to be used for escape and the f2	key for	control	C.

   Section 1-16: 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 use
       can be given with the name of the similar  terminal.  The  capabilities
       given  before use override those	in the terminal	type invoked by	use. A
       capability can be canceled by placing xx@ to the	left of	the capability
       definition, where xx is the capability. For example, the	entry

       att4424-2|Teletype4424 in display function group	ii,
       rev@, sgr@, smul@, use=att4424,

       defines	an AT&T4424 terminal that does not have	the rev, sgr, and smul
       capabilities, and hence cannot do highlighting. This is useful for dif-
       ferent  modes  for  a terminal, or for different	user preferences. More
       than one	use capability may be given.

       The terminfo database allows you	to define capabilities of printers  as
       well  as	 terminals.  To	 find  out what	capabilities are available for
       printers	as well	as for terminals, see the two lists under "DEVICE  CA-
       PABILITIES" that	list capabilities by variable and by capability	name.

   Section 2-1:	Rounding Values
       Because	parameterized  string capabilities work	only with integer val-
       ues, we recommend that terminfo designers create	 strings  that	expect
       numeric	values	that  have  been rounded. Application designers	should
       note this and should always round values	to the nearest integer	before
       using them with a parameterized string capability.

   Section 2-2:	Printer	Resolution
       A printer's resolution is defined to be the smallest spacing of charac-
       ters it can achieve. In general printers	 have  independent  resolution
       horizontally  and vertically. Thus the vertical resolution of a printer
       can be determined by measuring the smallest achievable distance between
       consecutive  printing baselines,	while the horizontal resolution	can be
       determined by measuring the smallest achievable	distance  between  the
       left-most edges of consecutive printed, identical, characters.

       All printers are	assumed	to be capable of printing with a uniform hori-
       zontal and vertical resolution. The view	of printing that terminfo cur-
       rently presents is one of printing inside a uniform matrix: All charac-
       ters are	printed	at fixed positions relative to each  ``cell''  in  the
       matrix;	furthermore, each cell has the same size given by the smallest
       horizontal and vertical step sizes dictated  by	the  resolution.  (The
       cell size can be	changed	as will	be seen	later.)

       Many printers are capable of ``proportional printing,'' where the hori-
       zontal spacing depends on the size of the character last	printed.  ter-
       minfo  does  not	 make use of this capability, although it does provide
       enough capability definitions to	allow an application to	simulate  pro-
       portional printing.

       A  printer  must	not only be able to print characters as	close together
       as the horizontal and vertical resolutions suggest, but also of	``mov-
       ing''  to a position an integral	multiple of the	smallest distance away
       from a previous position. Thus printed characters can be	spaced apart a
       distance	 that  is an integral multiple of the smallest distance, up to
       the length or width of a	single page.

       Some printers can have different	 resolutions  depending	 on  different
       ``modes.''  In  ``normal	mode,''	the existing terminfo capabilities are
       assumed to work on columns and lines, just like a video terminal.  Thus
       the  old	lines capability would give the	length of a page in lines, and
       the cols	capability would give the width	of a page in columns. In ``mi-
       cro  mode,'' many terminfo capabilities work on increments of lines and
       columns.	With some printers the micro mode may be concomitant with nor-
       mal mode, so that all the capabilities work at the same time.

   Section 2-3:	Specifying Printer Resolution
       The  printing  resolution  of  a	printer	is given in several ways. Each
       specifies the resolution	as the number of smallest steps	per distance:

	  Specification	of Printer Resolution
	   Characteristic Number of Smallest Steps

	    orhi    Steps per inch horizontally
	    orvi    Steps per inch vertically
	    orc	    Steps per column
	    orl	    Steps per line

       When printing in	normal mode, each character printed causes movement to
       the  next column, except	in special cases described later; the distance
       moved is	the same as the	per-column resolution. Some printers cause  an
       automatic  movement to the next line when a character is	printed	in the
       rightmost position; the distance	moved vertically is the	 same  as  the
       per-line	 resolution.  When printing in micro mode, these distances can
       be different, and may be	zero for some printers.

	   Specification of Printer Resolution
	    Automatic Motion after Printing

	    Normal Mode:

	    orc	    Steps moved	horizontally
	    orl	    Steps moved	vertically

	    Micro Mode:

	    mcs	    Steps moved	horizontally
	    mls	    Steps moved	vertically

       Some printers are capable of printing  wide  characters.	 The  distance
       moved  when a wide character is printed in normal mode may be different
       from when a regular width character is printed. The distance moved when
       a  wide	character  is printed in micro mode may	also be	different from
       when a regular character	is printed in micro mode, but the  differences
       are  assumed to be related: If the distance moved for a regular charac-
       ter is the same whether in normal mode or micro	mode  (mcs=orc),  then
       the  distance  moved  for  a wide character is also the same whether in
       normal mode or micro mode. This doesn't mean the	normal character  dis-
       tance is	necessarily the	same as	the wide character distance, just that
       the distances don't change with a change	in normal to micro mode.  How-
       ever, if	the distance moved for a regular character is different	in mi-
       cro mode	from the distance moved	in normal mode	(mcs<orc),  the	 micro
       mode distance is	assumed	to be the same for a wide character printed in
       micro mode, as the table	below shows.

	   Specification of Printer Resolution
	    Automatic Motion after Printing Wide Character

	    Normal Mode	or Micro Mode (mcs = orc):
	    widcs   Steps moved	horizontally

	    Micro Mode (mcs < orc):

	    mcs	    Steps moved	horizontally

       There may be control sequences to change	the number of columns per inch
       (the  character	pitch) and to change the number	of lines per inch (the
       line pitch). If these are used, the resolution of the printer  changes,
       but the type of change depends on the printer:

	   Specification of Printer Resolution
	    Changing the Character/Line	Pitches

	    cpi	    Change character pitch
	    cpix    If set, cpi	changes	orhi, otherwise	changes
	    lpi	    Change line	pitch
	    lpix    If set, lpi	changes	orvi, otherwise	changes
	    chr	    Change steps per column
	    cvr	    Change steps per line

       The  cpi	 and lpi string	capabilities are each used with	a single argu-
       ment, the pitch in columns (or characters) and lines per	inch,  respec-
       tively. The chr and cvr string capabilities are each used with a	single
       argument, the number of steps per column	and line, respectively.

       Using any of the	control	sequences in these strings will	imply a	change
       in  some	 of the	values of orc, orhi, orl, and orvi. Also, the distance
       moved when a wide character is printed, widcs, changes in  relation  to
       orc. The	distance moved when a character	is printed in micro mode, mcs,
       changes similarly, with one exception:  if the distance is 0 or 1, then
       no change is assumed (see items marked with  * in the following table).

       Programs	 that use cpi, lpi, chr, or cvr	should recalculate the printer
       resolution (and should recalculate other	values-- see "Effect of	Chang-
       ing Printing Resolution"	under "Dot-Mapped Graphics").

	   Specification of Printer Resolution
	    Effects of Changing	the Character/Line Pitches

	  Before	    After

       Using cpi with cpix clear:
	$bold orhi '$	orhi
	$bold orc '$	$bold orc = bold orhi over V sub italic	cpi$

	Using cpi with cpix set:
	$bold orhi '$	$bold orhi = bold orc cdot V sub italic	cpi$
	$bold orc '$	$bold orc$

	Using lpi with lpix clear:
	$bold orvi '$	$bold orvi$
	$bold orl '$	$bold orl = bold orvi over V sub italic	lpi$

	Using lpi with lpix set:
	$bold orvi '$	$bold orvi = bold orl cdot V sub italic	lpi$
	$bold orl '$	$bold orl$

	Using chr:
	$bold orhi '$	$bold orhi$
	$bold orc '$	$V sub italic chr$

	Using cvr:
	$bold orvi '$	$bold orvi$
	$bold orl '$	$V sub italic cvr$

	Using cpi or chr:
	$bold widcs '$	$bold widcs = bold {widcs '} bold orc over { bold {orc '} }$
	$bold mcs '$	$bold mcs = bold {mcs '} bold orc over { bold {orc '} }$

       $V  sub italic cpi$, $V sub italic lpi$,	$V sub italic chr$, and	$V sub
       italic cvr$ are the arguments used with cpi, lpi, chr, and cvr, respec-
       tively. The prime marks (') indicate the	old values.

   Section 2-4:	Capabilities that Cause	Movement
       In the following	descriptions, ``movement'' refers to the motion	of the
       ``current position.'' With video	terminals this would  be  the  cursor;
       with  some  printers this is the	carriage position. Other printers have
       different equivalents. In general, the  current	position  is  where  a
       character would be displayed if printed.

       terminfo	has string capabilities	for control sequences that cause move-
       ment a number of	full columns or	lines. It also has  equivalent	string
       capabilities  for  control  sequences  that  cause movement a number of
       smallest	steps.

       String Capabilities for Motion

	    mcub1   Move 1 step	left
	    mcuf1   Move 1 step	right
	    mcuu1   Move 1 step	up
	    mcud1   Move 1 step	down
	    mcub    Move N steps left
	    mcuf    Move N steps right
	    mcuu    Move N steps up
	    mcud    Move N steps down
	    mhpa    Move N steps from the left
	    mvpa    Move N steps from the top

       The latter six strings are each used with a single argument, N.

       Sometimes the motion is limited to less than the	width or length	 of  a
       page.  Also,  some printers don't accept	absolute motion	to the left of
       the current position. terminfo has capabilities	for  specifying	 these

       Limits to Motion

	    mjump     Limit on use of mcub1, mcuf1, mcuu1,  mcud1
	    maddr      Limit on	use of mhpa, mvpa
	    xhpa	If set,	hpa and	mhpa can't move	left
	    xvpa	If set,	vpa and	mvpa can't move	up

       If  a  printer needs to be in a ``micro mode'' for the motion capabili-
       ties described above to work, there are string capabilities defined  to
       contain	the control sequence to	enter and exit this mode. A boolean is
       available for those printers where using	a carriage  return  causes  an
       automatic return	to normal mode.

	  Entering/Exiting Micro Mode

	    smicm   Enter micro	mode
	    rmicm   Exit micro mode
	    crxm    Using cr exits micro mode

       The movement made when a	character is printed in	the rightmost position
       varies among printers. Some make	no movement, some move to  the	begin-
       ning  of	 the next line,	others move to the beginning of	the same line.
       terminfo	has boolean capabilities for describing	all three cases.

		      What Happens After Character
		       Printed in Rightmost Position

	    sam	    Automatic move to beginning	of same	line

       Some printers can be put	in a mode where	the normal direction of	motion
       is reversed. This mode can be especially	useful when there are no capa-
       bilities	for leftward or	upward motion, because those capabilities  can
       be built	from the motion	reversal capability and	the rightward or down-
       ward motion capabilities.  It is	best to	leave it up to an  application
       to  build  the  leftward	 or upward capabilities, though, and not enter
       them in the terminfo database. This allows several reverse  motions  to
       be  strung  together  without  intervening  wasted steps	that leave and
       reenter reverse mode.

       Entering/Exiting	Reverse	Modes

	    slm	    Reverse sense of horizontal	motions
	    rlm	    Restore sense of horizontal	motions
	    sum	    Reverse sense of vertical motions
	    rum	    Restore sense of vertical motions

	    While sense	of horizontal motions reversed:
	    mcub1   Move 1 step	right
	    mcuf1   Move 1 step	left
	    mcub    Move N steps right
	    mcuf    Move N steps left
	    cub1    Move 1 column right
	    cuf1    Move 1 column left
	    cub	    Move N columns right
	    cuf	    Move N columns left

	    While sense	of vertical motions reversed:
	    mcuu1   Move 1 step	down
	    mcud1   Move 1 step	up
	    mcuu    Move N steps down
	    mcud    Move N steps up
	    cuu1    Move 1 line	down
	    cud1    Move 1 line	up
	    cuu	    Move N lines down
	    cud	    Move N lines up

       The reverse motion modes	should not affect the mvpa and	mhpa  absolute
       motion  capabilities. The reverse vertical motion mode should, however,
       also reverse the	action of the line ``wrapping''	 that  occurs  when  a
       character  is  printed  in the right-most position.  Thus printers that
       have the	standard terminfo capability am	defined	should experience  mo-
       tion  to	the beginning of the previous line when	a character is printed
       in the right-most position under	reverse	vertical motion	mode.

       The action when any other motion	capabilities are used in  reverse  mo-
       tion  modes  is	not  defined;  thus, programs must exit	reverse	motion
       modes before using other	motion capabilities.

       Two miscellaneous capabilities complete the list	of new motion capabil-
       ities.  One of these is needed for printers that	move the current posi-
       tion to the beginning of	a line when certain control  characters,  such
       as  ``line-feed'' or ``form-feed,'' are used. The other is used for the
       capability of suspending	the motion that	normally occurs	after printing
       a character.

       Miscellaneous Motion Strings

	    docr    List of control characters causing cr
	    zerom   Prevent auto motion	after printing next single character

       terminfo	 provides  two	strings	for setting margins on terminals:  one
       for the left and	one for	the right margin. Printers, however, have  two
       additional  margins,  for the top and bottom margins of each page. Fur-
       thermore, some printers require not using motion	strings	 to  move  the
       current	position to a margin and then fixing the margin	there, but re-
       quire the specification of where	a margin should	be regardless  of  the
       current	position. Therefore terminfo offers six	additional strings for
       defining	margins	with printers.

       Setting Margins

	    smgl    Set	left margin at current column
	    smgr    Set	right margin at	current	column
	    smgb    Set	bottom margin at current line
	    smgt    Set	top margin at current line
	    smgbp   Set	bottom margin at line N
	    smglp   Set	left margin at column N
	    smgrp   Set	right margin at	column N
	    smgtp   Set	top margin at line N

       The last	four strings are used with one or more arguments that give the
       position	 of  the  margin or margins to set. If both of smglp and smgrp
       are set,	each is	used with a single argument, N,	that gives the	column
       number of the left and right margin, respectively. If both of smgtp and
       smgbp are set, each is used to set the top and bottom  margin,  respec-
       tively: smgtp is	used with a single argument, N,	the line number	of the
       top margin; however, smgbp is used with two arguments, N	 and  M,  that
       give  the line number of	the bottom margin, the first counting from the
       top of the page and the second counting from the	bottom.	This  accommo-
       dates the two styles of specifying the bottom margin in different manu-
       facturers' printers. When coding	a terminfo entry for  a	 printer  that
       has a settable bottom margin, only the first or second parameter	should
       be used,	depending on the printer. When	writing	 an  application  that
       uses smgbp to set the bottom margin, both arguments must	be given.

       If  only	 one of	smglp and smgrp	is set,	then it	is used	with two argu-
       ments, the column number	of the left and	right margins, in that	order.
       Likewise,  if  only one of smgtp	and smgbp is set, then it is used with
       two arguments that give the top and  bottom  margins,  in  that	order,
       counting	 from  the  top	of the page. Thus when coding a	terminfo entry
       for a printer that requires setting both	left and right or top and bot-
       tom  margins  simultaneously,  only one of smglp	and smgrp or smgtp and
       smgbp should be defined;	the other should be left blank.	 When  writing
       an application that uses	these string capabilities, the pairs should be
       first checked to	see if each in the pair	is set or only one is set, and
       should then be used accordingly.

       In counting lines or columns, line zero is the top line and column zero
       is the left-most	column.	A zero value  for  the	second	argument  with
       smgbp means the bottom line of the page.

       All margins can be cleared with mgc.

   Shadows, Italics, Wide Characters
       Five new	sets of	strings	describe the capabilities printers have	of en-
       hancing printed text.

       Enhanced	Printing

	    sshm    Enter shadow-printing mode
	    rshm    Exit shadow-printing mode
	    sitm    Enter italicizing mode
	    ritm    Exit italicizing mode
	    swidm   Enter wide character mode
	    rwidm   Exit wide character	mode
	    ssupm   Enter superscript mode
	    rsupm   Exit superscript mode
	    supcs   List of characters available as superscripts
	    ssubm   Enter subscript mode
	    rsubm   Exit subscript mode
	    subcs   List of characters available as subscripts

       If a printer requires the sshm control sequence before every  character
       to be shadow-printed, the rshm string is	left blank. Thus programs that
       find a control sequence in sshm but none	in rshm	should	use  the  sshm
       control	sequence  before  every	character to be	shadow-printed;	other-
       wise, the sshm control sequence should be used once before the  set  of
       characters  to  be  shadow-printed,  followed by	rshm. The same is also
       true of each of the sitm/ritm,  swidm/rwidm,  ssupm/rsupm,  and	ssubm/
       rsubm pairs.

       Note  that  terminfo also has a capability for printing emboldened text
       (bold). While shadow printing and emboldened printing  are  similar  in
       that they ``darken'' the	text, many printers produce these two types of
       print in	slightly different ways.  Generally,  emboldened  printing  is
       done  by	 overstriking  the  same  character  one or more times.	Shadow
       printing	likewise usually involves  overstriking,  but  with  a	slight
       movement	up and/or to the side so that the character is ``fatter.''

       It  is  assumed	that enhanced printing modes are independent modes, so
       that it would be	possible, for instance,	 to  shadow  print  italicized

       As  mentioned  earlier,	the  amount of motion automatically made after
       printing	a wide character should	be given in widcs.

       If only a subset	of the printable ASCII characters can  be  printed  as
       superscripts  or	 subscripts,  they  should be listed in	supcs or subcs
       strings,	respectively. If the ssupm or ssubm  strings  contain  control
       sequences,  but	the corresponding supcs	or subcs strings are empty, it
       is assumed that all printable ASCII characters are available as	super-
       scripts or subscripts.

       Automatic  motion made after printing a superscript or subscript	is as-
       sumed to	be the same as for  regular  characters.  Thus,	 for  example,
       printing	 any of	the following three examples will result in equivalent

	      Bi  Bi  Bi

       Note that the existing msgr boolean capability describes	whether	motion
       control sequences can be	used while in ``standout mode.'' This capabil-
       ity is extended to cover	the enhanced printing modes added  here.  msgr
       should  be  set	for  those printers that accept	any motion control se-
       quences without affecting shadow, italicized, widened, superscript,  or
       subscript  printing.  Conversely,  if msgr is not set, a	program	should
       end these modes before attempting any motion.

   Section 2-5:	Alternate Character Sets
       In addition to allowing you to define line graphics (described in  Sec-
       tion 1-12), terminfo lets you define alternate character	sets. The fol-
       lowing capabilities cover printers  and	terminals  with	 multiple  se-
       lectable	or definable character sets.

       Alternate Character Sets

	    scs	    Select character set N
	    scsd    Start definition of	character set N, M characters
	    defc    Define character A,	B dots wide, descender D
	    rcsd    End	definition of character	set N
	    csnm    List of character set names
	    daisy   Printer has	manually changed print-wheels

       The  scs,  rcsd,	and csnm strings are used with a single	argument, N, a
       number from 0 to	63 that	identifies the character set. The scsd	string
       is  also	used with the argument N and another, M, that gives the	number
       of characters in	the set. The defc string is used with three arguments:
       A  gives	 the  ASCII code representation	for the	character, B gives the
       width of	the character in dots, and D  is  zero	or  one	 depending  on
       whether	the  character	is  a ``descender'' or not. The	defc string is
       also followed by	a string of ``image-data'' bytes that describe how the
       character looks (see below).

       Character  set 0	is the default character set present after the printer
       has been	initialized. Not every	printer	 has  64  character  sets,  of
       course;	using  scs  with  an argument that doesn't select an available
       character set should cause a null result	from tparm.

       If a character set has to be defined before it can be  used,  the  scsd
       control	sequence  is to	be used	before defining	the character set, and
       the rcsd	is to be used after. They should also cause a null result from
       tparm  when  used with an argument N that doesn't apply.	If a character
       set still has to	be selected after being	defined, the scs  control  se-
       quence  should  follow  the rcsd	control	sequence. By examining the re-
       sults of	using each of the scs, scsd, and rcsd strings with a character
       set  number  in	a  call	to tparm, a program can	determine which	of the
       three are needed.

       Between use of the scsd and rcsd	strings, the  defc  string  should  be
       used  to	define each character. To print	any character on printers cov-
       ered by terminfo, the ASCII code	is sent	to the printer.	This  is  true
       for  characters	in  an alternate set as	well as	``normal'' characters.
       Thus the	definition of a	character includes the ASCII code that	repre-
       sents  it.  In  addition,  the width of the character in	dots is	given,
       along with an indication	of whether the character should	descend	 below
       the  print  line	(such as the lower case	letter ``g'' in	most character
       sets). The width	of the character in dots also indicates	the number  of
       image-data  bytes  that	will  follow the defc string. These image-data
       bytes indicate where in a dot-matrix pattern ink	should be  applied  to
       ``draw''	 the  character;  the number of	these bytes and	their form are
       defined below under ``Dot-Mapped	Graphics.''

       It's easiest for	the creator of terminfo	entries	to refer to each char-
       acter  set by number; however, these numbers will be meaningless	to the
       application developer. The csnm string alleviates this problem by  pro-
       viding names for	each number.

       When  used  with	 a  character  set number in a call to tparm, the csnm
       string will produce the equivalent name.	These names should be used  as
       a  reference only. No naming convention is implied, although anyone who
       creates a terminfo entry	for a printer should use names consistent with
       the names found in user documents for the printer. Application develop-
       ers should allow	a user to specify a character set by  number  (leaving
       it  up  to the user to examine the csnm string to determine the correct
       number),	or by name, where the application examines the csnm string  to
       determine the corresponding character set number.

       These capabilities are likely to	be used	only with dot-matrix printers.
       If they are not available, the  strings	should	not  be	 defined.  For
       printers	 that  have  manually changed print-wheels or font cartridges,
       the boolean daisy is set.

   Section 2-6:	Dot-Matrix Graphics
       Dot-matrix  printers  typically	have  the  capability  of  reproducing
       ``raster-graphics''  images.  Three  new	numeric	capabilities and three
       new string capabilities can help	a program draw raster-graphics	images
       independent  of the type	of dot-matrix printer or the number of pins or
       dots the	printer	can handle at one time.

       Dot-Matrix Graphics

	    npins   Number of pins, N, in print-head
	    spinv   Spacing of pins vertically in pins per inch
	    spinh   Spacing of dots horizontally in dots per inch
	    porder  Matches software bits to print-head	pins
	    sbim    Start printing bit image graphics, B bits wide
	    rbim    End	printing bit image graphics

       The sbim	sring is used with a single argument, B, the width of the  im-
       age in dots.

       The  model  of  dot-matrix or raster-graphics that terminfo presents is
       similar to the technique	used for most dot-matrix printers:  each  pass
       of  the printer's print-head is assumed to produce a dot-matrix that is
       N dots high and B dots wide. This is typically a	wide, squat, rectangle
       of  dots.  The  height  of  this	 rectangle  in dots will vary from one
       printer to the next; this is given in the npins numeric capability. The
       size of the rectangle in	fractions of an	inch will also vary; it	can be
       deduced from the	spinv and spinh	numeric	capabilities. With these three
       values  an application can divide a complete raster-graphics image into
       several horizontal strips, perhaps interpolating	to account for differ-
       ent dot spacing vertically and horizontally.

       The sbim	and rbim strings are used to start and end a dot-matrix	image,
       respectively. The sbim string is	used with a single argument that gives
       the width of the	dot-matrix in dots. A sequence of ``image-data bytes''
       are sent	to the printer after the  sbim	string	and  before  the  rbim
       string.	The number of bytes is a integral multiple of the width	of the
       dot-matrix; the multiple	and the	form of	each byte is determined	by the
       porder string as	described below.

       The  porder  string is a	comma separated	list of	pin numbers optionally
       followed	by an numerical	offset.	The offset,  if	 given,	 is  separated
       from  the list with a semicolon.	The position of	each pin number	in the
       list corresponds	to a bit in an 8-bit data byte.	The pins are  numbered
       consecutively  from 1 to	npins, with 1 being the	top pin. Note that the
       term ``pin'' is used  loosely  here;  ``ink-jet''  dot-matrix  printers
       don't  have pins, but can be considered to have an equivalent method of
       applying	a single dot of	ink to paper. The bit positions	in porder  are
       in groups of 8, with the	first position in each group the most signifi-
       cant bit	and the	last position the least	significant bit.  An  applica-
       tion produces 8-bit bytes in the	order of the groups in porder.

       An  application computes	the ``image-data bytes'' from the internal im-
       age, mapping vertical dot positions in each print-head pass into	 8-bit
       bytes,  using  a	 1  bit	where ink should be applied and	0 where	no ink
       should be applied. This can be reversed (0 bit for ink, 1  bit  for  no
       ink)  by	 giving	 a  negative  pin  number. If a	position is skipped in
       porder, a 0 bit is used.	If a position has a lower case `x' instead  of
       a pin number, a 1 bit is	used in	the skipped position. For consistency,
       a lower case `o'	can be used to represent  a  0	filled,	 skipped  bit.
       There  must be a	multiple of 8 bit positions used or skipped in porder;
       if not, 0 bits are used to fill the last	byte in	the least  significant
       bits.  The offset, if given, is added to	each data byte;	the offset can
       be negative.

       Some examples may help clarify the use of the porder string.  The  AT&T
       470, AT&T 475 and C.Itoh	8510 printers provide eight pins for graphics.
       The pins	are identified top to bottom by	the 8 bits  in	a  byte,  from
       least  significant to most. The porder strings for these	printers would
       be 8,7,6,5,4,3,2,1. The AT&T 478	and AT&T  479  printers	 also  provide
       eight  pins  for	 graphics. However, the	pins are identified in the re-
       verse  order.  The  porder  strings  for	 these	 printers   would   be
       1,2,3,4,5,6,7,8.	  The  AT&T  5310,  AT&T 5320, DEC LA100, and DEC LN03
       printers	provide	six pins for graphics. The pins	are identified top  to
       bottom by the decimal values 1, 2, 4, 8,	16 and 32. These correspond to
       the low six bits	in an 8-bit byte, although the decimal values are fur-
       ther offset by the value	63. The	porder string for these	printers would
       be ,,6,5,4,3,2,1;63, or alternately o,o,6,5,4,3,2,1;63.

   Section 2-7:	Effect of Changing Printing Resolution
       If the control sequences	to change the  character  pitch	 or  the  line
       pitch are used, the pin or dot spacing may change:

	   Dot-Matrix Graphics
	    Changing the Character/Line	Pitches

	    cpi	    Change character pitch
	    cpix    If set, cpi	changes	spinh
	    lpi	    Change line	pitch
	    lpix    If set, lpi	changes	spinv

       Programs	that use cpi or	lpi should recalculate the dot spacing:

       Dot-Matrix Graphics
	    Effects of Changing	the Character/Line Pitches

	    Before		 After

       Using cpi with cpix clear:
	$bold spinh '$	  $bold	spinh$

       Using cpi with cpix set:
	$bold spinh '$	  $bold	spinh =	bold spinh ' cdot bold orhi over
				 { bold	{orhi '} }$

       Using lpi with lpix clear:
	$bold spinv '$	  $bold	spinv$

       Using lpi with lpix set:
	$bold spinv '$	  $bold	spinv =	bold {spinv '} cdot bold orhi over
				 { bold	{orhi '}}$

       Using chr:
	$bold spinh '$	  $bold	spinh$

       Using cvr:
	$bold spinv '$	  $bold	spinv$

       orhi' and orhi are the values of	the horizontal resolution in steps per
       inch, before using cpi and after	 using	cpi,  respectively.  Likewise,
       orvi'  and  orvi	are the	values of the vertical resolution in steps per
       inch, before using lpi and after	using  lpi,  respectively.  Thus,  the
       changes in the dots per inch for	dot-matrix graphics follow the changes
       in steps	per inch for printer resolution.

   Section 2-8:	Print Quality
       Many dot-matrix printers	can alter the dot spacing of printed  text  to
       produce near ``letter quality'' printing	or ``draft quality'' printing.
       Usually it is important to be able to choose one	or the	other  because
       the rate	of printing generally falls off	as the quality improves. There
       are three new strings used to describe these capabilities.

       Print Quality

	    snlq    Set	near-letter quality print
	    snrmq   Set	normal quality print
	    sdrfq   Set	draft quality print

       The capabilities	are listed in  decreasing  levels  of  quality.	 If  a
       printer doesn't have all	three levels, one or two of the	strings	should
       be left blank as	appropriate.

   Section 2-9:	Printing Rate and Buffer Size
       Because there is	no standard protocol that can be used to keep  a  pro-
       gram  synchronized with a printer, and because modern printers can buf-
       fer data	before printing	it, a program generally	 cannot	 determine  at
       any time	what has been printed. Two new numeric capabilities can	help a
       program estimate	what has been printed.

       Print Rate/Buffer Size

	    cps	    Nominal print rate in characters per second
	    bufsz   Buffer capacity in characters

       cps is the nominal or average rate at which the printer prints  charac-
       ters;  if this value is not given, the rate should be estimated at one-
       tenth the prevailing baud rate. bufsz is	the maximum number  of	subse-
       quent  characters buffered before the guaranteed	printing of an earlier
       character, assuming proper flow control has been	used. If this value is
       not  given  it  is assumed that the printer does	not buffer characters,
       but prints them as they are received.

       As an example, if a printer has a 1000-character	buffer,	 then  sending
       the  letter  ``a'' followed by 1000 additional characters is guaranteed
       to cause	the letter ``a'' to print. If the same printer prints  at  the
       rate  of	 100  characters per second, then it should take 10 seconds to
       print all the characters	in the buffer, less if the buffer is not full.
       By  keeping  track of the characters sent to a printer, and knowing the
       print rate and buffer size, a program can synchronize itself  with  the

       Note  that most printer manufacturers advertise the maximum print rate,
       not the nominal print rate. A good way to get a value to	put in for cps
       is to generate a	few pages of text, count the number of printable char-
       acters, and then	see how	long it	takes to print the text.

       Applications that use these values should recognize the variability  in
       the print rate. Straight	text, in short lines, with no embedded control
       sequences will probably print at	close to the advertised	print rate and
       probably	 faster	than the rate in cps. Graphics data with a lot of con-
       trol sequences, or very long lines of text, will	print  at  well	 below
       the  advertised	rate  and below	the rate in cps. If the	application is
       using cps to decide how long it should take a printer to	print a	 block
       of  text,  the application should pad the estimate.  If the application
       is using	cps to decide how much	text  has  already  been  printed,  it
       should  shrink  the estimate. The application will thus err in favor of
       the user, who wants, above all, to see all the output  in  its  correct

       /usr/share/lib/terminfo/?/*     compiled	terminal description database

       /usr/share/lib/.COREterm/?/*    subset of compiled terminal description

       /usr/share/lib/tabset/*	       tab settings for	some terminals,	 in  a
				       format  appropriate to be output	to the
				       terminal	 (escape  sequences  that  set
				       margins and tabs)

       ls(1),  pg(1),  stty(1),	tput(1), tty(1),  vi(1), infocmp(1M), tic(1M),
       printf(3C), curses(3CURSES), curses(3XCURSES)

       The most	effective way to prepare a terminal description	is by  imitat-
       ing the description of a	similar	terminal in terminfo and to build up a
       description gradually, using partial descriptions with  a  screen  ori-
       ented  editor,  such  as	 vi, to	check that they	are correct. To	easily
       test a new terminal description the environment variable	TERMINFO   can
       be  set to the pathname of a directory containing the compiled descrip-
       tion, and programs will look there rather than  in  /usr/share/lib/ter-

SunOS 5.10			  9 Jul	1996			   terminfo(4)


Want to link to this manual page? Use this URL:

home | help