# groff_mom

## Name



           groff_mom - modern macros for document composition with GNU _roff_
    


## Synopsis



           **groff -mom**[_option_ ...] [_file_ ...]
    
           **groff -m mom**[_option_ ...] [_file_ ...]
    


## Description



           _mom_ is a macro set for _groff_ , designed primarily to prepare
           documents for PDF and PostScript output.  _mom_ provides macros in
           two categories: typesetting and document processing.  The former
           provide access to _groff_ 's typesetting capabilities in ways that
           are simpler to master than _groff_ 's requests and escape sequences.
           The latter provide highly customizable markup tags that allow the
           user to design and output professional-looking documents with a
           minimum of typesetting intervention.
    
           Files processed with _pdfmom_(1) produce PDF documents.  The
           documents include a PDF outline that appears in the navigation
           pane panel of document viewers, and may contain clickable internal
           and external links.
    
           Normally, _groff_ 's native PDF driver, _gropdf_(1), is used to
           generate the output.  When _pdfmom_ is given the “**-T ps** ” option, it
           still produces PDF, but processing is delegated to _pdfroff_ , which
           uses _groff_ 's PostScript driver, _grops_(1).  Not all PDF features
           are available when **-T ps** is given; its primary use is to allow
           processing of files with embedded PostScript images.
    
           Files processed with **groff -mom**(or **-m mom**) format for the device
           specified with the **-T** option.  (In this installation, **ps** is the
           default output device.)
    
           _mom_ comes with her own comprehensive documentation in HTML.  A PDF
           manual, “Producing PDFs with _groff_ and _mom_ ”, discusses preparation
           of PDF documents with _mom_ in detail.
    


## Files



           _/usr/local/share/groff/1.23.0/tmac/mom.tmac_
                  is a wrapper enabling the package to be loaded with the
                  option “**-m mom** ”.
    
           _/usr/local/share/groff/1.23.0/tmac/om.tmac_
                  implements the package.
    
           _/usr/local/share/doc/groff-1.23.0/html/mom/toc.html_
                  is the entry point to the HTML documentation.
    
           _/usr/local/share/doc/groff-1.23.0/pdf/mom-pdf.pdf_
                  is “Producing PDFs with _groff_ and _mom_ ”, by Deri James and
                  Peter Schaffter.
    
           _/usr/local/share/doc/groff-1.23.0/examples/mom/_ *_.mom_
                  are examples of _mom_ usage.
    


## Reference



       **Escape sequences**
           **\*[**_< colorname>_**]**
                  begin using an initialized colour inline
    
           **\*[BCK** _n_**]**
                  move backward in a line
    
           **\*[BOLDER]**
                  invoke pseudo bold inline (related to macro **.SETBOLDER**)
    
           **\*[BOLDERX]**
                  off pseudo bold inline (related to macro **.SETBOLDER**)
    
           **\*[BU** _n_**]**
                  move characters pairs closer together inline (related to
                  macro **.KERN**)
    
           **\*[COND]**
                  invoke pseudo condensing inline (related to macro
                  **.CONDENSE**)
    
           **\*[CONDX]**
                  off pseudo condensing inline (related to macro **.CONDENSE**)
    
           **\*[CONDSUP]**...**\*[CONDSUPX]**
                  pseudo-condensed superscript
    
           **\*[DOWN** _n_**]**
                  temporarily move downward in a line
    
           **\*[EN-MARK]**
                  mark initial line of a range of line numbers (for use with
                  line numbered endnotes)
    
           **\*[EXT]**
                  invoke pseudo extending inline (related to macro **.EXTEND**)
    
           **\*[EXTX]**
                  off pseudo condensing inline (related to macro **.EXTEND**)
    
           **\*[EXTSUP]**...**\*[EXTSUPX]**
                  pseudo extended superscript
    
           **\*[FU** _n_**]**
                  move characters pairs further apart inline (related to
                  macro **.KERN**)
    
           **\*[FWD** _n_**]**
                  move forward in a line
    
           **\*[LEADER]**
                  insert leaders at the end of a line
    
           **\*[RULE]**
                  draw a full measure rule
    
           **\*[SIZE** _n_**]**
                  change the point size inline (related to macro **.PT_SIZE**)
    
           **\*[SLANT]**
                  invoke pseudo italic inline (related to macro **.SETSLANT**)
    
           **\*[SLANTX]**
                  off pseudo italic inline (related to macro **.SETSLANT**)
    
           **\*[ST** _< n>_**]**...**\*[ST** _< n>_**X]**
                  string tabs (mark tab positions inline)
    
           **\*[SUP]**...**\*[SUPX]**
                  superscript
    
           **\*[TB+]**
                  inline escape for **.TN**(_Tab Next_)
    
           **\*[UL]**...**\*[ULX]**
                  invoke underlining inline (fixed width fonts only)
    
           **\*[UP** _n_**]**
                  temporarily move upward in a line
    
       **Macros**
           **.AUTOLEAD**
                  set the linespacing relative to the point size
    
           **.B_MARGIN**
                  set a bottom margin
    
           **.BR** break a justified line
    
           **.CENTER**
                  set line-by-line quad centre
    
           **.CONDENSE**
                  set the amount to pseudo condense
    
           **.EL** break a line without advancing on the page
    
           **.EXTEND**
                  set the amount to pseudo extend
    
           **.FALLBACK_FONT**
                  establish a fallback font (for missing fonts)
    
           **.FAM** alias to **.FAMILY**
    
           **.FAMILY** _< family>_
                  set the _family type_
    
           **.FT** set the font style (roman, italic, etc.)
    
           **.HI [**_< measure>_ **]**
                  hanging indent
    
           **.HY** automatic hyphenation on/off
    
           **.HY_SET**
                  set automatic hyphenation parameters
    
           **.IB [**_< left measure> <right measure>_ **]**
                  indent both
    
           **.IBX [ CLEAR ]**
                  exit indent both
    
           **.IL [**_< measure>_ **]**
                  indent left
    
           **.ILX [ CLEAR ]**
                  exit indent left
    
           **.IQ [ CLEAR ]**
                  quit any/all indents
    
           **.IR [**_< measure>_ **]**
                  indent right
    
           **.IRX [ CLEAR ]**
                  exit indent right
    
           **.JUSTIFY**
                  justify text to both margins
    
           **.KERN** automatic character pair kerning on/off
    
           **.L_MARGIN**
                  set a left margin (page offset)
    
           **.LEFT** set line-by-line quad left
    
           **.LL** set a line length
    
           **.LS** set a linespacing (leading)
    
           **.PAGE** set explicit page dimensions and margins
    
           **.PAGEWIDTH**
                  set a custom page width
    
           **.PAGELENGTH**
                  set a custom page length
    
           **.PAPER** _< paper_type>_
                  set common paper sizes (letter, A4, etc)
    
           **.PT_SIZE**
                  set the point size
    
           **.QUAD** "justify" text left, centre, or right
    
           **.R_MARGIN**
                  set a right margin
    
           **.RIGHT** set line-by-line quad right
    
           **.SETBOLDER**
                  set the amount of emboldening
    
           **.SETSLANT**
                  set the degree of slant
    
           **.SPREAD**
                  force justify a line
    
           **.SS** set the sentence space size
    
           **.T_MARGIN**
                  set a top margin
    
           **.TI [**_< measure>_ **]**
                  temporary left indent
    
           **.WS** set the minimum word space size
    


## Documentation of details



       **Details of inline escape sequences in alphabetical order**
           **\*[**_< colorname>_**]**
                  begin using an initialized colour inline
    
           **\*[BCK** _n_**]**
                  move backward in a line
    
           **\*[BOLDER]**
           **\*[BOLDERX]**
                  Emboldening on/off
    
                  **\*[BOLDER]** begins emboldening type.  **\*[BOLDERX]** turns the
                  feature off.  Both are inline escape sequences; therefore,
                  they should not appear as separate lines, but rather be
                  embedded in text lines, like this:
                         Not **\*[BOLDER]** everything**\*[BOLDERX]** is as it seems.
    
                  Alternatively, if you wanted the whole line emboldened, you
                  should do
                         **\*[BOLDER]** Not everything is as it seems.**\*[BOLDERX]**
                  Once **\*[BOLDER]** is invoked, it remains in effect until
                  turned off.
    
                  Note: If you're using the document processing macros with
                  **.PRINTSTYLE TYPEWRITE** , _mom_ ignores **\*[BOLDER]** requests.
    
           **\*[BU** _n_**]**
                  move characters pairs closer together inline (related to
                  macro **.KERN**)
    
           **\*[COND]**
           **\*[CONDX]**
                  Pseudo-condensing on/off
    
                  **\*[COND]** begins pseudo-condensing type.  **\*[CONDX]** turns
                  the feature off.  Both are inline escape sequences;
                  therefore, they should not appear as separate lines, but
                  rather be embedded in text lines, like this:
                         **\*[COND]**_Not everything is as it seems._**\*[CONDX]**
                  **\*[COND]** remains in effect until you turn it off with
                  **\*[CONDX]**.
    
                  IMPORTANT: You must turn **\*[COND]** off before making any
                  changes to the point size of your type, either via the
                  **.PT_SIZE** macro or with the **\s** inline escape sequence.  If
                  you wish the new point size to be pseudo-condensed, simply
                  reinvoke **\*[COND]** afterward.  Equally, **\*[COND]** must be
                  turned off before changing the condense percentage with
                  **.CONDENSE**.
    
                  Note: If you're using the document processing macros with
                  **.PRINTSTYLE TYPEWRITE** , _mom_ ignores **\*[COND]** requests.
    
           **\*[CONDSUP]**...**\*[CONDSUPX]**
                  pseudo-condensed superscript
    
           **\*[DOWN** _n_**]**
                  temporarily move downward in a line
    
           **\*[EN-MARK]**
                  mark initial line of a range of line numbers (for use with
                  line numbered endnotes)
    
           **\*[EXT]**
           **\*[EXTX]**
                  Pseudo-extending on/off
    
                  **\*[EXT]** begins pseudo-extending type.  **\*[EXTX]** turns the
                  feature off.  Both are inline escape sequences; therefore,
                  they should not appear as separate lines, but rather be
                  embedded in text lines, like this:
                         **\*[EXT]**_Not everything is as it seems._**\*[EXTX]**
                  **\*[EXT]** remains in effect until you turn it off with
                  **\*[EXTX]**.
    
                  IMPORTANT: You must turn **\*[EXT]** off before making any
                  changes to the point size of your type, either via the
                  **.PT_SIZE** macro or with the **\s** inline escape sequence.  If
                  you wish the new point size to be _pseudo-extended_ , simply
                  reinvoke **\*[EXT]** afterward.  Equally, **\*[EXT]** must be
                  turned off before changing the extend percentage with
                  **.EXTEND**.
    
                  Note: If you are using the document processing macros with
                  **.PRINTSTYLE TYPEWRITE** , _mom_ ignores **\*[EXT]** requests.
    
           **\*[EXTSUP]**...**\*[EXTSUPX]**
                  pseudo extended superscript
    
           **\*[FU** _n_**]**
                  move characters pairs further apart inline (related to
                  macro **.KERN**)
    
           **\*[FWD** _n_**]**
                  move forward in a line
    
           **\*[LEADER]**
                  insert leaders at the end of a line
    
           **\*[RULE]**
                  draw a full measure rule
    
           **\*[SIZE** _n_**]**
                  change the point size inline (related to macro **.PT_SIZE**)
    
           **\*[SLANT]**
           **\*[SLANTX]**
                  Pseudo italic on/off
    
                  **\*[SLANT]** begins _pseudo-italicizing type_.  **\*[SLANTX]** turns
                  the feature off.  Both are inline escape sequences;
                  therefore, they should not appear as separate lines, but
                  rather be embedded in text lines, like this:
                         Not **\*[SLANT]** everything**\*[SLANTX]** is as it seems.
    
                  Alternatively, if you wanted the whole line _pseudo-_
                  _italicized_ , you'd do
                         **\*[SLANT]** Not everything is as it seems.**\*[SLANTX]**
    
                  Once **\*[SLANT]** is invoked, it remains in effect until
                  turned off.
    
                  Note: If you're using the document processing macros with
                  **.PRINTSTYLE TYPEWRITE** , _mom_ underlines pseudo-italics by
                  default.  To change this behaviour, use the special macro
                  **.SLANT_MEANS_SLANT**.
    
           **\*[ST** _< number>_**]**...**\*[ST** _< number>_**X]**
                  Mark positions of string tabs
    
                  The _quad_ direction must be **LEFT** or **JUSTIFY**(see **.QUAD** and
                  **.JUSTIFY**) or the _no-fill mode_ set to **LEFT** in order for
                  these inlines to function properly.  Please see _IMPORTANT_ ,
                  below.
    
                  String tabs need to be marked off with inline escape
                  sequences before being set up with the **.ST** macro.  Any
                  input line may contain string tab markers.  _< number>_,
                  above, means the numeric identifier of the tab.
    
                  The following shows a sample input line with string tab
                  markers.
                         **\*[ST1]** De minimus**\*[ST1X]** non curat**\*[ST2]** lex**\*[ST2X]**.
    
                  String _tab 1_ begins at the start of the line and ends after
                  the word _time_.  String _tab 2_ starts at _good_ and ends after
                  _men_.  _Inline escape sequences_ (e.g., _font_ or _point size_
                  _changes_ , or horizontal movements, including padding) are
                  taken into account when _mom_ determines the _position_ and
                  _length_ of _string tabs_.
    
                  Up to nineteen string tabs may be marked (not necessarily
                  all on the same line, of course), and they must be numbered
                  between 1 and 19.
    
                  Once string tabs have been marked in input lines, they have
                  to be _set_ with **.ST** , after which they may be called, by
                  number, with **.TAB**.
    
                  Note: Lines with string tabs marked off in them are normal
                  input lines, i.e. they get printed, just like any input
                  line.  If you want to set up string tabs without the line
                  printing, use the **.SILENT** macro.
    
                  _IMPORTANT:_ Owing to the way _groff_ processes input lines and
                  turns them into output lines, it is not possible for _mom_ to
                  _guess_ the correct starting position of string tabs marked
                  off in lines that are centered or set flush right.
    
                  Equally, she cannot guess the starting position if a line
                  is fully justified and broken with **.SPREAD**.
    
                  In other words, in order to use string tabs, **LEFT** must be
                  active, or, if **.QUAD LEFT** or **JUSTIFY** are active, the line
                  on which the _string tabs_ are marked must be broken _manually_
                  with **.BR**(but not **.SPREAD**).
    
                  To circumvent this behaviour, I recommend using the **PAD** to
                  set up string tabs in centered or flush right lines.  Say,
                  for example, you want to use a _string tab_ to _underscore_ the
                  text of a centered line with a rule.  Rather than this,
                         **.CENTER**
                         **\*[ST1]A line of text\*[ST1X]\c**
                         **.EL**
                         **.ST 1**
                         **.TAB 1**
                         **.PT_SIZE 24**
                         **.ALD 3p**
                         **\*[RULE]**
                         **.RLD 3p**
                         **.TQ**
                  you should do:
                         .QUAD CENTER
                         .PAD "#\*[ST1]A line of text\*[ST1X]#"
                         .EL
                         .ST 1
                         .TAB 1
                         .PT_SIZE 24
                         .ALD 3p
                         \" You can't use \*[UP] or \*[DOWN] with \*[RULE].
                         .RLD 3p
                         .TQ
    
           **\*[SUP]**...**\*[SUPX]**
                  superscript
    
           **\*[TB+]**
                  Inline escape for **.TN**(_Tab Next_)
    
           **\*[UL]**...**\*[ULX]**
                  invoke underlining inline (fixed width fonts only)
    
           **\*[UP** _n_**]**
                  temporarily move upward in a line
    
       **Details of macros in alphabetical order**
           **.AUTOLEAD**
                  set the linespacing relative to the point size
    
           **.B_MARGIN** _< bottom margin>_
                  Bottom Margin
    
                  Requires a unit of measure
    
                  **.B_MARGIN** sets a nominal position at the bottom of the page
                  beyond which you don't want your type to go.  When the
                  bottom margin is reached, _mom_ starts a new page.  **.B_MARGIN**
                  **requires a unit of measure.** Decimal fractions are allowed.
                  To set a nominal bottom margin of 3/4 inch, enter
                         **.B_MARGIN .75i**
    
                  Obviously, if you haven't spaced the type on your pages so
                  that the last lines fall perfectly at the bottom margin,
                  the margin will vary from page to page.  Usually, but not
                  always, the last line of type that fits on a page before
                  the bottom margin causes mom to start a new page.
    
                  Occasionally, owing to a peculiarity in _groff_ , an extra
                  line will fall below the nominal bottom margin.  If you're
                  using the document processing macros, this is unlikely to
                  happen; the document processing macros are very hard-nosed
                  about aligning bottom margins.
    
                  Note: The meaning of **.B_MARGIN** is slightly different when
                  you're using the document processing macros.
    
           **.FALLBACK_FONT** _< fallback font>_ **[ ABORT | WARN ]**
                  Fallback Font
    
                  In the event that you pass an invalid argument to **.FAMILY**
                  (i.e. a non-existent _family_), _mom_ , by default, uses the
                  _fallback font_ , **Courier Medium Roman**(**CR**), in order to
                  continue processing your file.
    
                  If you'd prefer another _fallback font_ , pass **.FALLBACK_FONT**
                  the full _family+font name_ of the _font_ you'd like.  For
                  example, if you'd rather the _fallback font_ were **Times Roman**
                  **Medium Roman** ,
                         **.FALLBACK_FONT TR**
                  would do the trick.
    
                  **Mom** issues a warning whenever a _font style set_ with **.FT**
                  does not exist, either because you haven't registered the
                  style or because the _font style_ does not exist in the
                  current _family set_ with **.FAMILY**.  By default, **mom** then
                  aborts, which allows you to correct the problem.
    
                  If you'd prefer that **mom** not abort on non-existent _fonts_ ,
                  but rather continue processing using a _fallback font_ , you
                  can pass **.FALLBACK_FONT** the argument **WARN** , either by
                  itself, or in conjunction with your chosen _fallback font_**.**
    
                  Some examples of invoking **.FALLBACK_FONT** :
    
                  **.FALLBACK_FONT WARN**
                         _mom_ will issue a warning whenever you try to access
                         a non-existent _font_ but will continue processing
                         your file with the default _fallback font_ , **Courier**
                         **Medium Roman**.
    
                  **.FALLBACK_FONT TR WARN**
                         **mom** will issue a warning whenever you try to access
                         a non-existent _font_ but will continue processing
                         your file with a _fallback font_ of **Times Roman Medium**
                         **Roman** ; additionally, **TR** will be the _fallback font_
                         whenever you try to access a _family_ that does not
                         exist.
    
                  **.FALLBACK_FONT TR ABORT**
                         **mom** will abort whenever you try to access a non-
                         existent **font** , and will use the _fallback font_ **TR**
                         whenever you try to access a _family_ that does not
                         exist.  If, for some reason, you want to revert to
                         **ABORT** , just enter **".FALLBACK_FONT ABORT"** and _mom_
                         will once again abort on _font errors_.
    
           **.FAM** _< family>_
                  Type Family, alias of **.FAMILY**
    
           **.FAMILY** _< family>_
                  Type Family, alias of **.FAM**
    
                  **.FAMILY** takes one argument: the name of the _family_ you
                  want.  _Groff_ comes with a small set of basic families, each
                  identified by a 1-, 2- or 3-letter mnemonic.  The standard
                  families are:
                         **A   = Avant Garde**
                         **BM  = Bookman**
                         **H   = Helvetica**
                         **HN  = Helvetica Narrow**
                         **N   = New Century Schoolbook**
                         **P   = Palatino**
                         **T   = Times Roman**
                         **ZCM = Zapf Chancery**
    
                  The argument you pass to **.FAMILY** is the identifier at left,
                  above.  For example, if you want **Helvetica** , enter
                         **.FAMILY H**
    
                  Note: The font macro (**.FT**) lets you specify both the type
                  _family_ and the desired font with a single macro.  While
                  this saves a few keystrokes, I recommend using **.FAMILY for**
                  _family_ , and **.FT for** _font_ , except where doing so is
                  genuinely inconvenient.  **ZCM** , for example, only exists in
                  one style: **Italic**(**I**).
    
                  Therefore,
                         **.FT ZCMI**
                  makes more sense than setting the _family_ to **ZCM** , then
                  setting the _font_ to _I_.
    
                  Additional note: If you are running a _groff_ version prior
                  to 1.19.2, you must follow all **.FAMILY** requests with a **.FT**
                  request, otherwise _mom_ will set all type up to the next **.FT**
                  request in the fallback font.
    
                  When running _groff_ 1.19.2 or later, and you call the
                  **.FAMILY** macro, _mom remembers_ the font style (such as roman
                  or italic) currently in use (if the font style exists in
                  the new _family_) and continues to use the same font style in
                  the new family.  For example:
                         **.FAMILY BM** _\" Bookman family_
                         **.FT I** _\" Medium Italic_
                         _< some text> \" Bookman Medium Italic_
                         **.FAMILY H** _\" Helvetica family_
                         _< more text> \" Helvetica Medium Italic_
    
                  However, if the font style does not exist in the new
                  family, _mom_ sets all subsequent type in the fallback font
                  (by default, **Courier Medium Roman**) until she encounters a
                  **.FT** call that's valid for the _family_.
    
                  For example, assuming you don't have the font **Medium**
                  **Condensed Roman**(_mom_ extension _CD_) in the _Helvetica family_ :
                         **.FAMILY UN** _\" Univers family_
                         **.FT CD** _\" Medium Condensed_
                         _< some text> \" Univers Medium Condensed_
                         **.FAMILY H** _\" Helvetica family_
                         _< more text> \" Courier Medium Roman!_
    
                  In the above example, you must follow **.FAMILY H** with a **.FT**
                  request that's valid for **Helvetica**.
    
                  Please see the Appendices, _Adding fonts to groff_ , for
                  information on adding fonts and families to
                  _groff_ ,_as_ well _as_ to see a list of the extensions _mom_ provides
                  to _groff_ 's basic **R** , **I** , **B** , **BI** styles.
    
                  Suggestion: When adding _families to groff_ , I recommend
                  following the established standard for the naming families
                  and fonts.  For example, if you add the **Garamond** family,
                  name the font files
                         **GARAMONDR**
                         **GARAMONDI**
                         **GARAMONDB**
                         **GARAMONDBI**
                  **GARAMOND then becomes a valid** _family name_ you can pass to
                  **.FAMILY**.  (You could, of course, shorten **GARAMOND** to just
                  **G** , or **GD**.)  **R** , **I** , **B** , and **BI** after **GARAMOND** are the _roman_ ,
                  _italic_ , _bold_ and _bold-italic_ fonts respectively.
    
           **.FONT R | B | BI |**_< any other valid font style>_
                  Alias to **.FT**
    
           **.FT R | B | BI |**_< any other valid font style>_
                  Set font
    
                  By default, _groff_ permits **.FT** to take one of four possible
                  arguments specifying the desired font:
                         **R = (Medium) Roman**
                         **I = (Medium) Italic**
                         **B = Bold (Roman)**
                         **BI = Bold Italic**
    
                  For example, if your _family_ is **Helvetica** , entering
                         **.FT B**
                  will give you the _Helvetica bold font_.  If your _family_ were
                  **Palatino** , you'd get the _Palatino bold font_.
    
                  **Mom** considerably extends the range of arguments you can
                  pass to **.FT** , making it more convenient to add and access
                  fonts of differing weights and shapes within the same
                  family.
    
                  Have a look here for a list of the weight/style arguments
                  _mom_ allows.  Be aware, though, that you must have the
                  fonts, correctly installed and named, in order to use the
                  arguments.  (See _Adding fonts to groff_ for instructions and
                  information.)  Please also read the _ADDITIONAL NOTE_ found
                  in the description of the **.FAMILY** macro.
    
                  How _mom_ reacts to an invalid argument to **.FT** depends on
                  which version of _groff_ you're using.  If your _groff_ version
                  is 1.19.2 or later, _mom_ will issue a warning and, depending
                  on how you've set up the fallback font, either continue
                  processing using the fallback font, or abort (allowing you
                  to correct the problem).  In earlier versions, _mom_ will
                  silently continue processing, using either the fallback
                  font or the font that was in effect prior to the invalid
                  **.FT** call.
    
                  **.FT** will also accept, as an argument, a full _family_ and
                  _font name_.
    
                  For example,
                         **.FT HB**
                  will set subsequent type in _Helvetica Bold_.
    
                  However, I strongly recommend keeping _family_ and _font_
                  separate except where doing so is genuinely inconvenient.
    
                  For inline control of _fonts_ , see _Inline Escapes_ , font
                  control.
    
           **.HI [**_< measure>_ **]**
                  Hanging indent — the optional argument requires a unit of
                  measure.
    
                  A hanging indent looks like this:
                         The thousand injuries of Fortunato I had borne as best I
                           could, but when he ventured upon insult, I vowed
                           revenge.  You who so well know the nature of my soul
                           will not suppose, however, that I gave utterance to a
                           threat, at length I would be avenged...
                  The first line of text _hangs_ outside the _left margin_.
    
                  In order to use _hanging indents_ , you must first have a _left_
                  _indent_ active (set with either **.IL** or **.IB**).  **Mom** will not
                  hang text outside the _left margin set_ with **.L_MARGIN** or
                  outside the _left margin_ of a _tab_.
    
                  The first time you invoke **.HI** , you must give it a **measure**.
                  If you want the first line of a paragraph to _hang by_ , say,
                  _1 pica_ , do
                         **.IL 1P**
                         **.HI 1P**
                  Subsequent invocations of **.HI** do not require you to supply
                  a _measure_ ; _mom_ keeps track of the last measure you gave it.
    
                  Generally speaking, you should invoke **.HI** immediately prior
                  to the line you want hung (i.e. without any intervening
                  control lines).  And because _hanging indents_ affect only
                  one line, there's no need to turn them off.
    
                  _IMPORTANT:_ Unlike **IL** , **IR** and **IB** , measures given to **.HI** are
                  NOT additive.  Each time you pass a measure to **.HI** , the
                  measure is treated literally.  _Recipe:_ A numbered list
                  using _hanging indents_
    
                  _Note: mom_ has macros for setting lists.  This recipe exists
                  to demonstrate the use of _hanging indents_ only.
                         .PAGE 8.5i 11i 1i 1i 1i 1i
                         .FAMILY  T
                         .FT      R
                         .PT_SIZE 12
                         .LS      14
                         .JUSTIFY
                         .KERN
                         .SS 0
                         .IL \w'\0\0.'
                         .HI \w'\0\0.'
                         1.\0The most important point to be considered is whether
                         the answer to the meaning of Life, the Universe, and
                         Everything really is 42.  We have no one's word on the
                         subject except Mr. Adams's.
                         .HI
                         2.\0If the answer to the meaning of Life, the Universe,
                         and Everything is indeed 42, what impact does this have on
                         the politics of representation?  42 is, after all not a
                         prime number.  Are we to infer that prime numbers don't
                         deserve equal rights and equal access in the universe?
                         .HI
                         3.\0If 42 is deemed non-exclusionary, how do we present
                         it as the answer and, at the same time, forestall debate
                         on its exclusionary implications?
    
                  First, we invoke a left indent with a measure equal to the
                  width of 2 figures spaces plus a period (using the \w
                  inline escape).  At this point, the left indent is active;
                  text afterward would normally be indented.  However, we
                  invoke a hanging indent of exactly the same width, which
                  hangs the first line (and first line only!) to the left of
                  the indent by the same distance (in this case, that means
                  “out to the left margin”).  Because we begin the first line
                  with a number, a period, and a figure space, the actual
                  text (_The most important point..._) starts at exactly the
                  same spot as the indented lines that follow.
    
                  Notice that subsequent invocations of **.HI** don't require a
                  _measure_ to be given.
    
                  Paste the example above into a file and preview it with
                         **pdfmom filename.mom | ps2pdf - filename.pdf**
                  to see hanging indents in action.
    
           **.IB [**_< left measure> <right measure>_ **]**
                  Indent both — the optional argument requires a unit of
                  measure
    
                  **.IB** allows you to set or invoke a left and a right indent
                  at the same time.
    
                  At its first invocation, you must supply a measure for both
                  indents; at subsequent invocations when you wish to supply
                  a measure, both must be given again.  As with **.IL** and **.IR** ,
                  the measures are added to the values previously passed to
                  the macro.  Hence, if you wish to change just one of the
                  values, you must give an argument of zero to the other.
    
                  _A word of advice:_ If you need to manipulate left and right
                  indents separately, use a combination of **.IL** and **.IR**
                  instead of **.IB**.  You'll save yourself a lot of grief.
    
                  A _minus sign_ may be prepended to the arguments to subtract
                  from their current values.  The \w inline escape may be
                  used to specify text-dependent measures, in which case no
                  unit of measure is required.  For example,
                         **.IB \w'margarine' \w'jello'**
                  left indents text by the width of the word _margarine_ and
                  right indents by the width of _jello_.
    
                  Like **.IL** and **.IR** , **.IB** with no argument indents by its last
                  active values.  See the brief explanation of how mom
                  handles indents for more details.
    
                  _Note:_ Calling a _tab_ (with **.TAB <n>**) automatically cancels
                  any active indents.
    
                  _Additional note:_ Invoking **.IB** automatically turns off **.IL**
                  and **.IR**.
    
           **.IL [**_< measure>_ **]**
                  Indent left — the optional argument requires a unit of
                  measure
    
                  **.IL** indents text from the left margin of the page, or if
                  you're in a _tab_ , from the left edge of the _tab_.  Once _IL_ is
                  on, the _left indent_ is applied uniformly to every
                  subsequent line of text, even if you change the line
                  length.
    
                  The first time you invoke **.IL** , you must give it a measure.
                  Subsequent invocations with a measure add to the previous
                  measure.  A minus sign may be prepended to the argument to
                  subtract from the current measure.  The **\w** inline escape
                  may be used to specify a text-dependent measure, in which
                  case no unit of measure is required.  For example,
                         **.IL \w'margarine'**
                  indents text by the width of the word _margarine_.
    
                  With no argument, **.IL** indents by its last active value.
                  See the brief explanation of how _mom_ handles indents for
                  more details.
    
                  _Note:_ Calling a _tab_ (with **.TAB <n>**) automatically cancels
                  any active indents.
    
                  _Additional note:_ Invoking **.IL** automatically turns off **IB**.
    
           **.IQ [**_< measure>_ **]**
                  IQ — quit any/all indents
    
                  _IMPORTANT NOTE:_ The original macro for quitting all indents
                  was **.IX**.  This usage has been deprecated in favour of **IQ**.
                  **.IX** will continue to behave as before, but _mom_ will issue a
                  warning to _stderr_ indicating that you should update your
                  documents.
    
                  As a consequence of this change, **.ILX** , **.IRX** and **.IBX** may
                  now also be invoked as **.ILQ** , **.IRQ** and **.IBQ**.  Both forms are
                  acceptable.
    
                  Without an argument, the macros to quit indents merely
                  restore your original margins and line length.  The
                  measures stored in the indent macros themselves are saved
                  so you can call them again without having to supply a
                  measure.
    
                  If you pass these macros the optional argument **CLEAR** , they
                  not only restore your original left margin and line length,
                  but also clear any values associated with a particular
                  indent style.  The next time you need an indent of the same
                  style, you have to supply a measure again.
    
                  **.IQ CLEAR** , as you'd suspect, quits and clears the values
                  for all indent styles at once.
    
           **.IR [**_< measure>_ **]**
                  Indent right — the optional argument requires a unit of
                  measure
    
                  **.IR** indents text from the _right margin_ of the page, or if
                  you're in a _tab_ , from the end of the _tab_.
    
                  The first time you invoke **.IR** , you must give it a measure.
                  Subsequent invocations with a measure add to the previous
                  indent measure.  A _minus sign_ may be prepended to the
                  argument to subtract from the current indent measure.  The
                  \w inline escape may be used to specify a text-dependent
                  measure, in which case no _unit of measure_ is required.  For
                  example,
                         **.IR \w'jello'**
                  indents text by the width of the word _jello_.
    
                  With no argument, **.IR** indents by its last active value.
                  See the brief explanation of how _mom_ handles indents for
                  more details.
    
                  _Note:_ Calling a _tab_ (with **.TAB <n>**) automatically cancels
                  any active indents.
    
                  _Additional note:_ Invoking **.IR** automatically turns off **IB**.
    
           **.L_MARGIN** _< left margin>_
                  Left Margin
    
                  L_MARGIN establishes the distance from the left edge of the
                  printer sheet at which you want your type to start.  It may
                  be used any time, and remains in effect until you enter a
                  new value.
    
                  Left indents and tabs are calculated from the value you
                  pass to **.L_MARGIN** , hence it's always a good idea to invoke
                  it before starting any serious typesetting.  A unit of
                  measure is required.  Decimal fractions are allowed.
                  Therefore, to set the left margin at 3 picas (1/2 inch),
                  you'd enter either
                         **.L_MARGIN 3P**
                  or
                         **.L_MARGIN .5i**
    
                  If you use the macros **.PAGE** , **.PAGEWIDTH** or **.PAPER** without
                  invoking **.L_MARGIN**(either before or afterward), _mom_
                  automatically sets **.L_MARGIN** to _1 inch_.
    
                  Note: **.L_MARGIN** behaves in a special way when you're using
                  the document processing macros.
    
           **.MCO** Begin multi-column setting.
    
                  **.MCO**(_Multi-Column On_) is the _macro_ you use to begin _multi-_
                  _column setting_.  It marks the current baseline as the top
                  of your columns, for use later with **.MCR**.  See the
                  introduction to columns for an explanation of _multi-columns_
                  and some sample input.
    
                  _Note:_ Do not confuse **.MCO** with the **.COLUMNS** macro in the
                  document processing macros.
    
           **.MCR** Once you've turned _multi-columns_ on (with **.MCO**), **.MCR** , at
                  any time, returns you to the _top of your columns_.
    
           **.MCX [**_< distance to advance below longest column>_ **]**
                  Optional argument requires a unit of measure.
    
                  Exit multi-columns.
    
                  **.MCX** takes you out of any _tab_ you were in (by silently
                  invoking **.TQ**) and advances to the bottom of the longest
                  column.
    
                  Without an argument, **.MCX** advances _1 linespace_ below the
                  longest column.
    
                  Linespace, in this instance, is the leading in effect at
                  the moment **.MCX** is invoked.
    
                  If you pass the _< distance>_ argument to **.MCX** , it advances _1_
                  _linespace_ below the longest column (see above) _PLUS_ the
                  distance specified by the argument.  The argument requires
                  a unit of measure; therefore, to advance an extra 6 points
                  below where **.MCX** would normally place you, you'd enter
                         **.MCX 6p**
    
                  _Note:_ If you wish to advance a precise distance below the
                  baseline of the longest column, use **.MCX** with an argument
                  of **0**(zero; no _unit of measure_ required) in conjunction
                  with the **.ALD** macro, like this:
                         **.MCX 0**
                         **.ALD 24p**
                  The above advances to precisely _24 points_ below the
                  baseline of the longest column.
    
           **.NEWPAGE**
    
                  Whenever you want to start a new page, use **.NEWPAGE** , by
                  itself with no argument.  **Mom** will finish up processing the
                  current page and move you to the top of a new one (subject
                  to the top margin set with **.T_MARGIN**).
    
           **.PAGE** _< width>_ **[**_< length>_ **[**_< lm>_ **[**_< rm>_ **[**_< tm>_ **[**_< bm>_ **] ] ] ] ]**
    
                  All arguments require a unit of measure
    
                  _IMPORTANT:_ If you're using the document processing macros,
                  **.PAGE** must come after **.START**.  Otherwise, it should go at
                  the top of a document, prior to any text.  And remember,
                  when you're using the document processing macros, top
                  margin and bottom margin mean something slightly different
                  than when you're using just the typesetting macros (see Top
                  and bottom margins in document processing).
    
                  **.PAGE** lets you establish paper dimensions and page margins
                  with a single macro.  The only required argument is page
                  width.  The rest are optional, but they must appear in
                  order and you can't skip over any.  _< lm>_, _< rm>_, _< tm>_ and
                  _< bm>_ refer to the left, right, top and bottom margins
                  respectively.
    
                  Assuming your page dimensions are 11 inches by 17 inches,
                  and that's all you want to set, enter
                         **.PAGE 11i 17i**
                  If you want to set the left margin as well, say, at 1 inch,
                  **PAGE** would look like this:
                         **.PAGE 11i 17i 1i**
    
                  Now suppose you also want to set the top margin, say, at
                  1–1/2 inches.  _< tm>_ comes after _< rm>_ in the optional
                  arguments, but you can't skip over any arguments, therefore
                  to set the top margin, you must also give a right margin.
                  The **.PAGE** macro would look like this:
                         .PAGE 11i 17i 1i 1i 1.5i
                                          |   |
                         required right---+   +---top margin
                                 margin
    
                  Clearly, **.PAGE** is best used when you want a convenient way
                  to tell _mom_ just the dimensions of your printer sheet
                  (width and length), or when you want to tell her everything
                  about the page (dimensions and all the margins), for
                  example
                         **.PAGE 8.5i 11i 45p 45p 45p 45p**
                  This sets up an 8½ by 11 inch page with margins of 45
                  points (5/8-inch) all around.
    
                  Additionally, if you invoke **.PAGE** with a top margin
                  argument, any macros you invoke after **.PAGE** will almost
                  certainly move the baseline of the first line of text down
                  by one linespace.  To compensate, do
                         **.RLD 1v**
                  immediately before entering any text, or, if it's feasible,
                  make **.PAGE** the last macro you invoke prior to entering
                  text.
    
                  Please read the _Important note_ on page dimensions and
                  papersize for information on ensuring _groff_ respects your
                  **.PAGE** dimensions and margins.
    
           **.PAGELENGTH** _< length of printer sheet>_
                  tells _mom_ how long your printer sheet is.  It works just
                  like **.PAGEWIDTH**.
    
                  Therefore, to tell _mom_ your printer sheet is 11 inches
                  long, you enter
                         **.PAGELENGTH 11i**
                  Please read the important note on page dimensions and
                  papersize for information on ensuring _groff_ respects your
                  _PAGELENGTH_.
    
           **.PAGEWIDTH** _< width of printer sheet>_
    
                  The argument to **.PAGEWIDTH** is the width of your printer
                  sheet.
    
                  **.PAGEWIDTH** requires a unit of measure.  Decimal fractions
                  are allowed.  Hence, to tell _mom_ that the width of your
                  printer sheet is 8½ inches, you enter
                         .PAGEWIDTH 8.5i
    
                  Please read the Important note on page dimensions and
                  papersize for information on ensuring _groff_ respects your
                  _PAGEWIDTH_.
    
           **.PAPER** _< paper type>_
                  provides a convenient way to set the page dimensions for
                  some common printer sheet sizes.  The argument _< paper type>_
                  can be one of: **LETTER** , **LEGAL** , **STATEMENT** , **TABLOID** , **LEDGER** ,
                  **FOLIO** , **QUARTO** , **EXECUTIVE** , **10x14** , **A3** , **A4** , **A5** , **B4** , **B5**.
    
           **.PRINTSTYLE**
    
           **.PT_SIZE** _< size of type in points>_
                  Point size of type, does not require a _unit of measure_.
    
                  **.PT_SIZE**(_Point Size_) takes one argument: the _size of type_
                  in _points_.  Unlike most other macros that establish the
                  _size_ or _measure_ of something, **.PT_SIZE** does not require
                  that you supply a _unit of measure_ since it's a near
                  universal convention that _type size_ is measured in _points_.
                  Therefore, to change the _type size_ to, say, _11 points_ ,
                  enter
                         **.PT_SIZE 11**
                  _Point sizes_ may be _fractional_ (e.g., _10.25_ or _12.5_).
    
                  You can prepend a _plus_ or a _minus sign_ to the argument to
                  **.PT_SIZE** , in which case the _point size_ will be changed by _+_
                  or _-_ the original value.  For example, if the _point size_ is
                  _12_ , and you want _14_ , you can do
                         **.PT_SIZE +2**
                  then later reset it to _12_ with
                         **.PT_SIZE -2**
                  The _size of type_ can also be changed inline.
    
                  _Note:_ It is unfortunate that the **pic** preprocessor has
                  already taken the name, PS, and thus _mom_ 's macro for
                  setting _point sizes_ can't use it.  However, if you aren't
                  using **pic** , you might want to alias **.PT_SIZE** as **.PS** , since
                  there'd be no conflict.  For example
                         **.ALIAS PS PT_SIZE**
                  would allow you to set _point sizes_ with **.PS**.
    
           **.R_MARGIN** _< right margin>_
                  Right Margin
    
                  Requires a unit of measure.
    
                  IMPORTANT: **.R_MARGIN** , if used, must come after **.PAPER** ,
                  **.PAGEWIDTH** , **.L_MARGIN** , and/or **.PAGE**(if a right margin
                  isn't given to PAGE).  The reason is that **.R_MARGIN**
                  calculates line length from the overall page dimensions and
                  the left margin.
    
                  Obviously, it can't make the calculation if it doesn't know
                  the page width and the left margin.
    
                  **.R_MARGIN** establishes the amount of space you want between
                  the end of typeset lines and the right hand edge of the
                  printer sheet.  In other words, it sets the line length.
                  **.R_MARGIN** requires a unit of measure.  Decimal fractions
                  are allowed.
    
                  The line length macro (LL) can be used in place of
                  **.R_MARGIN**.  In either case, the last one invoked sets the
                  line length.  The choice of which to use is up to you.  In
                  some instances, you may find it easier to think of a
                  section of type as having a right margin.  In others,
                  giving a line length may make more sense.
    
                  For example, if you're setting a page of type you know
                  should have 6-pica margins left and right, it makes sense
                  to enter a left and right margin, like this:
                         **.L_MARGIN 6P**
                         **.R_MARGIN 6P**
    
                  That way, you don't have to worry about calculating the
                  line length.  On the other hand, if you know the line
                  length for a patch of type should be 17 picas and 3 points,
                  entering the line length with LL is much easier than
                  calculating the right margin, e.g.,
                         **.LL 17P+3p**
    
                  If you use the macros **.PAGE** , **.PAGEWIDTH** or **PAPER** without
                  invoking **.R_MARGIN** afterward, _mom_ automatically sets
                  **.R_MARGIN** to _1 inch_.  If you set a line length after these
                  macros (with **.LL**), the line length calculated by **.R_MARGIN**
                  is, of course, overridden.
    
                  Note: **.R_MARGIN** behaves in a special way when you're using
                  the document processing macros.
    
           **.ST** _< tab number>_ **L | R | C | J [ QUAD ]**
    
                  After _string tabs_ have been marked off on an input line
                  (see **\*[ST]...\*[STX]**), you need to _set_ them by giving them
                  a direction and, optionally, the **QUAD** argument.
    
                  In this respect, **.ST** is like **.TAB_SET** except that you don't
                  have to give **.ST** an indent or a line length (that's already
                  taken care of, inline, by **\*[ST]...\*[STX]**).
    
                  If you want string _tab 1_ to be **left** , enter
                         **.ST 1 L**
                  If you want it to be _left_ and _filled_ , enter
                         **.ST 1 L QUAD**
                  If you want it to be justified, enter
                         **.ST 1 J**
    
           **.TAB** _< tab number>_
                  After _tabs_ have been defined (either with **.TAB_SET** or **.ST**),
                  **.TAB** moves to whatever _tab number_ you pass it as an
                  argument.
    
                  For example,
                         **.TAB 3**
                  moves you to _tab 3_.
    
                  Note: **.TAB** breaks the line preceding it and advances 1
                  linespace.  Hence,
                         **.TAB 1**
                         **A line of text in tab 1.**
                         **.TAB 2**
                         **A line of text in tab 2.**
                  produces, on output
                         **A line of text in tab 1.**
                                                      **A line of text in tab 2.**
    
                  If you want the tabs to line up, use **.TN**(“Tab Next”) or,
                  more conveniently, the inline escape sequence **\*[TB+]** :
                         **.TAB** 1
                         A line of text in tab 1.\*[TB+]
                         A line of text in tab 2.
                  which produces
                         **A line of text in tab 1.   A line of text in tab 2.**
    
                  If the text in your tabs runs to several lines, and you
                  want the first lines of each tab to align, you must use the
                  multi-column macros.
    
                  _Additional note:_ Any indents in effect prior to calling a
                  tab are automatically turned off by **TAB**.  If you were
                  happily zipping down the page with a left indent of _2 picas_
                  turned on, and you call a _tab_ whose indent from the left
                  margin is _6 picas_ , your new distance from the _left margin_
                  will be _6 picas_ , not I 6 picas plus the 2 pica indent.
    
                  _Tabs_ are not by nature columnar, which is to say that if
                  the text inside a _tab_ runs to several lines, calling
                  another _tab_ does not automatically move to the baseline of
                  the first line in the _previous tab_.  To demonstrate:
                         TAB 1
                         Carrots
                         Potatoes
                         Broccoli
                         .TAB 2
                         $1.99/5 lbs
                         $0.25/lb
                         $0.99/bunch
                  produces, on output
                         Carrots
                         Potatoes
                         Broccoli
                                     $1.99/5 lbs
                                     $0.25/lb
                                     $0.99/bunch
    
           **.TB** _< tab number>_
                  Alias to **.TAB**
    
           **.TI [**_< measure>_ **]**
                  Temporary left indent — the optional argument requires a
                  _unit of measure_
    
                  A temporary indent is one that applies only to the first
                  line of text that comes after it.  Its chief use is
                  indenting the first line of paragraphs.  (**Mom's .PP** macro,
                  for example, uses a _temporary indent_.)
    
                  The first time you invoke **.TI** , you must give it a measure.
                  If you want to _indent_ the first line of a paragraph by,
                  say, 2 ems, do
                         **.TI 2m**
    
                  Subsequent invocations of **.TI** do not require you to supply
                  a measure; _mom_ keeps track of the last measure you gave it.
    
                  Because _temporary indents_ are temporary, there's no need to
                  turn them off.
    
                  _IMPORTANT:_ Unlike **.IL** , **.IR** and **IB** , measures given to **.TI**
                  are NOT additive.  In the following example, the second
                  **".TI 2P"** is exactly _2 picas_.
                         **.TI 1P**
                         **The beginning of a paragraph...**
                         **.TI 2P**
                         **The beginning of another paragraph...**
    
           **.TN** Tab Next
    
                  Inline escape **\*[TB+]**
    
                  **TN** moves over to the _next tab_ in numeric sequence (_tab n+1_)
                  without advancing on the page.  See the _NOTE_ in the
                  description of the **.TAB** macro for an example of how **TN**
                  works.
    
                  In _tabs_ that aren't given the **QUAD** argument when they're
                  set up with **.TAB_SET** or **ST** , you must terminate the line
                  preceding **.TN** with the **\c** inline escape sequence.
                  Conversely, if you did give a **QUAD** argument to **.TAB_SET** or
                  **ST** , the **\c must not be used.**
    
                  If you find remembering whether to put in the **\c**
                  bothersome, you may prefer to use the inline escape
                  alternative to **.TN** , **\*[TB+]** , which works consistently
                  regardless of the fill mode.
    
                  _Note:_ You must put text in the input line immediately after
                  **.TN**.  Stacking of **.TN** 's is not allowed.  In other words,
                  you cannot do
                         .TAB 1
                         Some text\c
                         .TN
                         Some more text\c
                         .TN
                         .TN
                         Yet more text
                  The above example, assuming _tabs_ numbered from _1_ to _4_ ,
                  should be entered
                         .TAB 1
                         Some text\c
                         .TN
                         Some more text\c
                         .TN
                         \&\c
                         .TN
                         Yet more text
                  \& is a zero-width, non-printing character that _groff_
                  recognizes as valid input, hence meets the requirement for
                  input text following **.TN**.
    
           **.TQ    TQ** takes you out of whatever _tab_ you were in, advances _1_
                  _linespace_ , and restores the _left margin_ , _line length_ , _quad_
                  _direction_ and _fill mode_ that were in effect prior to
                  invoking any _tabs_.
    
           **.T_MARGIN** _< top margin>_
                  Top margin
    
                  Requires a unit of measure
    
                  **.T_MARGIN** establishes the distance from the top of the
                  printer sheet at which you want your type to start.  It
                  requires a unit of measure, and decimal fractions are
                  allowed.  To set a top margin of 2½ centimetres, you'd
                  enter
                         **.T_MARGIN 2.5c**
                  **.T_MARGIN** calculates the vertical position of the first
                  line of type on a page by treating the top edge of the
                  printer sheet as a baseline.  Therefore,
                         **.T_MARGIN 1.5i**
                  puts the baseline of the first line of type 1½ inches
                  beneath the top of the page.
    
                  Note: **.T_MARGIN** means something slightly different when
                  you're using the document processing macros.  See Top and
                  bottom margins in document processing for an explanation.
    
                  IMPORTANT: **.T_MARGIN** does two things: it establishes the
                  top margin for pages that come after it and it moves to
                  that position on the current page.  Therefore, **.T_MARGIN**
                  should only be used at the top of a file (prior to entering
                  text) or after NEWPAGE, like this:
                         **.NEWPAGE**
                         **.T_MARGIN 6P**
                         _< text>_
    


## Authors



           Peter Schaffter ⟨peter@schaffter.ca⟩ wrote _mom_.  Deri James ⟨deri@
           chuzzlewit.myzen.co.uk⟩ added PDF support.  Bernd Warken
           ⟨groff-bernd.warken-72@web.de⟩ contributed this man page.
    


## See also



           _/usr/local/share/doc/groff-1.23.0/html/mom/toc.html_
                  _mom_ manual (installed version)
    
           _mom_    manual ⟨http://www.schaffter.ca/mom/momdoc/toc.html⟩
                  (latest version)
    
           _mom_    homepage ⟨http://www.schaffter.ca/mom/⟩
    
           _Groff: The GNU Implementation of troff_ , by Trent A. Fisher and
           Werner Lemberg, is the primary _groff_ manual.  You can browse it
           interactively with “info groff”.
    
           _pdfmom_(1), _groff_(1), _troff_(1)
    


* * *