		PSROFF RELEASE 2.0 README 2.1 90/07/18

			May 14, 1990
			Chris Lewis

	See defs.h for the official Psroff release and patch level.

	Please see the end of this file for my contact information
	and for enrollment in the psroff mailing list.

Please read this document, especially any new patches (if any) near
the end before reconfiguring.  If you have difficulties, read the
TROUBLE file.  See STEP-BY-STEP INSTRUCTIONS near the end for precise
installation details.

Normal UNIX troff only prints its output on WANG C/A/T Phototypesetters.
This package contains a generic interface between standard troff and
other types of printers.  The package has a driver for PostScript printers
(Eg: Apple Laserwriters), a driver for HP LaserJet and DeskJet family
printers (including incremental downloading of PK or SFP format fonts),
and Ditroff output options (tpscript driving Postscript printers,
jetroff driving HP Laserjets, xtroff driving X.11, xproof driving DMD
terminals, psdit etc. and more to come...)

In fact, this package can be used to, in effect, upgrade CAT troff
to be ditroff.  There are limitations, but you get what you pay for.

Applicability:
    - You must have CAT troff, *not* ditroff (eg: *not* DWB 1.? or 2.?).
    - Printers:
	- If you have a laserjet, you should be able to use this
	  package directly.  Alternately, you can cause psroff
	  to generate ditroff and drive jetroff with it.
	- I believe the above comments also hold true for DeskJet
	  printers.
	- If you have a postscript printer use postscript output.
	  Or, generate ditroff and use tpscript.  Mine's better,
	  so there! ;-)
	- If you have ditroff drivers (eg: dit2dvi etc.) you can
	  configure psroff to drive them.
	- If you have real ditroff, then use ditroff and throw psroff
	  in the trash bucket.

Beware of the use of any ditroff-only-isms.  Psroff doesn't support
features in ditroff but not CAT troff (yet...).

This is a formal release.  There are probably rough edges however,
particularly with fine-tuning width tables for specific printers and
some of the more esoteric ditroff configurations.

I encourage people to experiment with psroff (particularly the configuration
files) and PLEASE PLEASE PLEASE send me your changes so that I can
encorporate them into new releases and updates.

This package is currently in production at our site and has been so for
nearly two years (in various incarnations).  The previous version of
psroff (version 1.0) was posted in comp.sources.unix in October 1989.
This version is a lot better.

If you send me your name and e-mail address, I'll put you on the psroff
mailing list, and you'll get express delivery of any small patches (see
CONTACT INFO at end of this README).  Patches are also shipped out through
comp.sources.unix and/or comp.sources.bugs, but the latency can be rather
high at times.  A current list of FTP-access sites can be obtained by
sending me mail.

Credit/copyright where credit's due:

 1) All code, except where noted below, is Copyright 1985, 1986, 1987,
    1988, 1989, 1990 Chris Lewis, All Rights Reserved.

    Permission to copy and further distribute is freely given provided
    this copyright notice remains intact and that this software is not
    sold for profit.

 2) psdtwid and some of the character drawing and spacing
    stuff (bracket font in ps.lib) is from ditroff2ps/tpscript:

    Copyright:	1985, Stephen Frede, UNSW Australia
	    Use it and copy it as much as you want, but don't pretend you
	    wrote it, or sell it for profit.

    Michael Rourke wrote some of the code that I borrowed.

    Excellent stuff.

 4) There are a few minor tweaks (specifically: headers on font width
    tables, and BSDHACK) influenced by David MacKenzie's (djm@wam.umd.edu or
    edf@rocky2.rockefeller.edu) and Sverre Froyen's (boulder!fesk!sverre,
    sunpeaks!seri!fesk!sverre) troff2lj package.  No code was directly
    borrowed, and no copyright appears on the sources consulted.
    (troff2lj downloads SFP's, not incrementally, and doesn't support
    PK files)

 5) The S.*.pk font files that I've distributed with this release are
    MATH8 encoded PK fonts, which are combination of several things:

	- characters from Donald Knuth's cmr, cmsy, cmmi TeX fonts.
	  These are public domain.

	- Rick Richardson's cmtrf font (bracket building characters)
	  from jetroff which Rick has graciously permitted me to
	  distribute provided that they are only used with psroff.

	- Each S.*.pk file was created by converting them to SFP's,
	  merging them into another SFP (using Ronald Florence's makeS
	  program), and converting them back to PK's using Rick
	  Richardson's sfp2pk program (included in jetroff).

	  Sorry, I cannot distribute either program, but pk2sfp can
	  be used to merge font files more generally than makeS.

	  See LASERFONTS on how to build psroff fonts from TeX PK's.

 6) The manual page for CAT troff format was written by Henry Spencer
    at the University of Toronto.  Without which this stuff would
    never have been written.

Remarks:

    - This was developed with a relatively old (eg: Lisa Xenix) troff, and
      may be slightly incompatible with the latest versions of CAT troff.
      See BSDHACK and FONT8/FONT4 in defs.h

    - The PostScript driver is fully complete.  It uses the
      built-in fonts on the AppleLaser.  A few characters not in
      these fonts are faked by the invocation of drawing routines
      defined in the file "ps.lib" (which is the definitions of things
      needed by the driver).  Or the bracket font (also in ps.lib).
      Eg: 1/2, 1/4, 3/4, circle, bell system logo and box are
      constructed by PostScript subroutines and/or the bracket font.
      The Bell System logo isn't really - try this:

	    \s36\(bs\s0

      The first person to correctly identify what it is (without reading
      ps.lib) gets a pat on the back ;-)

      The only two characters that don't exactly map properly are
      left and right hand.  I use double arrows instead.  This seems
      to be a relatively common convention.

    - The ditroff driver is fully complete and should work flawlessly
      provided that you use the proper width tables and you get the
      troff font:character -> ditroff font:character translations
      right.  You will probably want to take the ditroff width tables
      that come with your ditroff backend and run them through
      gfnttab (discussed later).

    - Fonts:
	- postscript driving - psroff uses what's on the printer - the
	  configuration (ps.fonts) supplied corresponds to a subset
	  of the AppleLaserwriter PLUS.  This should be satisfactory
	  with all modern postscript printers (the original Laserwriter
	  apparently is missing some of the fonts).  You may have
	  problems with Helvetica Narrow fonts on printers like LN03's.

	- ditroff driving - psroff uses whatever comes with the ditroff->
	  printer converter.  Eg: with xtroff, psroff would use the
	  font files that come with X windows.  With jetroff, psroff
	  would use the font files that come with jetroff, etc.
	  If you're driving a postscript printer via a ditroff backend,
	  chances are that you're using fonts on the printer (eg: tpscript)
	  and the "ps" widths will be satisfactory or can be manually
	  tweaked slightly.

	- HPLJ: to support downloading, you must obtain a set of font
	  files that are sufficient for the sort of stuff you are doing.
	  psroff has been designed to work with MATH8 encoded fonts
	  (for the CAT S font), and ROMAN8 encoded fonts for all others
	  (eg: R, I, B etc.).  Minimally, you should obtain from Hewlett
	  Packard (or other sources) Roman, RomanItalic, and RomanBold
	  all in ROMAN8 encodings, in the following point sizes:

	     6 7 8 9 10 11 12 14 16 18 20 22 24 28 36

	  From most sources these will be in HP "SFP" format.  I've
	  included with psroff a set of PK (TeX) format font files
	  for the S font in all of the sizes listed above.  These
	  "S" fonts are designed to be as close to HP MATH8 as possible.

	  Psroff supports both PK and SFP format font files.
	  Normal PK font files (eg: that come with TeX) do not have
	  anything close to the same encoding as HP.  The S PKs I supply
	  are specially reordered (actually a merge of four PKs) to
	  reflect MATH8 encoding.  You can also use TeX PK fonts
	  directly (after a name change to reflect psroff's file
	  naming conventions) for the non-S fonts.  cmr, cmit, and
	  cmb can be used for Roman, Italic and Bold respectively.
	  *BEWARE*, there are a *lot* of characters missing or
	  out-and-out wrong in Knuth's standard PK files (relative
	  to ROMAN8 ordering).  Particularly box-drawing characters.
	  I've included a couple R, I and B PK files that can be used
	  to have a bit of fun until you have better font files.
	  pk2sfp gives a method of merging PK files - see testmerge
	  entry in utils/Makefile.  R.10.pk, I.10.pk and B.10.pk
	  in the lj.fonts directory were created this way.

	  From Hewlett Packard, SFP's usually come on DOS diskettes
	  that can be "cat"'ed to the printer.  These are what you want.
	  Just remember to do BINARY copies from the floppies...

	  I got this mail message from Ronald Florence about HPLJ fonts:

		> May 14, 1990 (or thereabouts)

		> I just received a notice in the mail from HP, announcing
		> that they are about to discontinue the following soft
		> fonts:

		> 	TmsRmn/Helv	Roman 8		(33412AD)
		> 	TmsRmn/Helv	Roman 8		(33412AF)
		> 	TmsRmn/Helv	Ascii		(33412AE)

		> Together, the first two sets provide Times Roman and
		> Helvetica SFP fonts, including bold and italics, from
		> 6 to 30 points.  They can be ordered from HP Direct
		> (800/538-8787).

	  These are the fonts that Ronald has been using and they work
	  quite well.  Other soft fonts will probably work, but you
	  may have to tweak the translation tables.

	  So, order yours today...  (No, neither of us are in the
	  employ of HP).  You may also be able to get good SFP's
	  from the font archive at Waterloo.

	  Alternately, if you have TeX fonts, the file LASERFONTS
	  describes how to make fonts compatible with psroff.

	  Software is supplied (utils and widths directories) to
	  extract width information from PK and SFP font files and
	  is built into the makefiles.

    - The width tables supplied (widths/widthps) are in ditroff
      makedev-input-format (ASCII ditroff width tables).  I've
      specified them in ditroff format because it's easier to manipulate
      than CAT troff ft?? or ft??.c files.  dit2catwid/gfnttab convert
      these width files into ft?? files.  Further, if you're going to
      use a ditroff backend (tpscript, xtroff etc.) you'll probably
      need to feed them through the "makedev" utility so that the backend
      can understand the width tables.  I do not supply a makedev, but
      one has been posted, and one (written by Duane Hesser, dhh@teltone.com)
      is included with jetroff.  pk2ditwid takes PK and SFP files and
      produces widthtables compatible with gfnttab (but not necessarily
      with makedev).

    - Width tables: Postscript:
      (<printercommand> is how you sent output to your
      postscript printer.  You might use "lp -dlaserwriter".)
      These are in the utils subdirectory:

	showfont: If you type:
			    showfont <fontname> | <printercommand>
		  (eg: showfont Times-Roman) this will dump the entire
		  Postscript Times-Roman font (plus some constructions
		  that troff2ps uses) in a table.  Each character is
		  in a box, along with several numbers.  The number
		  in the center at the bottom of the box is the width
		  in CAT scaling (size of 6 point character in 1/432's).
		  The ditroff width tables are the size of a 10 point
		  character, by default in 1/300's, but can be changed
		  by a resolution directive in a DESC file (eg: widthps
		  is in 1/720's).

	dit2catwid.c: takes ditroff like font tables and converts them
		  to CAT codes suitable for (at least) Xenix troff.
		  (some attempt has been made to make it work for
		  systems that need a.out.h headers on their width
		  tables).  See the gfnttab script to see how it's
		  used.

	gfnttab:  Used to run dit2catwid to compile the width tables
		  and place them in /usr/lib/font/<printer>/ft??.
		  see lib/psrofflib.S

	psdtwid:  fire it off to your Postscript printer, and it
		  will send back a shar file containing ditroff
		  style char tables.  (Neat - thanks Michael!)

		  usage:
			psdtwid | <printercommand>

	widths/widthps/*:   width tables for postscript and ditroff driving
		  postscript.  (Most from tpscript (thanks Michael), but
		  some generated here with psdtwid)
	widths/width*/*:   other width tables.

    - Width tables: ditroff backends: (eg: jetroff, xtroff, psdit etc.)
	- install the backends *first*.
	- Find the DESC/R/S/I etc. files that come with the backend, or
	  are generated by installing the backend (eg: jetroff's makefont
	  stuff).
	- Copy these files to the appropriate widths/width<xx> subdirectory.
	  Notes:
		- I've used "jt" for jetroff, the jt.fonts file is already
		  at least partially set up.
		- "ps" is for ditroff->postscript (tpscript) and direct
		  postscript driving and these width files are supplied.
		  And would probably work with other ditroff->postscript
		  converters except for possible character mapping changes
		  (see jt.fonts).
	- Make in the widths directory will build the ft* files that you
	  need, and make install will install them in the proper places.
	  (normally /usr/lib/font/<xx>/ft*).  These are also done by
	  top level make invocations.
	- Some ditroff backends (jetroff f'r instance) need to be able
	  to read the "makedev compiled" font files.  For which you need
	  makedev (makedev is part of ditroff, but a PD version was
	  posted to the net sometime ago and a copy is included in the
	  jetroff release).

    - Width tables: HPLJ.  See the installation instructions below.

    - There is some code to allow the sending of arbitrary commands to
      the driver - the ".sR" macro.  This works well unless you're using
      the ".MT" macro in MM.  sR directives before the ".MT" will
      confuse MM.  See the manual page for psroff.1 for details on
      .sR.  Further, ".tm" has been redefined to make use of the
      .sR facility.

    - troff2 has 8-font troff support, but:

	    a) it's never been tested.
	    b) I'm no longer convinced that the cat.5 man page is
	       correct on how the decoding works.

    - troff2 has BSDHACK support (one of the tilt opcodes being
      replaced by an opcode to multiply the next vertical motion
      by 64), but this has not been tested.  I never heard of it
      before til I saw it in Froyen's troff2lj source.  This cannot
      be defined at the same time as 8-font support.  Frankly, I
      can't understand why they bothered - so you save a few opcodes
      here and there - vcat output is enormous!

    - ".S" files are the source files and are converted to a filename
      without the suffix by a sedscript that contains the configuration.
      Whenever you touch the top-level makefile, the sedscript is changed
      and all of the ".S" files are rebuilt.  If you make a makefile change
      (eg: configuration), do a "make makefiles" before using submakes.
      (though, if you simply say make, this will be done for you).  Only
      change .S files...

See the MANIFEST for a file-by-file description of the files.

STEP-BY-STEP INSTRUCTIONS (after unpacking the release):

	- Use /usr/bin/s5make on Ultrix.

	- NOTE: You may wish to try running "make check" at this
	  point, it should be able to find out the correct "HEADERSIZE"
	  and "trofftype" setting so you don't have to guess later on.
	  In any event, if you have problems and wish to ask me for help,
	  I will be requiring that you mail me a copy of the output
	  of "make check".

	- type "make unpackljfonts"  This will uudecode the font
	  files I've supplied and remove the .UU files.  This
	  step is unneccessary if you're not using Laserjets,
	  but it will regain you some space.

	- take a copy of the Makefile, defs.h and lib/psrofflib.S and
	  squirrel them away somewhere.  I'm not going to produce
	  patch-independent configurators, so if a patch has to come
	  out, they may well zap these three files.  If so, you'll
	  have to fix them manually.  Other files (lib/*.fonts and
	  lib/*.lib) are field-configurable, and it is possible I
	  will patch a few of them later (particularly lj.fonts).

	- If you are using the supplied width tables (widths/widthps),
	  all is fine.  But, if you're going to be driving another
	  package (eg: jetroff, tpscript, psdit, xtroff etc.) I suggest
	  you find the ditroff-format ASCII width tables (DESC, R, I,
	  S etc.), copy them to the appropriate widths/width<xx> area,
	  modify psrofflib.S to know how to use these width tables,
	  and possibly create *.fonts and *.lib files.  psrofflib.S
	  has copious comments on how to configure psroff.

	  psdit, tpscript, xtroff, and xproof work reasonably well using
	  the Postscript widths in widthps.

	- edit Makefile and change whatever you need to.

	- edit defs.h and define either BSD or ATT.  A few other options will
	  pertain to you.  Take special note of HEADERSIZE.  Take a look
	  at /usr/lib/font/ftR.  Is it 224 bytes long?  If so, HEADERSIZE
	  should be 0.  Otherwise you will probably have to set it to the
	  size of your a.out.h structure.  Ultrix and Sun appear to always
	  be HEADERSIZE = 32.

	  With Laserjet driving:

	    MDLF	max # downloaded fonts supported per page.
	    PRELOAD	# fonts statically downloaded
	    SFP		enables SFP's with incremental font downloading.
			Needs INCR.
	    INCR	enable incremental font downloading.  Needs PARTIAL.
	    PARTIAL	enable partial font downloading (only those characters
			troff could possibly use are downloaded).  Needs PK.
	    PK		enables PK font handling.  If PK is off, the only
			downloading supported is "cat <sfpfile>".
	    COMPRESS	permits you to compress SFP files.

	    Why all this config?  Well, when INCR is defined up to 16 fonts
	    could be incore at any given moment, which can chew up a lot
	    of space (especially with large pointsize SFP's).  I very
	    much doubt that you can use INCR on a 64K address space machine.
	    (or even split I&D!)  But you really *do* want to use INCR,
	    otherwise you might blow the Laserjet's memory, and use of INCR
	    *dramatically* decreases the transmission time to the printer.

	    If INCR not defined, at most only one font will be in core.

	    If PARTIAL is defined, only those characters that troff *could*
	    use (remember ROMAN8 and MATH8 fonts have 192 characters each,
	    but R and S have less than 108 each) are loaded into memory,
	    and only they are downloaded to the Laserjet.  This cuts down
	    the amount of laserjet memory used for fonts by about half,
	    and also cuts down transmission time.

	    If PARTIAL is undefined, whole PK or SFPs are downloaded.
	    if PK is undefined, only whole SFP's are downloaded.

	    Certain HPLJ clones will apparently not work with incremental
	    downloading.  If your printer screws up, undef INCR, but
	    make sure you have PARTIAL turned on and try again.

	- edit lib/psrofflib.S according to the instructions you find.
	  Take special note of -T/-F handling for troff (trofftype) -
	  check out your troff manual page!  Suns and Ultrix want
	  trofftype='-F/usr/lib/font/$width/ftXX'.

	- If you're going to be driving HP Laserjets:

	  If you have PK fonts from TeX, ensure that PKFONTS is set
	  reasonably in the Makefile.  type:

		make buildljfonts

	  This will generate under $NEWFONTS a whole pile of
	  SFP's (PK's if SFP2PK is set to a good sfp2pk program,
	  such as Rick Richardson's jetroff utility).  It will
	  also generate a $NEWFONTS/lj.fonts.new whose entries
	  should be *merged* (not copied) with lib/lj.fonts.
	  buildljfonts will generate a fair number of things,
	  so you may have to fix your Makefile/defs.h configuration.
	  Caution: if you have a lot of PK's, this will use up a LOT
	  of space - 5000 blocks or more!

	- if you're going to be driving HP Laserjets, type:

		su root
		make installljfonts

	  This will attempt to copy the fonts I've supplied plus
	  any created in the previous step to the $LJF directory.

	- Type
		make check

	  This will attempt to figure out whether you got some of the
	  more important options correct (trofftype & HEADERSIZE).

	- Type

		make

	  This will build everything (including width tables for any
	  HPLJ fonts you have supplied).

	- If you want to test psroff without actually installing it,
	  you will have to install the width tables (because troff's
	  limited as to where it will look for the width tables).
	  As root,
		make installwidths
	  Will install the widths as FONTDIR/ps/ftXX (which shouldn't
	  conflict with anything you already have, and you'll be
	  able to run "make test" without doing the "make install" first.
	  Actually, psroff will work without this being done, but it
	  will use the width tables that came with your troff, so the
	  output will look a little odd (along with giving you a warning
	  to that effect)

	- Final installation:
	  As root,
		make install
		make installwidths
	  Will install everything.

	- "make test" will print a test page.  If you have problems,
	  please run "make test", fill in the blanks, and FAX me the
	  result.  (the test page has the fax number).  The test page
	  exercises all R & S troff characters at 10 point, and displays
	  a few other characters at different point sizes.  If you don't
	  want to run psroff itself (eg: you've got troff2ps in a printer
	  daemon), type:

		make TEST
		tbl TEST | troff -t -T<whatever> | <troff2ps server>

	  "<troff2ps server>" may be "troff2ps -T<whatever> | your printer".

	  "TEST" is generated via make to include some information about
	  your configuration to help me diagnose your problems.

	- If you have problems, read the TROUBLE file which describes
	  some trouble-shooting.

	- HPLJ tuning:
	    bestmatch: in lj.c's bestmatch function there is are arrays
		"bigtry" and "smalltry".  These arrays provide a scan
		sequence finding a font size "close" to a requested font
		size that lj.fonts indicates isn't present.  If there
		are holes in your fonts, you may want to experiment with
		these arrays.
	    tbl box corners: depending on where you got your fonts from,
		you may have to slightly adjust the box drawing characters
		to match up at the corners of tbl boxes.  To do this,
		append to lj.fonts:

		    normal
		    ru N _ 0 -200
		    symbol
		    br N | -220 0

		The two numbers are the X and Y shifts of the corresponding
		characters, where the numbers are scaled by (.01 * pointsize)
		to get a shift in 1/720'ds.  Adjust these (carefully examine
		tbl output to decide whether you want to move ru or br).

		The distributed defaults (which are shown here) are suitable
		for HP Times-Roman font floppies.

	    - performance: you can preload commonly used fonts into your
	      laserjet and thereby greatly reduce transmission time.
	      Consult the manual page for pk2sfp about the -P, -i, -S and -p
	      options (don't forget to mark the pointsizes you've downloaded
	      as "b" in the lj.fonts file).

	- ditroff tuning: Many of the ditroff converters have slightly
	  different correspondences between what character is in what
	  font.  You may want to modify the *.fonts file that you're
	  using to make sure that every character you want is being
	  printed correctly.  As an example, with tpscript "@" and
	  "^" aren't S font characters - they're in the normal fonts,
	  but the dt.c table says they're "symbol".  To tune for
	  tpscript:

	    - modify psrofflib to have "-ptp" option to troff2ps (t2arg).
	    - copy dt.fonts to tp.fonts (in LIBDIR/lib).
	    - append to tp.fonts the following font override sequence:

		symbol
		^	N
		@	N

	  psdit and xtroff appear to require the same things to be done
	  for "^" and "@" (psdit prints nothing without these, and xtroff
	  prints some other characters instead).

	  Jetroff requires similar things, and jt.fonts has a more
	  extensive example of this.  Font overrides are documented
	  more completely next:

	- If you want to play around with character mappings.....
	  Eg: adding accents for your own language (ie: German)
	  The most important thing to remember is that you cannot extend
	  the CAT's character sets without modifying troff - unlike ditroff
	  where you can add them by changing the makedev files.  This
	  is how you do install overrides:

	    - Put in a map override in the appropriate *.fonts file that
	      emits the character you want in place of a character you
	      don't need in the appropriate *.fonts file.  Eg: for
	      "germandbls" in ditroff, emit "ss" instead of "ct" for
	      the cent character.  Your override (in dt.fonts) would
	      look like:

		ct N ss

	      The complete override format is:

		<troffchar> N|S|n <sequence> <x adjust> <y adjust> <scale>

	      x adjust, y adjust, scale default to 0, 0 and 0 respectively.
	      x and y adjust are multiplied by .01, then the pointsize
	      and of the output driver to give the shift factor in
	      1/resolution units.  Scale allows you to change the size
	      of that one character (eg: you think bullet is too small), but
	      it isn't recommended too much (it may not work reasonably
	      on non-postscript drivers).  Again, scale is prescaled by
	      .01 first, so 100 is 1-1.

	      <sequence> defaults to <troffchar>.  N means normal mapping
	      (eg: for fonts other than S with no cross font jumping),
	      S means symbol font, and "n" means specific font (usually >3 -
	      eg: special bracket fonts).

	    - Modify the width table for the character you're replacing
	      to have the width for the character you're emitting.
	      Eg: for germandbls in ditroff, replace the "ct" entry's
	      width in widths/widthps/R with the width for "ss".  This
	      latter step is not necessary with laserjets because the
	      build procedure builds a new width table using the
	      remapping.

    - Adding fonts after installation:
	- New Laserjet fonts should be installed in the $LJF directory.
	- Non-laserjet fonts should have their ditroff width table placed
	  in the proper widths/width?? directory.
	- Ensure that the appropriate lib/*.fonts file contains the fonts
	  you're adding.
	- at the top level, type:
	    make register
	- then
	    su root
	    make installwidths

Future directions:

You may have noticed a compile flag called "OPT" which is defined in
the distributed version of defs.h.  If enabled (via -Z/W), this enables the
experimental optimizer that I'm working on.  It works well with Postscript
output, but not with laserjet unless the fonts you use are VERY good.
It's disabled by default.  The optimizer does two things: it emits as many
characters as it can as one print directive, rather than one CAT code
per print.  On postscript and HPLJ's this is a BIG win (printer execution
speeds 3 or more times faster), but it won't work with ditroff.  The
optimizer requires access to the CAT troff width tables, and if troff2ps
can't find them, it simply doesn't optimize.  The other thing the optimizer
does is enable a new backend transmission feature (\(bs\(bs<directive>\(bs)
which will ultimately *replace* the ".tm M<directive>" feature.  Once
this occurs, troff stderr can unmerged with stdout, psfig will work better,
and special directives will no longer require breaks.  And, I might
be able to emulate \X better, and maybe even (gasp) \D and friends.

The intent is, that when I'm satisfied with the optimizer, possibly after
some patching), I can either ship a patch that explicitly makes it default,
or tell you to do it manually in the patch preamble.  Stay tuned.

CONTACT INFO:

    Chris Lewis
    Elegant Communications Inc.
    481 University Avenue, Suite 602
    Toronto, Ontario, Canada
    Voice Phone: Canada (416)-595-5425
    FAX: Canada (416)-595-5439
    Userid's for e-mail contact:
	Psroff enquiries/help/mailing list enrollment: psroff-request
	Non-psroff mail only: clewis
    UUCP routing: {uunet!attcan,utzoo}!lsuc!eci386!<userid>
    Possible internet routing: lsuc!eci386!<userid>@uunet.uu.net
    Alternates: <user>@eci386.uucp
