lliibbmmiisscc -- Library

Library of miscellaneous functions

lliibbmmiisscc is a library of miscellaneous C functions.  These functions perform
such  useful tasks  as  handling such  programming tasks  as allocation  of
memory,  copying  strings,  displaying  variables  from C  with  COBOL-like
``picture''  descriptions,  and  supporting  virtual arrays  via  secondary
storage.

Source  code   for  lliibbmmiisscc   is  kept   in  the  compressed   ttaarr  archive
/uussrr/ssrrcc/mmiisscc.ttaarr.ZZ. To  extract the files  into a new  subdirectory called
mmiisscc, type the command:

    zcat /usr/src/misc.tar.Z | tar xvf -

To build the library, type the following:

    cd misc
    make

This compiles the lliibbmmiisscc routines and builds the library lliibbmmiisscc.aa.

Archive mmiisscc.ttaarr also includes  the header file mmiisscc.hh which protypes these
functions, and  declares the global variables and  constants they use.  You
must include this  header file in any program that  uses any of the lliibbmmiisscc
functions.

_F_u_n_c_t_i_o_n_s
The following summarizes the functions in lliibbmmiisscc.aa:

cchhaarr * aalllloocc(_n) uunnssiiggnneedd _n;
     mmaalllloocc() _n bytes and initialize them to zero.  Abort on failure.

iinntt aapppprrooxx(_a, _b) ddoouubbllee _a, _b;
     If _a  and _b  are within epsilon,  return one; otherwise,  return zero.
     epsilon is a visable ddoouubbllee.

cchhaarr *aasskk(_r_e_p_l_y, _m_s_g, ...) cchhaarr *_r_e_p_l_y, *_m_s_g;
     Print a  message and  retrieve the user's  reply.  _m_s_g is  a pprriinnttff()-
     style format  string that formats the text pointed  to by any trailing
     arguments.  aasskk() constructs the prompt message from _m_s_g and prints it
     on the standard output; then reads a line from stdin, stores it in the
     place pointed to by _r_e_p_l_y,  and returns its address.  _r_e_p_l_y must point
     to enough space to hold the user's reply.

     For example,

         sscanf(ask(buff, "%d numbers", 3), &a, &b, &c);

     prints the message

         Enter: 3 numbers

     writes the user's reply into bbuuffff, and hands its address to ssssccaannff().

vvooiidd bbaannnneerr(_w_o_r_d, _p_a_d) cchhaarr *_w_o_r_d; iinntt _p_a_d;
     Print _w_o_r_d on stdout as a banner, preceded by _p_a_d spaces.  Each letter
     of the  banner is fashioned from many occurrences  of itself.  This is
     especially  useful  if  you wish  your  listings  to  look like  truly
     professional, mainframe printouts.

bbeeddaaeemmoonn()
     bbeeddaaeemmoonn() turns  the calling  program into a  daemon.  A _d_a_e_m_o_n  is a
     process that executes in the background, without the usual connections
     to standard  I/O streams and terminals.  Examples  are ccrroonn and uuuuxxqqtt.
     To ensure  proper operation in connection  with other system software,
     any program that you intend to  run as a daemon should call bbeeddaaeemmoonn()
     as  its  first  step.   This  call  closes  all  inherited,  open-file
     descriptors, detaches the process from its inherited process group and
     controlling terminal, sets current directory to `/', and sets uummaasskk to
     zero.  For  further information on daemon  processes, see _U_n_i_x _N_e_t_w_o_r_k
     _P_r_o_g_r_a_m_m_i_n_g by W. Richard Stevens (Englewood Cliffs, NJ, Prentice-Hall
     Inc, 1990), section 2.6.

uunnssiiggnneedd sshhoorrtt ccrrcc1166(_p) cchhaarr *_p;
     Compute  the 16-bit  cyclic  redundency check  (crc16)  of the  string
     pointed to  by _p,  and return  it.  This function  is very  useful for
     building hash tables or checking differences between strings.

vvooiidd ffaattaall(_m_s_g, ...) cchhaarr *_m_s_g;
     Print  an error  message  and call  eexxiitt(11). _m_s_g  is a  pprriinnttff()-style
     format string; trailing arguments must to point to data.

cchhaarr *ggeettlliinnee(_i_f_p, _l_i_n_e_n_o) FFIILLEE *_i_f_p; iinntt *_l_i_n_e_n_o;
     Get  a line  from the  input  file pointed  to by  _i_f_p. This  function
     returns the address of the line,  or NULL to indicate the end of file.
     ggeettlliinnee() calls  mmaalllloocc() to  acquire space  for the line,  and allows
     lines to be continued with a \-whitespace.  It also implements lliinneennoo.

     ggeettlliinnee() recognizes the following escape sequences:

         # to end of line is passed
         \ whitespace through end of line is passed
         \n  newline
         \p  #
         \a  alarm
         \b  backspace
         \r  carrage return
         \f  form feed
         \t   tab
         \\  backslash
         \ddd    octal number

     All other \ sequences are errors that ggeettlliinnee() reports on stderr.

ttmm_tt *jjddaayy_ttoo_ttmm(_j_d) jjddaayy_tt _j_d;
     Turn a  Julian date to  ttmm (time) structure.   The Julian date  is the
     number of days since the  beginning of the Julian calendar, January 1,
     4713 B.C.;  it is a  good way to  store dates in  a system-independent
     manner,  such as  in  a data  base.   Structure jjddaayy_tt  is defined  in
     mmiisscc.hh.  Structure ttmm is defined in <ttiimmee.hh>.

ttiimmee_tt jjddaayy_ttoo_ttiimmee(_j_d) jjddaayy_tt _j_d;
     Turn Julian  date structure to COHERENT time.   Type ttiimmee_tt is defined
     in header file <ssyyss/ttyyppeess.hh>.

vvooiidd sspplliitttteerr(_o_f_p, _l_i_n_e, _l_i_m_i_t) FFIILLEE *_o_f_p; cchhaarr *_l_i_n_e; iinntt _l_i_m_i_t;
     Write _l_i_n_e  into file  _o_f_p, splitting it  into chunks less  than _l_i_m_i_t
     bytes long.  sspplliitttteerr() inserts a \ between chunks, and attempts to do
     this  on  white-space boundaries.   sspplliitttteerr()  produces  a long  line
     rather  than split  on  non-whitespace.  If  _l_i_n_e  does not  end in  a
     newline, sspplliitttteerr() adds one.  This is the inverse of ggeettlliinnee().

iinntt iiss_ffss(_s_p_e_c_i_a_l) cchhaarr *_s_p_e_c_i_a_l;
     Check whether  _s_p_e_c_i_a_l names a well-formed  file system.  Users should
     never put  file systems on  /ddeevv/rraamm11, but for  multi-system software,
     like ccoommpprreessss, it is smart to test.

     iiss_ffss() returns -1  if _s_p_e_c_i_a_l is not a device,  or if ooppeenn(), rreeaadd(),
     or sseeeekk() fails.  It returns zero  if no file system was found, or one
     if _s_p_e_c_i_a_l names a legal file system.

cchhaarr *llccaassee(_s_t) cchhaarr *_s_t_r;
     Convert every  character in _s_t_r  to lower case.  Note  that this works
     only with the U.S. dialect of English; it does not work with German or
     other languages  that use  characters in the  upper half of  the ASCII
     table.

cchhaarr *mmaattcchh(_s_t_r_i_n_g, _p_a_t_t_e_r_n, _f_i_n) cchhaarr *_s_t_r_i_n_g, *_p_a_t_t_e_r_n, **_f_i_n;
     mmaattcchh() resembles ppnnmmaattcchh(), except that it returns the address of the
     pattern matched.  _f_i_n is aimed past the end of the pattern found; that
     is, mmaattcchh() finds a pattern and tells you where it is.

cchhaarr *mmeettaapphhoonnee(_w_o_r_d) cchhaarr *_w_o_r_d;
     Translate _w_o_r_d  into a short phonetic equivalent  for easy lookup.  It
     resembles  Knuth's ssoouunnddeexx  method,  except that  it  uses a  superior
     algorithm.

cchhaarr *nneewwccppyy(_s_t_r) cchhaarr *_s_t_r;
     Create  a NUL-terminated  copy of  _s_t_r and  return its  address.  Call
     ffaattaall() if there is no space.

cchhaarr *ppaatthhnn(_n_a_m_e, _e_n_v_p_a_t_h, _d_e_f_l_p_a_t_h, _a_c_c_e_s_s)
cchhaarr *_n_a_m_e, *_e_n_v_p_a_t_h, *_d_e_f_l_p_a_t_h, *_a_c_c_e_s_s;
     ppaatthhnn() looks for file _n_a_m_e.  It searches the directories named in the
     environmental variable _e_n_v_p_a_t_h. If the user has not set _e_n_v_p_a_t_h, or if
     it is NULL, ppaatthhnn() searches the default path _d_e_f_l_p_a_t_h. _n_a_m_e must have
     _a_c_c_e_s_s permission.   ppaatthhnn() returns the full path  to the file found.
     For example:

         pathn("helpfile", "LIBPATH", "/lib", "r")

     searches the directories named in LLIIBBPPAATTHH for file hheellppffiillee, for which
     the user  must have read  permission.  If LLIIBBPPAATTHH is  not set, ppaatthhnn()
     searches /lliibb for hheellppffiillee.

#iinncclluuddee <rreeggeexxpp.hh>
rreeggeexxpp *rreeggccoommpp(_e_x_p) cchhaarr *_e_x_p;
iinntt rreeggeexxeecc(_p_r_o_g, _s_t_r_i_n_g) rreeggeexxpp *pprroogg; cchhaarr *_s_t_r_i_n_g;
rreeggssuubb(_p_r_o_g, _s_o_u_r_c_e, _d_e_s_t) rreeggeexxpp *_p_r_o_g; cchhaarr *_s_o_u_r_c_e; cchhaarr *_d_e_s_t;
rreeggeerrrroorr(_m_s_g) cchhaarr *_m_s_g;
     These  functions  implement  a  standard  method for  parsing  regular
     expressions.  rreeggccoommpp() turns a regular expression into a structure of
     type rreeggeexxpp  and returns  a pointer  to it.  rreeggeexxeecc()  matches _s_t_r_i_n_g
     against  the regular  expression in  _p_r_o_g.  It  returns one  if _s_t_r_i_n_g
     matches _e_x_p, and zero if it does not.  rreeggssuubb() copies _s_o_u_r_c_e to _d_e_s_t,
     and  makes  substitutions  according  to  the  most  recent  rreeggeexxeecc()
     performed  using _p_r_o_g.   rreeggeerrrroorr()  is called  whenever  an error  is
     detected  in rreeggccoommpp(),  rreeggeexxeecc(), or  _r_e_g_s_u_b().  See  rreeggeexxpp.ddoocc for
     details.

lloonngg rraannddll()
     Return  a  long  random number  uniformly  distributed  between 1  and
     2,147,483,562.  This comes  from _C_o_m_m_u_n_i_c_a_t_i_o_n_s _o_f _t_h_e _A_C_M, volume 31,
     number 6.  See ssrraannddll(), below.

cchhaarr *rreeppllaaccee(_s_1, _p_a_t, _s_3, _a_l_l, _m_a_t_c_h_e_r) cchhaarr *_s_1, *_p_a_t, *_s_3, (_m_a_t_c_h_e_r)();
     RReeppllaaccee oonnee oorr  aallll ooccccuurrrreenncceess ooff _p_a_t iinn ssttrriinngg  _s_1 bbyy _s_3, aanndd rreettuurrnn
     tthhee rreessuulltt.  TThhee ddeeffiinniittiioonn ooff mmaattcchh iiss sseett bbyy _m_a_t_c_h_e_r. TThhiiss ccaallllss tthhee
     uusseerr-ddeeffiinneedd ffuunnccttiioonn

         mmaattcchheerr(_s_w, _p_a_t, &_f_i_n).

     The _m_a_t_c_h_e_r must  return the address of the pattern  match and its end
     in &_f_i_n. mmaattcchh() is a valid  example of _m_a_t_c_h_e_r. It replaces the first
     occurrence, or  all occurrences  of the  pattern, and returns  the new
     pattern.  The new pattern has been aalllloocc()'d.

sshhoowwffllaagg(_d_a_t_a, _f_l_a_g_s, _o_u_t_p_u_t) lloonngg _d_a_t_a; cchhaarr *_f_l_a_g_s, *_o_u_t_p_u_t;
     Turn  the bits in  _d_a_t_a to  the flags  in _f_l_a_g_s or  `-' in  the string
     _o_u_t_p_u_t, which must be as long as _f_l_a_g_s.

cchhaarr *sskkiipp(_s_1, _m_a_t_c_h_e_r, _f_i_n) cchhaarr *_s_1, **_f_i_n; iinntt (*_m_a_t_c_h_e_r)();
     Skip  all initial  characters  in string  _s_1 that  fail when  examined
     _m_a_t_c_h_e_r. _m_a_t_c_h_e_r is  usually a character function, e.g., iissddiiggiitt(). It
     returns  the  first  character  skipped.   sskkiipp()  points _f_i_n  at  the
     character after the skip.

cchhaarr *ssppaann(_s_1, _m_a_t_c_h_e_r, _f_i_n) cchhaarr *_s_1, **_f_i_n; iinntt (*_m_a_t_c_h_e_r)();
     Span all  initial characters in string _s_1 that  match when examined by
     _m_a_t_c_h_e_r. _m_a_t_c_h_e_r is  usually a character function, e.g., iissddiiggiitt(). It
     returns  the  first  character  spanned.   ssppaann()  points _f_i_n  at  the
     character after the span.

ssrraannddll(_s_e_e_d_1, _s_e_e_d_2) lloonngg _s_e_e_d_1, _s_e_e_d_2;
     rraannddll() needs two seeds; ssrraannddll() sets  them.  Use it only if you need
     to repeat a random-number sequence.

ssttrrcchhttrr(_f_r_o_m, _t_o, _c, _d_e_f)
cchhaarr *_f_r_o_m, *_t_o; iinntt _c, _d_e_f;
     Look up  the character _c in the string  _f_r_o_m. Return the corresponding
     character  in the  string _t_o  if  it is  found; otherwise,  return the
     default character _d_e_f.

     For example, consider the call:

         strchtr("ab", "xy", c, d);

     If variable _c equals `a', then ssttrrcchhttrr() returns `x'; if _c equals `b',
     then it returns `y'; otherwise, it returns the value of _d

ssttrrccmmppll(_s_1, _s_2)
     Case-insensitive string comparison.  Resembles ssttrrccmmpp().

jjddaayy_tt ttiimmee_ttoo_jjddaayy(_t_i_m_e) ttiimmee_tt _t_i_m_e;
     Turn COHERENT  time to Julian date structure.  The  Julian date is the
     number of days since the  beginning of the Julian calendar, January 1,
     4713 B.C.  The structure jjddaayy_tt  is defined in mmiisscc.hh.  Type ttiimmee_tt is
     defined in <ssyyss/ttyyppeess.hh>.

jjddaayy_tt ttmm_ttoo_jjddaayy(_t_m) ttmm_tt *_t_m;
     Turn the time structure ttmm date into Julian date structure.  Structure
     ttmm is defined in <ttiimmee.hh>.

cchhaarr *ttrriimm(_s) cchhaarr *_s;
     Remove trailing whitespace from string _s.

uuccaassee(_s) cchhaarr *_s;
     Convert a string to upper case.

uussaaggee(_s) cchhaarr *_s;
     Print string _s and call eexxiitt(11).

xxdduummpp(_p, _l_e_n_g_t_h) cchhaarr *_p;
     Print on stdout a vertical hexadecimal dump of string _p.

     A vertical  hexadecimal dump prints  as three lines.  The  top line is
     the display  character, or  `.' if  the character cannot  be displayed
     cleanly.  The  next two lines are the  hexadecimal numerals.  The data
     are blocked into groups of four bytes.

xxooppeenn(_f_i_l_e_n_a_m_e, _a_c_s) cchhaarr *_f_i_l_e_n_a_m_e, *_a_c_s;
     Like ffooppeenn(), but call ffaattaall() if the open fails.

yynn(_q_u_e_s_t_i_o_n, ...) cchhaarr *_q_u_e_s_t_i_o_n;
     Ask  a question  and retrieve  a  `Y' or  `N' answer.   _q_u_e_s_t_i_o_n is  a
     pprriinnttff()-style format string;  any trailing parameters should point to
     data used  in _q_u_e_s_t_i_o_n. yynn()  returns one if  the user answers  `Y' or
     `y', and returns zero if she answers `N' or `n'.

_V_i_r_t_u_a_l _M_e_m_o_r_y
The following  functions are part  of a virtual memory  system for COHERENT
286.  Occasionally, users port  programs like ccoommpprreessss to COHERENT 286 that
use a small number of very  large arrays.  Because COHERENT 286 is a SMALL-
model operating system, special provision must be made for arrays too large
to fit  into a  64-kilobyte data  segment.  The following  functions enable
programs that are to be run under COHERENT 286 use very large arrays:

vvooiidd vviinniitt(_f_i_l_e_n_a_m_e, _r_a_m) cchhaarr *_f_i_l_e_n_a_m_e; uunnssiiggnneedd _r_a_m;
     Initialize  the  virtual-memory   system,  using  _f_i_l_e_n_a_m_e  for  work.
     _f_i_l_e_n_a_m_e may be a raw device, such as /_d_e_v/_r_r_a_m_1. _r_a_m is the amount of
     buffer space to give the system -- the more, the better.

vvooiidd vvsshhuuttddoowwnn()
     Shut the virtual-memory system, and make it restartable.

uunnssiiggnneedd vvooppeenn(_a_m_t) uunnssiiggnneedd lloonngg _a_m_t;
     Set up  a virtual-memory object.  For example, if  you want to emulate
     having a 100,000-byte array and a 50,000-byte array, use the call

         vid1 = vopen(100000L); vid2 = vopen(50000L);

     This does  some checking  and tells the  system that any  reference to
     _v_i_d_2 will be between 100,000 and 150,000 in the virtual file.

cchhaarr *vvffiinndd(_v_i_d, _d_i_s_p, _d_i_r_t_y)
uunnssiiggnneedd _v_i_d, _d_i_r_t_y; uunnssiiggnneedd lloonngg _d_i_s_p;
     Find a character in the virtual  system, mark the block's dirty bit if
     the access is to write.  Given  the example in vvooppeenn(), if you want to
     find the 1,000th byte in _v_d_i_1, use the call:

         c = *(vfind(vdi1, 1000L, 0));

     To change the 2000th byte in _v_i_d_2 dd, use the call

         *(vfind(vid2, 2000L, 1)) = d;

     Note that the  dirty indicator tells the system of  the change so that
     the block will be written back before it is read over.  Blocks are 512
     bytes long, so iinntt's or lloonngg's can be read or written without multiple
     accesses to vvffiinndd().

_F_i_l_e _L_o_c_k_i_n_g
lliibbmmiisscc holds a number of routines with which you can lock and unlock files
and  devices.   It is  adapted  from  the mechanism  used  by the  COHERENT
implementation of UUCP.

Lock  files  are created  in  $SSPPOOOOLLDDIIRR.  A lock  file  is  given the  name
LLCCKK.._r_e_s_o_u_r_c_e.   The lock  file contains  a  decimal representation  of the
process identifier of the process that created the lock.

It  is  possible to  provide  an alternate  pid  by using  one  of the  "n"
routines.  The  unlocking routines regard a  pid of zero as  an override --
they remove the lock regardless of which process created the lock.

For  a tty  device, the  _r_e_s_o_u_r_c_e is  a string that  consists of  a decimal
representation of  its major  number, a decimal  point, and the  lower five
bits of its minor number.

Each routine takes a string that names a resource to be locked or unlocked.
The tty  routines want the base  name of the tty to  be locked (without the
``/dev/'' part).

All lock routines all return zero on failure and one on success.

lloocckkiitt(_r_e_s_o_u_r_c_e) char *_r_e_s_o_u_r_c_e;
     Use a resource string to lock a tty.

lloocckkeexxiisstt(_r_e_s_o_u_r_c_e) char *_r_e_s_o_u_r_c_e;
     Check whether a lock file exists for the tty with _r_e_s_o_u_r_c_e.

lloocckknnrrmm(_r_e_s_o_u_r_c_e, _p_i_d) cchhaarr *_r_e_s_o_u_r_c_e; iinntt _p_i_d;
     Remove a lock file for a tty owned by process _p_i_d.

lloocckknnttttyy(_t_t_y, _p_i_d) cchhaarr *_t_t_y; iinntt _p_i_d;
     Lock a tty for process _p_i_d.

lloocckkrrmm(_r_e_s_o_u_r_c_e) char *_r_e_s_o_u_r_c_e;
     Remove a lock file for tty with _r_e_s_o_u_r_c_e.

lloocckkttttyy(_t_t_y) cchhaarr *_t_t_y;
     Lock a tty.

lloocckkttttyyeexxiisstt(_t_t_y) cchhaarr *_t_t_y;
     Check whether a given tty is locked.

uunnlloocckknnttttyy(_t_t_y, _p_i_d) cchhaarr *_t_t_y; iinntt _p_i_d;
     Unlock a tty for process _p_i_d.  Unlocking always succeeds.

uunnlloocckkttttyy(_t_t_y) cchhaarr *_t_t_y;
     Unlock a tty that the current process owns.

uunnlloocckkiitt(_r_e_s_o_u_r_c_e, _p_i_d) cchhaarr *_r_e_s_o_u_r_c_e; iinntt _p_i_d;
     Unlock something for process _p_i_d.

_T_e_m_p_l_a_t_e_s _a_n_d _P_i_c_t_u_r_e_s
lliibbmmiisscc includes a function, ppiiccttuurree(), for formatting numeric strings.  It
has the following syntax:

    ddoouubbllee ppiiccttuurree(_d_b_l_e, _f_o_r_m_a_t, _o_u_t_p_u_t)
    ddoouubbllee _d_b_l_e; cchhaarr *_f_o_r_m_a_t, *_o_u_t_p_u_t;

ppiiccttuurree()  performs  numeric  formatting  under  C.  It  resembles  masking
functions  built into  COBOL and  BASIC, but is  superior to  either.  _d_b_l_e
gives the number to format; _f_o_r_m_a_t gives the format mask; and _o_u_t_p_u_t points
to the area into which the  formatted number is written.  _o_u_t_p_u_t must be at
least as large as _f_o_r_m_a_t.  If _d_b_l_e overflows the picture, ppiiccttuurree() returns
the overflow.

The following  summarizes the values that can appear  in the _f_o_r_m_a_t string.
Note that throughout, the symbol  <sspp> indicates a space character, not the
literal string ``<sp>''.

99  Provide a  slot for a  number.  Passing 5.000  through a mask  of 999999 CCRR
   gives ``005''.   Passing -5.000  through a mask  of 999999 CCRR  yields ``005
   CR''.  Note that ppiiccttuurree() does not recognize the characters `C' and `R'
   as  being special.   Trailing non-special characters  print only  if the
   number is negative.

ZZ  Provide a slot for a  number, but suppress leading zeroes.  For example,
   passing  1034.000 through  a  mask of  ZZZZZZ,ZZZZZZ gives  ``<sp><sp>1,034''.
   Note  that ppiiccttuurree()  does  not recognize  a  comma as  being a  special
   character.   ppiiccttuurree() prints  embedded non-special  characters  only if
   they are preceeded by significant digits.

JJ  Provide a slot for a number, but shrink out leading zeros.  For example,
   passing 1034.000 through a mask of JJJJJJ,JJJJJJ yields ``1,034''.

KK  Provide a  slot for a  number, but shrink  out any zeros.   For example,
   passing 70884.000 through a mask of KK99/KK99/KK99 yields ``7/8/84''.

$  Float a dollar  sign to the left of the  displayed number.  For example,
   passing    105.000     through    a    mask     of    $ZZZZZZ,ZZZZZZ    yields
   ``<sp><sp><sp><sp>$105''.

.  Separate the number  between decimal and integer portions.  For example,
   passing 105.670 through a mask of ZZ,ZZZZZZ.999999 yields ``<sp><sp>105.670''.

TT  Provide a slot for a number, but suppress trailing zeroes.  For example,
   passing    105.670    through     a    mask    of    ZZ,ZZZZ99.99TTTT    yields
   ``<sp><sp>105.67<sp>''.

SS  Provide  a slot  for  a number,  but  shrink out  trailing zeroes.   For
   example,   passing  105.670   through   a  mask   of  ZZ,ZZZZ99.99SSSS   yields
   ``<sp><sp>105.67''.

-  Float  a  negative sign  in  front of  negitive  numbers.  For  example,
   passing  105.000 through  a mask  of -ZZ,ZZZZZZ  yields ``<sp><sp><sp<105'',
   whereas  passing -105.000  through a mask  of -ZZ,ZZZZZZ  yields ``<sp><sp>-
   105''.

(  Acts like  -, but  prints a  parenthesis.  For example,  passing 105.000
   through a  mask of (ZZZZZZ) yields  ``<sp>105<sp>'', whereas passing -5.000
   through a mask of (ZZZZZZ) yields ``<sp><sp>(5)''.

+  Float  a + or  - in  front of  the number, depending  on its  sign.  For
   example,  pasing 5.000  through a  mask  of +ZZZZZZ  yields ``<sp><sp>+5'',
   whereas passing -5.000 through a mask of +ZZZZZZ yields ``<sp><sp>-5''.

*  Fill all  spaces to right with asterisks.   For example, passing 104.100
   through a  mask of  *ZZZZZZ,ZZZZZZ.9999 yields ``*****104.10'';  whereas passing
   104.100  through   a  mask  of   *$ZZZZZZ,ZZZZZZ.9999  yields  ``*****$104.10''.
   ppiiccttuurree()  returns  any  overflow  as  a  ddoouubbllee. For  example,  passing
   -1234.000 through  a mask of (ZZZZZZ) yields ``(234)''  with an overflow of
   -1.0;  passing  123.400 through  a  mask  of 9999  yields  ``23'' with  an
   overflow of 1.0; and passing 1200.000 through a mask of ZZZZ yields ``00''
   with an overflow of 12.0.

_F_i_l_e_s
/uussrr/ssrrcc/mmiisscc.ttaarr.ZZ -- Compressed ttaarr archive of sources

_S_e_e _A_l_s_o
lliibbrraarriieess, ttaarr, zzccaatt

_N_o_t_e_s
The mmiisscc library is provided on an _a_s-_i_s basis only.  _C_a_v_e_a_t _u_t_i_l_i_t_o_r!
