# grops

## Name



           grops - _groff_ output driver for PostScript
    


## Synopsis



           **grops**[**-glm**] [**-b** _brokenness-flags_] [**-c** _num-copies_] [**-F** _font-_
                 _directory_] [**-I** _inclusion-directory_] [**-p** _paper-format_]
                 [**-P** _prologue-file_] [**-w** _rule-thickness_] [_file_ ...]
    
           **grops --help**
    
           **grops -v**
    
           **grops --version**
    


## Description



           The GNU _roff_ PostScript output driver translates the output of
           _troff_(1) into PostScript.  Normally, _grops_ is invoked by _groff_(1)
           when the latter is given the “**-T ps** ” option.  (In this
           installation, **ps** is the default output device.)  Use _groff_ 's **-P**
           option to pass any options shown above to _grops_.  If no _file_
           arguments are given, or if _file_ is “-”, _grotty_ reads the standard
           input stream.  It writes to the standard output stream.
    
           When called with multiple _file_ arguments, _grops_ doesn't produce a
           valid document structure (one conforming to the Document
           Structuring Conventions).  To print such catenated output, it is
           necessary to deactivate DSC handling in the printing program or
           previewer.
    
           See section “Font installation” below for a guide to installing
           fonts for _grops_.
    


## Options



           **--help** displays a usage message, while **-v** and **--version** show
           version information; all exit afterward.
    
           **-b** _n_   Work around problems with spoolers, previewers, and older
                  printers.  Normally, _grops_ produces output at PostScript
                  LanguageLevel 2 that conforms to version 3.0 of the
                  Document Structuring Conventions.  Some software and
                  devices can't handle such a data stream.  The value of _n_
                  determines what _grops_ does to make its output acceptable to
                  such consumers.  If _n_ is **0** , _grops_ employs no workarounds,
                  which is the default; it can be changed by modifying the
                  **broken** directive in _grops_ 's _DESC_ file.
    
                  Add 1 to suppress generation of **%%BeginDocumentSetup** and
                  **%%EndDocumentSetup** comments; this is needed for early
                  versions of TranScript that get confused by anything
                  between the **%%EndProlog** comment and the first **%%Page**
                  comment.
    
                  Add 2 to omit lines in included files beginning with **%!** ,
                  which confuse Sun's _pageview_ previewer.
    
                  Add 4 to omit lines in included files beginning with
                  **%%Page** , **%%Trailer** and **%%EndProlog** ; this is needed for
                  spoolers that don't understand **%%BeginDocument** and **%%End‐**
                  **Document** comments.
    
                  Add 8 to write **%!PS-Adobe-2.0** rather than **%!PS-Adobe-3.0** as
                  the first line of the PostScript output; this is needed
                  when using Sun's Newsprint with a printer that requires
                  page reversal.
    
                  Add 16 to omit media size information (that is, output
                  neither a **%%DocumentMedia** comment nor the **setpagedevice**
                  PostScript command).  This was the behavior of _groff_ 1.18.1
                  and earlier; it is needed for older printers that don't
                  understand PostScript LanguageLevel 2, and is also
                  necessary if the output is further processed to produce an
                  EPS file; see subsection “Escapsulated PostScript” below.
    
           **-c** _n_   Output _n_ copies of each page.
    
           **-F** _dir_ Prepend directory dir _/dev_ name to the search path for font
                  and device description and PostScript prologue files; _name_
                  is the name of the device, usually **ps**.
    
           **-g** Generate PostScript code to guess the page length.  The
                  guess is correct only if the imageable area is vertically
                  centered on the page.  This option allows you to generate
                  documents that can be printed on both U.S. letter and A4
                  paper formats without change.
    
           **-I** _dir_ Search the directory _dir_ for files named in **\X'ps: file'**
                  and **\X'ps: import'** escape sequences.  **-I** may be specified
                  more than once; each _dir_ is searched in the given order.
                  To search the current working directory before others, add
                  “**-I .** ” at the desired place; it is otherwise searched last.
    
           **-l** Use landscape orientation rather than portrait.
    
           **-m** Turn on manual feed for the document.
    
           **-p** _fmt_ Set physical dimensions of output medium, overriding the
                  **papersize** , **paperlength** , and **paperwidth** directives in the
                  _DESC_ file.  _fmt_ can be any argument accepted by the
                  **papersize** directive; see _groff_font_(5).
    
           **-P** _prologue_
                  Use the file _prologue_ , sought in the _groff_ font search
                  path, as the PostScript prologue, overriding the default
                  (see section “Files” below) and the environment variable
                  _GROPS_PROLOGUE._
    
           **-w** _n_   Draw rules (lines) with a thickness of _n_ thousandths of an
                  em.  The default thickness is **40**(0.04 em).
    


## Usage



           The input to _grops_ must be in the format output by _troff_(1),
           described in _groff_out_(5).  In addition, the device and font
           description files for the device used must meet certain
           requirements.  The device resolution must be an integer multiple
           of 72 times the **sizescale**.  The device description file must
           contain a valid paper format; see _groff_font_(5).  Each font
           description file must contain a directive
                  internalname _psname_
           which says that the PostScript name of the font is _psname_.
    
           A font description file may also contain a directive
                  encoding _enc-file_
           which says that the PostScript font should be reencoded using the
           encoding described in _enc-file_ ; this file should consist of a
           sequence of lines of the form
                  _pschar code_
           where _pschar_ is the PostScript name of the character, and _code_ is
           its position in the encoding expressed as a decimal integer; valid
           values are in the range 0 to 255.  Lines starting with **#** and blank
           lines are ignored.  The code for each character given in the font
           description file must correspond to the code for the character in
           encoding file, or to the code in the default encoding for the font
           if the PostScript font is not to be reencoded.  This code can be
           used with the **\N** escape sequence in _troff_ to select the character,
           even if it does not have a _groff_ glyph name.  Every character in
           the font description file must exist in the PostScript font, and
           the widths given in the font description file must match the
           widths used in the PostScript font.  _grops_ assumes that a
           character with a _groff_ name of **space** is blank (makes no marks on
           the page); it can make use of such a character to generate more
           efficient and compact PostScript output.
    
           _grops_ is able to display all glyphs in a PostScript font; it is
           not limited to 256 of them.  _enc-file_ (or the default encoding if
           no encoding file is specified) just defines the order of glyphs
           for the first 256 characters; all other glyphs are accessed with
           additional encoding vectors which _grops_ produces on the fly.
    
           _grops_ can embed fonts in a document that are necessary to render
           it; this is called “downloading”.  Such fonts must be in PFA
           format.  Use _pfbtops_(1) to convert a Type 1 font in PFB format.
           Downloadable fonts must be listed a _download_ file containing lines
           of the form
                  _psname file_
           where _psname_ is the PostScript name of the font, and _file_ is the
           name of the file containing it.  Blank lines and those beginning
           with **#** are ignored; fields are separated by tabs.  _file_ is sought
           using the same mechanism as for _groff_ font description files.  The
           _download_ file itself is as well; currently, the first matching
           file found in the device and font description search path is used.
    
           If the file containing a downloadable font or imported document
           conforms to the Adobe Document Structuring Conventions, then _grops_
           interprets any comments in the files sufficiently to ensure that
           its own output is conforming.  It also supplies any needed font
           resources that are listed in the _download_ file as well as any
           needed file resources.  It is also able to handle inter-resource
           dependencies.  For example, suppose that you have a downloadable
           font called Garamond, and also a downloadable font called
           Garamond-Outline which depends on Garamond (typically it would be
           defined to copy Garamond's font dictionary, and change the
           PaintType), then it is necessary for Garamond to appear before
           Garamond-Outline in the PostScript document.  _grops_ handles this
           automatically provided that the downloadable font file for
           Garamond-Outline indicates its dependence on Garamond by means of
           the Document Structuring Conventions, for example by beginning
           with the following lines.
                  %!PS-Adobe-3.0 Resource-Font
                  %%DocumentNeededResources: font Garamond
                  %%EndComments
                  %%IncludeResource: font Garamond
           In this case, both Garamond and Garamond-Outline would need to be
           listed in the _download_ file.  A downloadable font should not
           include its own name in a **%%DocumentSuppliedResources** comment.
    
           _grops_ does not interpret **%%DocumentFonts** comments.  The
           **%%DocumentNeededResources** , **%%DocumentSuppliedResources** , **%%Include‐**
           **Resource** , **%%BeginResource** , and **%%EndResource** comments (or possibly
           the old **%%DocumentNeededFonts** , **%%DocumentSuppliedFonts** , **%%Include‐**
           **Font** , **%%BeginFont** , and **%%EndFont** comments) should be used.
    
           The default stroke and fill colors are black.  For colors defined
           in the “rgb” color space, **setrgbcolor** is used; for “cmy” and
           “cmyk”, **setcmykcolor** ; and for “gray”, **setgray**.  **setcmykcolor** is a
           PostScript LanguageLevel 2 command and thus not available on some
           older printers.
    
       **Typefaces**
           Styles called **R** , **I** , **B** , and **BI** mounted at font positions 1 to 4.
           Text fonts are grouped into families **A** , **BM** , **C** , **H** , **HN** , **N** , **P** , and **T** ,
           each having members in each of these styles.
    
                  **AR** AvantGarde-Book
                  **AI** AvantGarde-BookOblique
                  **AB** AvantGarde-Demi
                  **ABI** AvantGarde-DemiOblique
                  **BMR** Bookman-Light
                  **BMI** Bookman-LightItalic
                  **BMB** Bookman-Demi
                  **BMBI** Bookman-DemiItalic
                  **CR** Courier
                  **CI** Courier-Oblique
                  **CB** Courier-Bold
                  **CBI** Courier-BoldOblique
                  **HR** Helvetica
                  **HI** Helvetica-Oblique
                  **HB** Helvetica-Bold
                  **HBI** Helvetica-BoldOblique
                  **HNR** Helvetica-Narrow
                  **HNI** Helvetica-Narrow-Oblique
                  **HNB** Helvetica-Narrow-Bold
                  **HNBI** Helvetica-Narrow-BoldOblique
                  **NR** NewCenturySchlbk-Roman
                  **NI** NewCenturySchlbk-Italic
                  **NB** NewCenturySchlbk-Bold
                  **NBI** NewCenturySchlbk-BoldItalic
                  **PR** Palatino-Roman
                  **PI** Palatino-Italic
                  **PB** Palatino-Bold
                  **PBI** Palatino-BoldItalic
                  **TR** Times-Roman
                  **TI** Times-Italic
                  **TB** Times-Bold
                  **TBI** Times-BoldItalic
    
           Another text font is not a member of a family.
    
                  **ZCMI** ZapfChancery-MediumItalic
    
           Special fonts include **S** , the PostScript Symbol font; **ZD** , Zapf
           Dingbats; **SS**(slanted symbol), which contains oblique forms of
           lowercase Greek letters derived from Symbol; **EURO** , which offers a
           Euro glyph for use with old devices lacking it; and **ZDR** , a
           reversed version of Zapf Dingbats (with symbols flipped about the
           vertical axis).  Most glyphs in these fonts are unnamed and must
           be accessed using **\N**.  The last three are not standard PostScript
           fonts, but supplied by _groff_ and therefore included in the default
           _download_ file.
    
           _grops_ furthermore supports a naming scheme for East Asian
           typefaces shared with _grohtml_(1), _gropdf_(1), and _grotty_(1).
    
                  **CSH** Simplified Chinese, Hei style
                  **CSS** Simplified Chinese, Song style
                  **CTH** Traditional Chinese, Hei style
                  **CTS** Traditional Chinese, Song style
                  **JPG** Japanese, Gothic style
                  **JPM** Japanese, Mincho style
                  **KOG** Korean, Gothic style
                  **KOM** Korean, Mincho style
    
       **Device extension commands**
           _grops_ recognizes device extension commands produced by the _groff_
           request **device** or _roff_ **\X** escape sequence, but interprets only
           those that begin with a “**ps:** ” tag.
    
           **\X'ps: exec** _code_**'**
                  Execute the arbitrary PostScript commands _code_.  The
                  PostScript _currentpoint_ is set to the _groff_ drawing
                  position when the **\X** escape sequence is interpreted before
                  executing _code_.  The origin is at the top left corner of
                  the page; _x_ coordinates increase to the right, and
                  _y_ coordinates down the page.  A procedure **u** is defined that
                  converts _groff_ basic units to the coordinate system in
                  effect (provided the user doesn't change the scale).  For
                  example,
                         .nr x 1i
                         \X'ps: exec \nx u 0 rlineto stroke'
                  draws a horizontal line one inch long.  _code_ may make
                  changes to the graphics state, but any changes persist only
                  to the end of the page.  A dictionary containing the
                  definitions specified by the **def** and **mdef** commands is on
                  top of the dictionary stack.  If your code adds definitions
                  to this dictionary, you should allocate space for them
                  using “**\X'ps: mdef** _n_**'** ”.  Any definitions persist only until
                  the end of the page.  If you use the **\Y** escape sequence
                  with an argument that names a macro, _code_ can extend over
                  multiple lines.  For example,
                         .nr x 1i
                         .de y
                         ps: exec
                         \nx u 0 rlineto
                         stroke
                         ..
                         \Yy
                  is another way to draw a horizontal line one inch long.
                  The single backslash before “**nx** ”—the only reason to use a
                  register while defining the macro “**y** ”—is to convert a user-
                  specified dimension “**1i** ” to _groff_ basic units which are in
                  turn converted to PostScript units with the **u** procedure.
    
                  _grops_ wraps user-specified PostScript code into a
                  dictionary, nothing more.  In particular, it doesn't start
                  and end the inserted code with **save** and **restore** ,
                  respectively.  This must be supplied by the user, if
                  necessary.
    
           **\X'ps: file** _name_**'**
                  This is the same as the **exec** command except that the
                  PostScript code is read from file _name_.
    
           **\X'ps: def** _code_**'**
                  Place a PostScript definition contained in _code_ in the
                  prologue.  There should be at most one definition per **\X**
                  command.  Long definitions can be split over several **\X**
                  commands; all the _code_ arguments are simply joined together
                  separated by newlines.  The definitions are placed in a
                  dictionary which is automatically pushed on the dictionary
                  stack when an **exec** command is executed.  If you use the **\Y**
                  escape sequence with an argument that names a macro, _code_
                  can extend over multiple lines.
    
           **\X'ps: mdef** _n code_**'**
                  Like **def** , except that _code_ may contain up to _n_ definitions.
                  _grops_ needs to know how many definitions _code_ contains so
                  that it can create an appropriately sized PostScript
                  dictionary to contain them.
    
           **\X'ps: import** _file llx lly urx ury width_ [_height_]**'**
                  Import a PostScript graphic from _file_.  The arguments _llx_ ,
                  _lly_ , _urx_ , and _ury_ give the bounding box of the graphic in
                  the default PostScript coordinate system.  They should all
                  be integers: _llx_ and _lly_ are the _x_ and _y_ coordinates of the
                  lower left corner of the graphic; _urx_ and _ury_ are the _x_ and
                  _y_ coordinates of the upper right corner of the graphic;
                  _width_ and _height_ are integers that give the desired width
                  and height in _groff_ basic units of the graphic.
    
                  The graphic is scaled so that it has this width and height
                  and translated so that the lower left corner of the graphic
                  is located at the position associated with **\X** command.  If
                  the height argument is omitted it is scaled uniformly in
                  the _x_ and _y_ axes so that it has the specified width.
    
                  The contents of the **\X** command are not interpreted by
                  _troff_ , so vertical space for the graphic is not
                  automatically added, and the _width_ and _height_ arguments are
                  not allowed to have attached scaling indicators.
    
                  If the PostScript file complies with the Adobe Document
                  Structuring Conventions and contains a **%%BoundingBox**
                  comment, then the bounding box can be automatically
                  extracted from within _groff_ input by using the **psbb**
                  request.
    
                  See _groff_tmac_(5) for a description of the **PSPIC** macro
                  which provides a convenient high-level interface for
                  inclusion of PostScript graphics.
    
           **\X'ps: invis'**
           **\X'ps: endinvis'**
                  No output is generated for text and drawing commands that
                  are bracketed with these **\X** commands.  These commands are
                  intended for use when output from _troff_ is previewed before
                  being processed with _grops_ ; if the previewer is unable to
                  display certain characters or other constructs, then other
                  substitute characters or constructs can be used for
                  previewing by bracketing them with these **\X** commands.
    
                  For example, _gxditview_ is not able to display a proper
                  **\[em]** character because the standard X11 fonts do not
                  provide it; this problem can be overcome with the following
                  request.
    
                         .char \[em] \X'ps: invis'\
                         \Z'\v'-.25m'\h'.05m'\D'l .9m 0'\h'.05m''\
                         \X'ps: endinvis'\[em]
    
                  In this case, _gxditview_ is unable to display the **\[em]**
                  character and draws the line, whereas _grops_ prints the
                  **\[em]** character and ignores the line (this code is already
                  in file _Xps.tmac_ , which is loaded if a document intended
                  for _grops_ is previewed with _gxditview_).
    
           If a PostScript procedure **BPhook** has been defined via a “**ps: def** ”
           or “**ps: mdef** ” device extension command, it is executed at the
           beginning of every page (before anything is drawn or written by
           _groff_).  For example, to underlay the page contents with the word
           “DRAFT” in light gray, you might use the following.
                  .de XX
                  ps: def
                  /BPhook
                  { gsave .9 setgray clippath pathbbox exch 2 copy
                    .5 mul exch .5 mul translate atan rotate pop pop
                    /NewCenturySchlbk-Roman findfont 200 scalefont setfont
                    (DRAFT) dup stringwidth pop -.5 mul -70 moveto show
                    grestore }
                  def
                  ..
                  .devicem XX
    
           Or, to cause lines and polygons to be drawn with square linecaps
           and mitered linejoins instead of the round linecaps and linejoins
           normally used by _grops_ , use the following.
                  .de XX
                  ps: def
                  /BPhook { 2 setlinecap 0 setlinejoin } def
                  ..
                  .devicem XX
           (Square linecaps, as opposed to butt linecaps (“**0 setlinecap** ”),
           give true corners in boxed tables even though the lines are drawn
           unconnected.)
    
       **Encapsulated PostScript**
           _grops_ itself doesn't emit bounding box information.  The following
           script, _groff2eps_ , produces an EPS file.
    
                  #!/bin/sh
                  groff -P-b16 "$1" > "$1".ps
                  gs -dNOPAUSE -sDEVICE=bbox -- "$1".ps 2> "$1".bbox
                  sed -e "/^%%Orientation/r $1.bbox" \
                      -e "/^%!PS-Adobe-3.0/s/$/ EPSF-3.0/" "$1".ps > "$1".eps
                  rm "$1".ps "$1".bbox
    
           You can then use “**groff2eps foo** ” to convert file _foo_ to _foo.eps_.
    
       **TrueType and other font formats**
           To use TrueType fonts with _grops_ , convert them first to Type 42
           format, a PostScript wrapper equivalent to the PFA format
           described in _pfbtops_(1).  Several methods exist to generate a
           Type 42 wrapper; some of them involve the use of a PostScript
           interpreter such as Ghostscript—see _gs_(1).
    
           FontForge ⟨https://fontforge.org/⟩ converts most outline font
           formats.  Here's how we'd set up Roboto Slab Serif for use with
           _groff_.
    
               MAP=/usr/local/share/groff/1.23.0/font/devps/generate/text.map
               TTF=/usr/share/fonts/truetype/roboto/slab/RobotoSlab-Regular.ttf
               BASE=$(basename "$TTF")
               INT=${BASE%.ttf}
               PFA=$INT.pfa
               AFM=$INT.afm
               GFN=RSR
               DIR=$HOME/.local/groff/font
               mkdir -p "$DIR"/devps
               fontforge -lang=ff -c "Open(\"$TTF\");\
               Generate(\"$DIR/devps/$PFA\");"
               afmtodit "$DIR/devps/$AFM" "$MAP" "$DIR/devps/$GFN"
               printf "$BASE\t$PFA\n" >> "$DIR/devps/download"
    
           _fontforge_ and _afmtodit_ may produce warnings depending on font file
           attributes.  Test the font as follows.
    
               printf ".ft RSR\nHello, world!\n" | groff -F "$DIR" > hello.ps
    
           Once you're satisfied that the font works, you may want to
           generate any available related styles (for instance, Roboto Slab
           also has “Bold”, “Light”, and “Thin” styles) and set up
           _GROFF_FONT_PATH_ in your environment to include the directory you
           keep the generated fonts in so that you don't have to use the **-F**
           option.
    


## Font installation



           The following is a step-by-step font installation guide for _grops._
    
           •  Convert your font to something _groff_ understands.  This is a
              PostScript Type 1 font in PFA format or a PostScript Type 42
              font, together with an AFM file.  A PFA file begins as follows.
                     %!PS-AdobeFont-1.0:
              A PFB file contains this string as well, preceded by some non-
              printing bytes.  If your font is in PFB format, use _groff_ 's
              _pfbtops_(1) program to convert it to PFA.  For TrueType and
              other font formats, we recommend _fontforge_ , which can convert
              most outline font formats.  A Type 42 font file begins as
              follows.
                     %!PS-TrueTypeFont
              This is a wrapper format for TrueType fonts.  Old PostScript
              printers might not support them (that is, they might not have a
              built-in TrueType font interpreter).  In the following steps,
              we will consider the use of CTAN's BrushScriptX-Italic 
              ⟨https://ctan.org/tex-archive/fonts/brushscr⟩ font in PFA
              format.
    
           •  Convert the AFM file to a _groff_ font description file with the
              _afmtodit_(1) program.  For instance,
                     $ **afmtodit BrushScriptX-Italic.afm text.map BSI**
              converts the Adobe Font Metric file _BrushScriptX-Italic.afm_ to
              the _groff_ font description file _BSI_.
    
              If you have a font family which provides regular upright
              (roman), bold, italic, and bold-italic styles (where “italic”
              may be “oblique” or “slanted”), we recommend using the letters
              **R** , **B** , **I** , and **BI** , respectively, as suffixes to the _groff_ font
              family name to enable _groff_ 's font family and style selection
              features.  An example is _groff_ 's built-in support for Times:
              the font family name is abbreviated as **T** , and the _groff_ font
              names are therefore **TR** , **TB** , **TI** , and **TBI**.  In our example,
              however, the BrushScriptX font is available in a single style
              only, italic.
    
           •  Install the _groff_ font description file(s) in a _devps_
              subdirectory in the search path that _groff_ uses for device and
              font file descriptions.  See the _GROFF_FONT_PATH_ entry in
              section “Environment” of _troff_(1) for the current value of the
              font search path.  While _groff_ doesn't directly use AFM files,
              it is a good idea to store them alongside its font description
              files.
    
           •  Register fonts in the _devps/download_ file so they can be
              located for embedding in PostScript files _grops_ generates.
              Only the first _download_ file encountered in the font search
              path is read.  If in doubt, copy the default _download_ file (see
              section “Files” below) to the first directory in the font
              search path and add your fonts there.  The PostScript font name
              used by _grops_ is stored in the **internalname** field in the _groff_
              font description file.  (This name does not necessarily
              resemble the font's file name.)  We add the following line to
              _download_.
                     BrushScriptX-Italic→BrushScriptX-Italic.pfa
              A tab character, depicted as →, separates the fields.
    
           •  Test the selection and embedding of the new font.
                     printf "\\f[BSI]Hello, world!\n" | groff -T ps >hello.ps
                     see hello.pdf
    


## Old fonts



           _groff_ versions 1.19.2 and earlier contained descriptions of a
           slightly different set of the base 35 PostScript level 2 fonts
           defined by Adobe.  The older set has 314 glyphs and a larger set
           of kerning pairs; the newer one has only 229 glyphs, but includes
           the Euro sign.  For backward compatibility, these old font
           descriptions are also installed in the _/usr/local/share/groff/_
           _1.23.0/oldfont/devps_ directory.
    
           To use them, make sure that _grops_ finds the fonts before the
           default system fonts (with the same names): either give _grops_ the
           **-F** command-line option,
                  $ **groff -Tps -P-F -P/usr/local/share/groff/1.23.0/oldfont**...
           or add the directory to _groff_ 's font and device description search
           path environment variable,
                  $ **GROFF_FONT_PATH=/usr/local/share/groff/1.23.0/oldfont \**
                         **groff -Tps**...
           when the command runs.
    


## Exit status



           _grops_ exits with status **0** on successful operation, status **2** if the
           program cannot interpret its command-line arguments, and status **1**
           if it encounters an error during operation.
    


## Environment



           _GROFF_FONT_PATH_
                  A list of directories in which to seek the selected output
                  device's directory of device and font description files.
                  See _troff_(1) and _groff_font_(5).
    
           _GROPS_PROLOGUE_
                  If this is set to _foo_ , then _grops_ uses the file _foo_ (in the
                  font path) instead of the default prologue file _prologue_.
                  The option **-P** overrides this environment variable.
    
           _SOURCE_DATE_EPOCH_
                  A timestamp (expressed as seconds since the Unix epoch) to
                  use as the output creation timestamp in place of the
                  current time.  The time is converted to human-readable form
                  using _gmtime_(3) and _asctime_(3), and recorded in a
                  PostScript comment.
    
           _TZ_     The time zone to use when converting the current time to
                  human-readable form; see _tzset_(3).  If _SOURCE_DATE_EPOCH_ is
                  used, it is always converted to human-readable form using
                  UTC.
    


## Files



           _/usr/local/share/groff/1.23.0/font/devps/DESC_
                  describes the **ps** output device.
    
           _/usr/local/share/groff/1.23.0/font/devps/_ F
                  describes the font known as _F_ on device **ps**.
    
           _/usr/local/share/groff/1.23.0/font/devps/download_
                  lists fonts available for embedding within the PostScript
                  document (or download to the device).
    
           _/usr/local/share/groff/1.23.0/font/devps/prologue_
                  is the default PostScript prologue prefixed to every output
                  file.
    
           _/usr/local/share/groff/1.23.0/font/devps/text.enc_
                  describes the encoding scheme used by most PostScript
                  Type 1 fonts; the **encoding** directive of font description
                  files for the **ps** device refers to it.
    
           _/usr/local/share/groff/1.23.0/tmac/ps.tmac_
                  defines macros for use with the **ps** output device.  It is
                  automatically loaded by _troffrc_ when the **ps** output device
                  is selected.
    
           _/usr/local/share/groff/1.23.0/tmac/pspic.tmac_
                  defines the **PSPIC** macro for embedding images in a document;
                  see _groff_tmac_(5).  It is automatically loaded by _troffrc._
    
           _/usr/local/share/groff/1.23.0/tmac/psold.tmac_
                  provides replacement glyphs for text fonts that lack
                  complete coverage of the ISO Latin-1 character set; using
                  it, _groff_ can produce glyphs like eth (ð) and thorn (þ)
                  that older PostScript printers do not natively support.
    
           _grops_ creates temporary files using the template “ _grops_ XXXXXX”;
           see _groff_(1).
    


## See also



           PostScript Language Document Structuring Conventions Specification
           ⟨http://partners.adobe.com/public/developer/en/ps/5001.DSC_Spec
           .pdf⟩
    
           _afmtodit_(1), _groff_(1), _troff_(1), _pfbtops_(1), _groff_char_(7),
           _groff_font_(5), _groff_out_(5), _groff_tmac_(5)
    


* * *