


     FFFFGGGGEEEETTTTMMMMFFFFSSSS((((3333))))		     XXXXEEEENNNNIIIIXXXX 3333....0000 ((((llllooooccccaaaallll))))		    FFFFGGGGEEEETTTTMMMMFFFFSSSS((((3333))))



     NNNNAAAAMMMMEEEE
	  fgetmfs - read an arbitrarily long, possibly continued line

     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
	  ####iiiinnnncccclllluuuuddddeeee <<<<ssssttttddddiiiioooo....hhhh>>>>
	  ####iiiinnnncccclllluuuuddddeeee <<<<ffffggggeeeettttmmmmffffssss....hhhh>>>>

	  cccchhhhaaaarrrr ****ffffggggeeeettttmmmmffffssss((((ssssttttrrrreeeeaaaammmm,,,,	lllliiiimmmmiiiitttt,,,, ccccoooonnnntttt))))
	  FFFFIIIILLLLEEEE ****ssssttttrrrreeeeaaaammmm;;;;
	  iiiinnnntttt lllliiiimmmmiiiitttt,,,, ccccoooonnnntttt;;;;

	  cccchhhhaaaarrrr ****ffffggggeeeettttmmmmssss((((ssssttttrrrreeeeaaaammmm))))
	  FFFFIIIILLLLEEEE ****ssssttttrrrreeeeaaaammmm;;;;

	  cccchhhhaaaarrrr ****ccccffffggggeeeettttmmmmssss((((ssssttttrrrreeeeaaaammmm))))
	  FFFFIIIILLLLEEEE ****ssssttttrrrreeeeaaaammmm;;;;

     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_g_e_t_m_f_s reads	an arbitrarily long line from _s_t_r_e_a_m,
	  allocating memory via	_m_a_l_l_o_c(3) as needed.  If _l_i_m_i_t is
	  non-negative,	_f_g_e_t_m_f_s	will read no more than _l_i_m_i_t bytes
	  from _s_t_r_e_a_m.	For efficiency,	if _c_o_n_t	is not _C_O_N_T__N_O,	such
	  as _C_O_N_T__N_O_S_P_C	or _C_O_N_T__S_P_C, occurrences of a backslash	and a
	  newline together and in that order will be deleted from the
	  input	stream;	if _c_o_n_t	is _C_O_N_T__N_O_S_P_C, any whitespace after
	  the newline in the input stream will also be deleted from
	  it.

	  The macros _f_g_e_t_m_s (to	read without continuations) and
	  _c_f_g_e_t_m_s (to read with	continuations and remove leading
	  whitespace) should be	used instead when the _l_i_m_i_t is not
	  needed.

	  _F_g_e_t_m_f_s is intended to provide a reliable mechanism for
	  reading input	containing lines of arbitrary length, rather
	  than trusting	that no	line with be longer than some
	  arbitrary tolerance.

	  The memory returned by _f_g_e_t_m_f_s should	be returned when no
	  longer needed	via _f_r_e_e(3).

     SSSSEEEEEEEE AAAALLLLSSSSOOOO
	  _m_a_l_l_o_c(3), _f_g_e_t_s(3)

     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
	  Returns NULL (0) if memory cannot be allocated or upon
	  reading end-of-file; use _f_e_o_f(_s_t_r_e_a_m)	to distinguish.

     HHHHIIIISSSSTTTTOOOORRRRYYYY
	  Written by Geoff Collyer at the University of	Toronto	as
	  part of the C	news project.




     Page 1					      (printed 8/2/94)






     FFFFGGGGEEEETTTTMMMMFFFFSSSS((((3333))))		     XXXXEEEENNNNIIIIXXXX 3333....0000 ((((llllooooccccaaaallll))))		    FFFFGGGGEEEETTTTMMMMFFFFSSSS((((3333))))



     BBBBUUUUGGGGSSSS
	  It's too slow.
	  The meaning of the _c_o_n_t flag is ugly,	but layering this form
	  of continuation on top is even slower.



















































     Page 2					      (printed 8/2/94)



