


     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



     NNNNAAAAMMMMEEEE
	  figlet - print in large characters made up of	ordinary
	  screen characters


     SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
	  ffffiiiigggglllleeeetttt [ ----ccccllllnnnnpppprrrrttttvvvvxxxxDDDDEEEELLLLNNNNRRRRXXXX ] [ ----dddd _f_o_n_t_d_i_r_e_c_t_o_r_y	]
	       [ ----ffff _f_o_n_t_f_i_l_e ] [ ----mmmm _s_m_u_s_h_m_o_d_e ]	[ ----wwww _o_u_t_p_u_t_w_i_d_t_h ]
	       [ ----CCCC _c_o_n_t_r_o_l_f_i_l_e	] [ ----IIII _i_n_f_o_c_o_d_e	]


     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
	  ffffiiiigggglllleeeetttt prints	its input using	large characters made up of
	  ordinary screen characters.  ffffiiiigggglllleeeetttt output is	generally
	  reminiscent of the sort of ``signatures'' many people	like
	  to put at the	end of e-mail and UseNet messages.  It is also
	  reminiscent of the output of some banner programs, although
	  it is	oriented normally, not sideways.

	  ffffiiiigggglllleeeetttt can print in a	variety	of fonts, both left-to-right
	  and right-to-left, with adjacent characters kerned and
	  ``smushed'' together in various ways.	 ffffiiiigggglllleeeetttt	fonts are
	  stored in separate files, which can be identified by the
	  suffix ``....ffffllllffff''.  Most ffffiiiigggglllleeeetttt	font files will	be stored in
	  ffffiiiigggglllleeeetttt''''ssss default font	directory.

	  ffffiiiigggglllleeeetttt can also use ``control	files'', which tell it to map
	  certain input	characters to certain other characters,
	  similar to the Unix ttttrrrr command.  Control files can be
	  identified by	the suffix ``....ffffllllcccc''.  Most ffffiiiigggglllleeeetttt control
	  files	will be	stored in ffffiiiigggglllleeeetttt''''ssss default font	directory.


     OOOOTTTTHHHHEEEERRRR FFFFOOOONNNNTTTTSSSS &&&& MMMMAAAAIIIILLLLIIIINNNNGGGG LLLLIIIISSSSTTTT
	  As of	this writing you can get many fonts which are not in
	  the basic ffffiiiigggglllleeeetttt package by anonymous	FTP from
	  ftp.isu.edu:pub/figlet/fonts.	 ftp.isu.edu:pub/figlet	should
	  also contain the latest version of ffffiiiigggglllleeeetttt and	other
	  utilities related to ffffiiiigggglllleeeetttt.	Of special interest are	non-
	  Roman	fonts.	As of this writing, there are Hebrew and
	  Cyrillic (Russian) fonts; more are expected.

	  We run an e-mail list	dedicated to ffffiiiigggglllleeeetttt software and font
	  announcements, as well as general discussion about ffffiiiigggglllleeeetttt.
	  If you would like to be on this list,	send e-mail to
	  lllliiiissssttttsssseeeerrrrvvvv@@@@vvvvmmmmdddd....ccccssssoooo....uuuuiiiiuuuucccc....eeeedddduuuu with the message body

	       ssssuuuubbbbssssccccrrrriiiibbbbeeee ffffiiiigggglllleeeetttt----llll _Y_O_U_R _N_A_M_E

	  where	_Y_O_U_R _N_A_M_E should be replaced with your name.  For
	  those	who don't want to be bothered with the discussions,
	  the list can be configured so	that you only see software



     Page 1					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  update notices, or only software and font announcements.


     UUUUSSSSAAAAGGGGEEEE
	  Just start up	ffffiiiigggglllleeeetttt (type ``ffffiiiigggglllleeeetttt'') and then type
	  whatever you want.  Alternatively, pipe a file or the	output
	  of another command through ffffiiiigggglllleeeetttt.  See EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS for other
	  things to do.


     OOOOPPPPTTTTIIIIOOOONNNNSSSS
	  ffffiiiigggglllleeeetttt reads command line options from left to right,	and
	  only the last	option that affects a parameter	has any
	  effect.  Every option	has an inverse,	so that, for example,
	  if ffffiiiigggglllleeeetttt is customized with a C-shell aaaalllliiiiaaaassss,	all the
	  options are still available.

	  Commonly-used	options	are ----ffff,	----cccc, ----mmmm0000, ----tttt, ----pppp	and ----vvvv.


	  ----ffff _f_o_n_t_f_i_l_e
	       Select the font.	 The ....ffffllllffff suffix may be	left off of
	       _f_o_n_t_f_i_l_e, in which case ffffiiiigggglllleeeetttt automatically appends
	       it.  ffffiiiigggglllleeeetttt looks for the file first in the default
	       font directory and then in the current directory, or,
	       if _f_o_n_t_f_i_l_e was given as	a full pathname, in the	given
	       directory.  If the ----ffff option is not specified, ffffiiiigggglllleeeetttt
	       uses the	font that was specified	when it	was compiled.
	       To find out which font this is, use the ----IIII3333 option.


	  ----dddd _f_o_n_t_d_i_r_e_c_t_o_r_y
	       Change the default font directory.  ffffiiiigggglllleeeetttt looks	for
	       fonts first in the default directory and	then in	the
	       current directory.  If the ----dddd option is not specified,
	       ffffiiiigggglllleeeetttt uses the directory that was specified when it
	       was compiled.  To find out which	directory this is, use
	       the ----IIII2222 option.


	  ----cccc
	  ----llll
	  ----rrrr
	  ----xxxx   These options handle the	justification of ffffiiiigggglllleeeetttt
	       output.	----cccc centers the output horizontally.  ----llll	makes
	       the output flush-left.  ----rrrr makes	it flush-right.	 ----xxxx
	       (default) sets the justification	according to whether
	       left-to-right or	right-to-left text is selected.
	       Left-to-right text will be flush-left, while right-to-
	       left text will be flush-right.  (Left-to-right versus
	       right-to-left text is controlled	by ----LLLL, ----RRRR and ----XXXX.)




     Page 2					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  ----tttt
	  ----wwww _o_u_t_p_u_t_w_i_d_t_h
	       These options control the _o_u_t_p_u_t_w_i_d_t_h, or the screen
	       width ffffiiiigggglllleeeetttt assumes when formatting its	output.
	       ffffiiiigggglllleeeetttt uses the _o_u_t_p_u_t_w_i_d_t_h to determine	when to	break
	       lines and how to	center the output.  Normally, ffffiiiigggglllleeeetttt
	       assumes 80 columns so that people with wide terminals
	       won't annoy the people they e-mail ffffiiiigggglllleeeetttt output	to.
	       ----tttt sets the _o_u_t_p_u_t_w_i_d_t_h to the terminal width.  If the
	       terminal	width cannot be	determined, the	previous
	       _o_u_t_p_u_t_w_i_d_t_h is retained.	 ----wwww sets the _o_u_t_p_u_t_w_i_d_t_h to
	       the given integer.  An _o_u_t_p_u_t_w_i_d_t_h of 1 is a special
	       value that tells	ffffiiiigggglllleeeetttt to print	each non-space
	       character, in its entirety, on a	separate line, no
	       matter how wide it is.


	  ----pppp
	  ----nnnn   These options control how figlet	handles	newlines.  ----pppp
	       puts ffffiiiigggglllleeeetttt into	``paragraph mode'', which eliminates
	       some unnecessary	line breaks when piping	a multi-line
	       file through ffffiiiigggglllleeeetttt.  In	paragraph mode,	ffffiiiigggglllleeeetttt treats
	       line breaks within a paragraph as if they were merely
	       blanks between words.  (Specifically, ----pppp	causes ffffiiiigggglllleeeetttt
	       to convert any newline which is not preceded by a
	       newline and not followed	by a space character into a
	       blank.) ----nnnn puts ffffiiiigggglllleeeetttt back to normal (default),	in
	       which every newline ffffiiiigggglllleeeetttt reads	causes it to produce a
	       line break.


	  ----DDDD
	  ----EEEE   ----DDDD switches to the German (Deutsch) character set.
	       Turns `[', `\' and `]' into umlauted A, O and U,
	       respectively.  `{', `|' and `}' turn into the
	       respective lower	case versions of these.	 `~' turns
	       into s-z.  (Of course, all this assumes the font	author
	       has placed German characters in these positions in the
	       font file.  Many	font authors do	not.) ----EEEE switches back
	       to English (default), i.e., the standard	ASCII
	       character set.


	  ----CCCC _c_o_n_t_r_o_l_f_i_l_e
	  ----NNNN   These options deal with ffffiiiigggglllleeeetttt _c_o_n_t_r_o_l_f_i_l_e_s.  A
	       _c_o_n_t_r_o_l_f_i_l_e is a	file containing	a list of commands
	       that ffffiiiigggglllleeeetttt executes each time it reads a character.
	       These commands can map certain input characters to
	       other characters, similar to the	Unix ttttrrrr	command	or the
	       ffffiiiigggglllleeeetttt ----DDDD option.  ffffiiiigggglllleeeetttt maintains a list of
	       _c_o_n_t_r_o_l_f_i_l_e_s, which is empty when ffffiiiigggglllleeeetttt	starts up.  ----CCCC
	       adds the	given _c_o_n_t_r_o_l_f_i_l_e to the list.	----NNNN clears the



     Page 3					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	       _c_o_n_t_r_o_l_f_i_l_e list, cancelling the	effect of any previous
	       ----CCCC.  ffffiiiigggglllleeeetttt executes the	commands in all	_c_o_n_t_r_o_l_f_i_l_e_s
	       in the list.  See CCCCOOOONNNNTTTTRRRROOOOLLLLFFFFIIIILLLLEEEE FFFFOOOORRRRMMMMAAAATTTT for	details	on how
	       to write	a _c_o_n_t_r_o_l_f_i_l_e.


	  ----mmmm _s_m_u_s_h_m_o_d_e
	       Specifies how ffffiiiigggglllleeeetttt should ``smush'' and kern
	       consecutive characters together.	 On the	command	line,
	       ----mmmm0000 can be useful, as it	tells figlet to	kern
	       characters without smushing them	together.  Otherwise,
	       this option is rarely needed, as	a ffffiiiigggglllleeeetttt font file
	       specifies the best smushmode to use with	the font.  ----mmmm
	       is, therefore, most useful to font designers testing
	       the various _s_m_u_s_h_m_o_d_e_s with their font.	_s_m_u_s_h_m_o_d_e can
	       be ----2222 through 66663333.

	       ----2222 Get mode from	font file (default).
		    Every ffffiiiigggglllleeeetttt font file specifies the best
		    _s_m_u_s_h_m_o_d_e to use with the font.  This will be one
		    of the _s_m_u_s_h_m_o_d_e_s (----1111 through 66663333) described	in the
		    following paragraphs.

	       ----1111 No smushing or kerning.
		    Characters are simply concatenated together.

	       0000 Kern only.
		    Characters are pushed together until they touch.

		    In any non-negative	_s_m_u_s_h_m_o_d_e ffffiiiigggglllleeeetttt kerns
		    adjacent font characters, i.e., it pushes adjacent
		    font characters together until their non-blank
		    portions touch.  At	that point, it may or may not
		    push the two font characters 1 screen character
		    closer, depending on the _s_m_u_s_h_m_o_d_e.	 Pushing font
		    characters one step	closer requires	``smushing''
		    two	non-blank screen characters into a single
		    screen character.  ffffiiiigggglllleeeetttt has 6 ways of doing
		    this, represented by 1, 2, 4, 8, 16	and 32.	 The
		    various non-negative _s_m_u_s_h_m_o_d_e_s (0000-66663333) are
		    obtained by	adding up the numbers corresponding to
		    the	sort of	smushing ffffiiiigggglllleeeetttt	should do.  In
		    particular _s_m_u_s_h_m_o_d_e 0000 kerns characters without
		    smushing them into each other.

	       1111 Smush equal characters.
		    Two	screen characters are smushed into a single
		    character if they are the same.  The resulting
		    character is the same as both of the original
		    characters.	 This mode does	not smush the
		    character known as a _h_a_r_d_b_l_a_n_k, which is a
		    character that prints as a blank, but is not



     Page 4					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



		    smushed (except in mode 32).  See FFFFOOOONNNNTTTT FFFFIIIILLLLEEEE	FFFFOOOORRRRMMMMAAAATTTT
		    for	more information on _h_a_r_d_b_l_a_n_k_s.

	       2222 Smush underscores.
		    An underscore will be smushed into (and replaced
		    by)	any of ``|/\[]{}()<>''.

	       4444 Hierarchy smushing.
		    Smushes certain characters together	according to a
		    hierarchy containing 6 classes: ``|'', ``/\'',
		    ``[]'', ``{}'', ``()'', ``<>''.  A member of any
		    class can be smushed into and replaced by a	member
		    of any later class.

	       8888 Opposite pair smushing, type I.
		    Smushes opposing brackets (``[]''),	braces
		    (``{}'') and parentheses (``()'') together,
		    replacing them with	a vertical bar (`|').

	       11116666 Opposite pair	smushing, type II.
		    Smushes opposing slashes (``/\'') and greater-
		    than/less-than (``><'') together, replacing	them
		    with an upper-case `X'.  ``><'' are	only smushed
		    together when they are in that order, i.e.,	``<>''
		    will not be	smushed.

	       33332222 Hardblank smushing.
		    Smushes two	_h_a_r_d_b_l_a_n_k_s together, replacing them
		    with a single _h_a_r_d_b_l_a_n_k.  See FFFFOOOONNNNTTTT FFFFIIIILLLLEEEE FFFFOOOORRRRMMMMAAAATTTT for
		    more information on	_h_a_r_d_b_l_a_n_k_s.


	  ----vvvv
	  ----IIII _i_n_f_o_c_o_d_e
	       These options print various information about ffffiiiigggglllleeeetttt,
	       then exit.  If several of these options are given on
	       the command line, only the last is executed, and	only
	       after all other command-line options have been dealt
	       with.

	       ----vvvv prints version and copyright information, as well as
	       a ``Usage: ...''	line.  ----IIII prints the information
	       corresponding to	the given _i_n_f_o_c_o_d_e in a	consistent,
	       reliable	(i.e., guaranteed to be	the same in future
	       releases) format.  ----IIII is	primarily intended to be used
	       by programs that	use ffffiiiigggglllleeeetttt.  _i_n_f_o_c_o_d_e can be any of
	       the following.

	       ----1111 Normal operation (default).
		    This _i_n_f_o_c_o_d_e indicates that ffffiiiigggglllleeeetttt	should operate
		    normally, not giving any informational printout,
		    printing its input in the selected font.



     Page 5					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	       0000 Version and copyright.
		    This is identical to ----vvvv.

	       1111 Version (integer).
		    This will print the	version	of your	copy of	ffffiiiigggglllleeeetttt
		    as a decimal integer.  The main version number is
		    multiplied by 10000, the sub-version number	is
		    multiplied by 100, and the sub-sub-version number
		    is multiplied by 1.	 These are added together, and
		    the	result is printed out.	For example, ffffiiiigggglllleeeetttt
		    2.1	will print ``22220000111100000000''.  If there	is ever	a
		    version 2.1.1, it will print ``22220000111100001111''.
		    Similarly, version 3.7.2 would print ``33330000777700002222''.
		    These numbers are guaranteed to be ascending, with
		    later versions having higher numbers.  Note	that
		    the	first major release of ffffiiiigggglllleeeetttt, version 2.0,
		    did	not have the ----IIII	option.

	       2222 Default font directory.
		    This will print the	default	font directory.	 It is
		    affected by	the ----dddd option.

	       3333 Font.
		    This will print the	name of	the font figlet	would
		    use.  It is	affected by the	----ffff option.  This is
		    not	a filename; the	``....ffffllllffff'' suffix	is not
		    printed.

	       4444 Output	width.
		    This will print the	value ffffiiiigggglllleeeetttt would use for
		    _o_u_t_p_u_t_w_i_d_t_h, the number of columns wide ffffiiiigggglllleeeetttt
		    assumes the	screen is.  It is affected by the ----wwww
		    and	----tttt options.

	       If _i_n_f_o_c_o_d_e is any other	positive value,	ffffiiiigggglllleeeetttt will
	       simply exit without printing anything.


	  ----LLLL
	  ----RRRR
	  ----XXXX   These options control whether ffffiiiigggglllleeeetttt prints left-to-
	       right or	right-to-left.	----LLLL selects left-to-right
	       printing.  ----RRRR selects right-to-left printing.  ----XXXX
	       (default) makes ffffiiiigggglllleeeetttt use whichever is specified in
	       the font	file.


     EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
	  To use ffffiiiigggglllleeeetttt	with its default settings, simply type

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt




     Page 6					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  and then type	whatever you like.

	  To change the	font, use the ----ffff option, for example,

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ffff ssssccccrrrriiiipppptttt


	  Use the ----cccc option if you would prefer	centered output:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----cccc


	  We have found	that the most common use of ffffiiiigggglllleeeetttt is making
	  up large text	to be placed in	e-mail messages.  For this
	  reason, ffffiiiigggglllleeeetttt defaults to 80	column output.	If you are
	  using	a wider	terminal, and would like ffffiiiigggglllleeeetttt	to use the
	  full width of	your terminal, use the ----tttt option:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----tttt


	  If you don't want ffffiiiigggglllleeeetttt to smush font characters into each
	  other, use the ----mmmm0000 option:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----mmmm0000


	  If ffffiiiigggglllleeeetttt gets its input from	a file,	it is often a good
	  idea to use ----pppp:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----pppp <<<< mmmmyyyyffffiiiilllleeee


	  Of course, the above can be combined:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ppppttttmmmm0000 ----ffff	sssshhhhaaaaddddoooowwww <<<< aaaannnnooootttthhhheeeerrrrffffiiiilllleeee
	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ccccffff ssssllllaaaannnntttt



	OOOOtttthhhheeeerrrr TTTThhhhiiiinnnnggggssss ttttoooo	TTTTrrrryyyy
	  On many systems nice effects can be obtained from the	lllleeeeaaaannnn
	  font by piping it through ttttrrrr.	 Some you might	want to	try
	  are the following:

	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ffff lllleeeeaaaannnn |||| ttttrrrr '''' ____////'''' '''' (((())))''''
	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ffff lllleeeeaaaannnn |||| ttttrrrr '''' ____////'''' ''''....////\\\\\\\\''''
	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ffff lllleeeeaaaannnn |||| ttttrrrr '''' ____////'''' '''' ////////''''
	       eeeexxxxaaaammmmpppplllleeee%%%%	ffffiiiigggglllleeeetttt ----ffff lllleeeeaaaannnn |||| ttttrrrr '''' ____////'''' ''''////  ''''

	  Similar things can be	done with the bbbblllloooocccckkkk font and many of
	  the other ffffiiiigggglllleeeetttt fonts.



     Page 7					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



     FFFFOOOONNNNTTTT FFFFIIIILLLLEEEE FFFFOOOORRRRMMMMAAAATTTT
	  If you would like to design a	ffffiiiigggglllleeeetttt font, it	is usually
	  best to begin	with an	already-existing font.	Except for the
	  first	line of	a font file, most of the file format should be
	  obvious.  If you design a font, please let us	know about it!
	  (See AAAAUUUUTTTTHHHHOOOORRRRSSSS for e-mail addresses.)

	  A ffffiiiigggglllleeeetttt font	filename must have the suffix ``....ffffllllffff''.

	  A ffffiiiigggglllleeeetttt font	file begins with a header.  The	header
	  consists of one line giving information about	the font,
	  followed by zero or more comment lines, which	ffffiiiigggglllleeeetttt
	  ignores.  Following the header is the	font data.


	TTTThhhheeee HHHHeeeeaaaaddddeeeerrrr
	  The first line of a ffffiiiigggglllleeeetttt font file is of the following
	  form:

	       ffffllllffff2222aaaa_h_a_r_d_b_l_a_n_k _h_e_i_g_h_t _u_p__h_t _m_a_x_l_e_n _s_m_u_s_h_m_o_d_e _c_m_t__c_o_u_n_t _r_t_o_l

	  where	_h_a_r_d_b_l_a_n_k is a character, and the remaining values are
	  integers, for	example:

	       ffffllllffff2222aaaa$$$$ 6666	5555 22220000 11115555	3333 0000

	  The last value, _r_t_o_l,	may be omitted,	in which case it is
	  assumed to be	0000.

	       ffffllllffff2222aaaa$$$$ 6666	5555 22220000 11115555	3333


	  For those desiring a quick explanation, the above line
	  indicates that this font has characters which	are 6 lines
	  tall,	5 of which are above the baseline, no line in the font
	  data is more than 20 characters long,	the default smushmode
	  is 15	(kern and smush	in various ways), there	are 3 comment
	  lines, and this font is to be	printed	left-to-right.	More
	  in-depth explanations	follow.

	  The first five characters of a font file should be
	  ``ffffllllffff2222aaaa''.  ``ffffllllffff2222'' is the _m_a_g_i_c _n_u_m_b_e_r of a	ffffiiiigggglllleeeetttt 2 font
	  file.	 The next character (`aaaa') is currently ignored.	 It
	  may mean something in	future versions	of ffffiiiigggglllleeeetttt.  If it
	  does,	you can	be sure	your fonts will	still work if this
	  character is `aaaa'.

	  Immediately following	this is	the _h_a_r_d_b_l_a_n_k (character).
	  Note that there are no blanks	between	``ffffllllffff2222aaaa'' and the
	  _h_a_r_d_b_l_a_n_k.  ffffiiiigggglllleeeetttt can smush together	consecutive characters
	  in various ways.  Normally, any character can	be smushed
	  into a blank.	 A _h_a_r_d_b_l_a_n_k prints as a blank,	but cannot be



     Page 8					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  smushed into any character except a blank, and, if _s_m_u_s_h_m_o_d_e
	  32 is	enabled, another _h_a_r_d_b_l_a_n_k.  (For example, the `r' in
	  ssssccccrrrriiiipppptttt....ffffllllffff contains a	_h_a_r_d_b_l_a_n_k, `$' in that font.  To see
	  why this is necessary, create	a copy of ssssccccrrrriiiipppptttt....ffffllllffff with this
	  _h_a_r_d_b_l_a_n_k replaced by	a blank.  In this new font, the	``tr''
	  combination looks awful.)

	  By convention, the _h_a_r_d_b_l_a_n_k is a `$', but it	can be any
	  character besides blank, newline and null.  If you want the
	  entire printing ASCII	set available to use, make the
	  _h_a_r_d_b_l_a_n_k a <delete> character.

	  Then comes the _h_e_i_g_h_t	(integer).  This is the	number of
	  screen lines high that each character	in the font is.

	  _u_p__h_t	(integer) is the number	of lines from the baseline of
	  a character to the top of the	character, i.e., it is the
	  height of a character, ignoring any descenders.  This	number
	  is currently ignored by ffffiiiigggglllleeeetttt, but future versions may use
	  it.

	  _m_a_x_l_e_n (integer) is the maximum length of a line in the font
	  file (excluding the first line and the comments lines, which
	  can be as long as you	want).	You may	want to	make this a
	  little too large as a	safety measure.

	  _s_m_u_s_h_m_o_d_e (integer) determines how much ffffiiiigggglllleeeetttt smushes the
	  font.	 Possible _s_m_u_s_h_m_o_d_e_s are ----1111 through 66663333.	 Typically,
	  you'll want to use 0000 (kern font characters without smushing
	  them together), ----1111 (no kerning or smushing) or 11115555 (smush
	  various pairs	of characters together into single
	  characters).	To try out different _s_m_u_s_h_m_o_d_e_s	with your
	  font,	use the	----mmmm command-line	option.	 See OOOOPPPPTTTTIIIIOOOONNNNSSSS for a
	  more detailed	explanation of these _s_m_u_s_h_m_o_d_e_s.  (Note	that a
	  _s_m_u_s_h_m_o_d_e of ----2222 can be given on the command line, but	not in
	  a font file.)

	  Between the first line and the actual	characters of the font
	  are the comment lines.  _C_m_t__c_o_u_n_t specifies how many lines
	  there	are.  These lines are optional,	may be as long as you
	  want,	and are	ignored	by ffffiiiigggglllleeeetttt.

	  _r_t_o_l (integer) tells which direction the font	is to be
	  printed.  0 means left-to-right, and 1 means right-to-left.
	  Left-to-right	text is	printed	flush-left by default, while
	  right-to-left	text is	printed	flush-right by default.	 _r_t_o_l
	  may be omitted, in which case	0 (left-to-right) is assumed.
	  Earlier versions of ffffiiiigggglllleeeetttt (i.e., version 2.0) ignore	_r_t_o_l.

	  Thus,	a complete ffffiiiigggglllleeeetttt font file header will	look something
	  like the following:




     Page 9					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	       ffffllllffff2222aaaa$$$$ 6666	5555 22220000 11115555	3333
	       EEEExxxxaaaammmmpppplllleeee bbbbyyyy GGGGlllleeeennnnnnnn	CCCChhhhaaaappppppppeeeellllllll <<<<ggggggggcccc@@@@uuuuiiiiuuuucccc....eeeedddduuuu>>>>	8888////99994444
	       PPPPeeeerrrrmmmmiiiissssssssiiiioooonnnn iiiissss hhhheeeerrrreeeebbbbyyyy ggggiiiivvvveeeennnn ttttoooo mmmmooooddddiiiiffffyyyy tttthhhhiiiissss ffffoooonnnntttt,,,, aaaassss lllloooonnnngggg aaaassss tttthhhheeee
	       mmmmooooddddiiiiffffiiiieeeerrrr''''ssss nnnnaaaammmmeeee iiiissss ppppllllaaaacccceeeedddd oooonnnn aaaa ccccoooommmmmmmmeeeennnntttt lllliiiinnnneeee....


	TTTThhhheeee FFFFoooonnnntttt DDDDaaaattttaaaa
	  The font data	begins on the next line	after the comments and
	  continues to the end of the file.  The characters from ` '
	  to `~' are given in standard ASCII order, followed by	the
	  extra	German characters: umlauted `A', `O', `U', `a',	`o'
	  and `u' and s-z.  Following these are	the optional code-
	  tagged characters.  Each character uses _h_e_i_g_h_t lines,	where
	  _h_e_i_g_h_t was given on the first	line of	the font file.	Each
	  code-tagged character	is preceeded by	an extra line with the
	  character's code (a number) on it.  The characters in	the
	  file are given exactly as they should	be printed out,	with
	  two exceptions: (1) _h_a_r_d_b_l_a_n_k_s should	be the _h_a_r_d_b_l_a_n_k
	  character, not a blank, and (2) every	line has an _e_n_d_m_a_r_k
	  character.

	  In most ffffiiiigggglllleeeetttt fonts,	the _e_n_d_m_a_r_k is either `@' or '#'.
	  ffffiiiigggglllleeeetttt eliminates the	last block of consecutive equal
	  characters from each line (other than	the header lines) when
	  the file is read in.	By convention, the last	line of	a font
	  character has	2 _e_n_d_m_a_r_k_s, while all the rest have one.  This
	  makes	it easy	to see where characters	begin and end.	No
	  line should have more	than 2 _e_n_d_m_a_r_k_s.

	  The code-tagged characters are optional, and are ignored by
	  earier versions of ffffiiiigggglllleeeetttt (i.e., version 2.0).  The code-
	  tagged characters begin just after the German	characters.
	  There	can be as many or as few of these as you like.	The
	  first	line of	a code-tagged character	has a single number on
	  it, the character's code, which is the number	by which
	  figlet will refer to it.  This number	can be in decimal,
	  octal	or hexadecimal,	using the standard ssssccccaaaannnnffff conventions
	  for such numbers.  On	the next line the character itself
	  begins, in the same format as	the un-tagged characters.

	  If two or more font characters have the same tag, the	last
	  one in the font is the one used.  For	this purpose, the
	  normal ASCII characters are considered to have tags equal to
	  their	ASCII value, while the German characters are given
	  tags -255 through -249.

	  There	is no required encoding	for the	code-tagged
	  characters.  ffffiiiigggglllleeeetttt simply prints the	character with the
	  given	code when it is	told to.  However, in most of the
	  fonts, we have used ISO Latin-1 for characters 160-255,
	  following a suggestion of Zhahai Stewart.  Stewart has
	  suggested using Unicode for other characters.



     Page 10					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  The zero tag is treated specially.  It is ffffiiiigggglllleeeetttt''''ssss ``missing
	  character''.	Whenever ffffiiiigggglllleeeetttt	is told	to print a character
	  which	doesn't	exist in the current font, it will print
	  character zero.  If character	zero doesn't exist, nothing
	  will be printed.


	NNNNooootttteeeessss
	  It is	very important that every character in a font has the
	  same height, and, once the _e_n_d_m_a_r_k_s are removed, that	all
	  the lines constituting a single font character have the same
	  length.  Be careful also that	no lines in the	font file have
	  trailing blanks, as ffffiiiigggglllleeeetttt will take these to	be the
	  _e_n_d_m_a_r_k_s.  Many problems like	these can be found easily
	  using	cccchhhhkkkkffffoooonnnntttt, part of the standard ffffiiiigggglllleeeetttt package, and also
	  available, as	of this	writing, by anonymous FTP from
	  ftp.isu.edu:pub/figlet/util.

	  If you don't want to define all the characters, make the
	  undefined characters empty, i.e., each line of the character
	  should consist only of one or	two _e_n_d_m_a_r_k_s.

	  The blank character should usually be	made entirely of
	  _h_a_r_d_b_l_a_n_k_s.  (Most slanted fonts are an exception to this.)

	  If you design	a font,	it is helpful if you put your name and
	  an e-mail address on a comment line.	If you will allow
	  others to modify your	font, you may want to say so on	a
	  comment line.

	  If a font contains a non-Roman alphabet stored in locations
	  normally taken by ASCII, we have found it helpful to include
	  a ``translation'' table as one of the	characters of the
	  font.	 Typically, the	``~~~~'' character	contains a list	of all
	  the special characters in the	font, along with the ASCII
	  characters they correspond to.  It is	a good idea to keep
	  this table no	more than 79 columns wide.  (Thanks to
	  Gedaliah Friedenberg for this	idea.)

	  Again, if you	design a font, please let us know!


     CCCCOOOONNNNTTTTRRRROOOOLLLLFFFFIIIILLLLEEEE FFFFOOOORRRRMMMMAAAATTTT
	  (Note: This section isn't terribly well-written.  I really
	  don't	have time right	now to do much with it.	 If you	want
	  to write a _c_o_n_t_r_o_l_f_i_l_e, just look at the existing files and
	  ignore the ffff command,	and you'll probably do pretty well.
	  Anyone needing extra help can	write us at <figlet@uiuc.edu>.
	  Also,	anyone willing to revise this section or the FONT FILE
	  FORMAT section is welcome to do so.  Please let us know
	  about	your efforts if	you give it a try.  -GGC-)




     Page 11					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  _C_o_n_t_r_o_l_f_i_l_e_s are files containing lists of commands that
	  ffffiiiigggglllleeeetttt executes each time it reads a character.  A
	  _c_o_n_t_r_o_l_f_i_l_e is specified to ffffiiiigggglllleeeetttt using the ----CCCC command line
	  option (see OPTIONS).	 In the	file itself the	first line
	  identifies the file as a ffffiiiigggglllleeeetttt _c_o_n_t_r_o_l_f_i_l_e, and the
	  remaining lines are the commands, one	per line.  Currently,
	  the only recognized commands tell ffffiiiigggglllleeeetttt to translate	one
	  character to another (similar	to the Unix ttttrrrr command).  In
	  future versions of ffffiiiigggglllleeeetttt, more commands may be added.  As
	  with font files, when	writing	a _c_o_n_t_r_o_l_f_i_l_e, it is usually
	  best to begin	with an	existing file.

	  The filename of a ffffiiiigggglllleeeetttt _c_o_n_t_r_o_l_f_i_l_e must have the suffix
	  ``....ffffllllcccc''.

	  The first five characters of a _c_o_n_t_r_o_l_f_i_l_e should be
	  ``ffffllllcccc2222aaaa''.  ``ffffllllcccc2222'' is the _m_a_g_i_c _n_u_m_b_e_r of a	ffffiiiigggglllleeeetttt
	  _c_o_n_t_r_o_l_f_i_l_e.	The next character (`aaaa') is currently ignored.
	  It may mean something	in future versions of ffffiiiigggglllleeeetttt.  If it
	  does,	you can	be sure	your files will	still work if this
	  character is `aaaa'.

	  Each of the following	lines of the file consists of a	one-
	  character command followed by	whatever parameters the
	  command requires, excepting blank lines, which are ignored.
	  There	are currently three recognized commands: ####, tttt and ffff.


	  #### comment
	       Any line	beginning with #### is ignored.


	  tttt translate
	       This is similar to the Unix ttttrrrr command.	It directs
	       figlet to ``translate'' one character to	another.
	       ``tttt'' is	followed by one	or more	blanks,	then by	a
	       character (or range of characters, e.g.,	``AAAA----ZZZZ'') then
	       one or more blanks, then	another	character (or range).

	       For example,

		    tttt ####	$$$$

	       will convert `#'	to `$',	while

		    tttt AAAA----ZZZZ aaaa----zzzz

	       will convert upper-case ASCII to	lower-case ASCII.  A
	       range should always be followed by another range	of the
	       same size.

	       A number	of backslash (`\') options are available for



     Page 12					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	       specifying characters.  Any of the standard ``C''
	       language	backslash-character conventions	are legal,
	       e.g., ``\\\\nnnn'' for	newline, etc.  Also, backslash-blank
	       can be used to specify a	blank character.  Backslash
	       followed	by a number in any of the standard ssssccccaaaannnnffff
	       formats (decimal, octal or hexadecimal) specifies the
	       character with the given	code.  For example,

		    tttt \\\\nnnn----\\\\  \\\\66665555----WWWW

	       will convert all	characters from	newline	to blank into
	       the corresponding characters from `A' to	`W' (`A' has
	       code 65).

	       If a number of consecutive tttt commands are given,	then
	       for each	character input, only the first	applicable
	       command,	if any,	will be	executed.  As a	result,

		    tttt AAAA	BBBB
		    tttt BBBB	AAAA

	       will swap the characters	`A' and	`B'.  If ffffiiiigggglllleeeetttt	reads
	       an `A' the first	command	will change `A'	to `B',	in
	       which case the second will not be executed.  In the
	       following list,

		    tttt AAAA	BBBB
		    tttt AAAA	CCCC

	       the second command is never executed.  In short,	a
	       sequence	of tttt commands ``does what it ought to''.


	  ffff freeze
	       More complex files, in which a single character is
	       acted upon by several tttt commands, can be	set up using
	       the ffff command.  ffff ``freezes'' the current character,
	       executing the remaining commands	in the _c_o_n_t_r_o_l_f_i_l_e as
	       if they were in a separate file.	 The ffff command has no
	       parameters, and anything	following it on	the same line
	       is ignored.  (Note: If you, along with so many others,
	       cannot figure out what the ffff command does, or why
	       anyone would use	it, feel free to ignore	it.) After
	       ffffiiiigggglllleeeetttt executes a tttt command, it skips to	the end	of the
	       file or to the next ffff command.  If any tttt	commands
	       follow, the first applicable one	will be	executed.  The
	       result is that ffff	acts as	a ``freeze'', executing	the
	       remaining commands as if	they were in a separate	file.



     FFFFIIIILLLLEEEESSSS



     PPPPaaaaggggeeee 11113333					      ((((pppprrrriiiinnnntttteeeedddd 9999////7777////99994444))))






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  _f_i_l_e....ffffllllffff	      ffffiiiigggglllleeeetttt font file
	  _f_i_l_e....ffffllllcccc	      ffffiiiigggglllleeeetttt control file


     DDDDIIIIAAAAGGGGNNNNOOOOSSSSTTTTIIIICCCCSSSS
	  ffffiiiigggglllleeeetttt''''ssss diagnostics are intended to be self-explanatory.
	  Possible messages are

	       UUUUssssaaaaggggeeee:::: ............
	       OOOOuuuutttt ooooffff mmmmeeeemmmmoooorrrryyyy
	       UUUUnnnnaaaabbbblllleeee ttttoooo ooooppppeeeennnn ffffoooonnnntttt ffffiiiilllleeee
	       NNNNooootttt aaaa ffffiiiigggglllleeeetttt 2222 ffffoooonnnntttt ffffiiiilllleeee
	       UUUUnnnnaaaabbbblllleeee ttttoooo ooooppppeeeennnn ccccoooonnnnttttrrrroooollll ffffiiiilllleeee
	       NNNNooootttt aaaa ffffiiiigggglllleeeetttt 2222 ccccoooonnnnttttrrrroooollll ffffiiiilllleeee
	       """"----tttt"""" iiiissss ddddiiiissssaaaabbbblllleeeedddd,,,, ssssiiiinnnncccceeee iiiiooooccccttttllll iiiissss	nnnnooootttt ffffuuuullllllllyyyy iiiimmmmpppplllleeeemmmmeeeennnntttteeeedddd....

	  This last message is printed when the	----tttt option is given,
	  but the operating system in use does not include the system
	  call ffffiiiigggglllleeeetttt uses to determine	the terminal width.

	  ffffiiiigggglllleeeetttt also prints an	explanatory message if the ----FFFF option
	  is given on the command line.	 The earlier version of
	  ffffiiiigggglllleeeetttt, version 2.0, listed the available fonts when the ----FFFF
	  option was given.  This option has been removed from ffffiiiigggglllleeeetttt
	  2.1.	It has been replaced by	the ffffiiiigggglllliiiisssstttt script, which is
	  part of the standard ffffiiiigggglllleeeetttt package.


     OOOORRRRIIIIGGGGIIIINNNN
	  ``ffffiiiigggglllleeeetttt'' stands for	``Frank, Ian and Glenn's LETters''.
	  Inspired by Frank's .sig, Glenn wrote	(most of) it, and Ian
	  helped.

	  Most of the standard ffffiiiigggglllleeeetttt fonts were inspired by
	  signatures on	various	UseNet articles.  Since	typically
	  hundreds of people use the same style	of letters in their
	  signatures, it was often not deemed necessary	to give	credit
	  to any one font designer.


     BBBBUUUUGGGGSSSS
	  Very little error checking is	done on	font and control
	  files.  While	ffffiiiigggglllleeeetttt tries to	be forgiving of	errors,	and
	  should (hopefully) never actually crash, using an
	  improperly-formatted file with ffffiiiigggglllleeeetttt	will produce
	  unpredictable	output.

	  ffffiiiigggglllleeeetttt does not handle formatting characters in a very
	  intelligent way.  A tab character is converted to a blank,
	  and vertical-tab, form-feed and carriage-return are each
	  converted to a newline.  On many systems, tabs can be
	  handled better by piping files through eeeexxxxppppaaaannnndddd	before piping



     Page 14					      (printed 9/7/94)






     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))		    vvvv2222....1111 ((((11112222 AAAAuuuugggg 1111999999994444))))		     FFFFIIIIGGGGLLLLEEEETTTT((((6666))))



	  through ffffiiiigggglllleeeetttt.

	  ffffiiiigggglllleeeetttt output	is quite ugly if it is displayed in a
	  proportionally-spaced	font.  I suppose this is to be
	  expected.


     AAAAUUUUTTTTHHHHOOOORRRRSSSS
	  Glenn	Chappell <ggc@uiuc.edu>	did most of the	work. You can
	  e-mail him but he is not an e-mail fanatic; people who e-
	  mail Glenn will probably get answers,	but if you e-mail his
	  best friend:

	  Ian Chai <spectre@uiuc.edu>, who _i_s an e-mail	fanatic,
	  you'll get answers, endless conversation about the mysteries
	  of life, invitations to join some 473	mailing	lists and a
	  free toaster.	 (Well,	ok, maybe not the free toaster.)

	  Frank	inspired this whole project with his .sig, but don't
	  e-mail him; he's decidedly an	un-e-mail-fanatic.



































     Page 15					      (printed 9/7/94)



