Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2086/README

Text File | 1990-12-28 | 28.3 KB | 665 lines

        PSROFF RELEASE 2.0 PL5 README 2.3 90/11/16

            May 14, 1990
            Chris Lewis

    This alt.sources release is based at patch level 5 of psroff 2.0.

    defs.h contains the level at which the sources have been patched.
    Previously, psroff 2.0 was only available via ftp.  If you had the
    ftp version, I suggest you completely replace it with this one,
    or, you can simply patch yours to this level - contact me for
    patch 5.

    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.  Further, there
is some testing code for emulating ditroff drawing commands (see
catconv).

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 ([e-mail] or
    [e-mail]) 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), and
      also available from the mims-iris font archives at waterloo.

      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, [e-mail])
      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.

    - psroff 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.

    - psroff 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.
            LJ+ have this as 16.  Later models support more.
        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 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 100 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