|
Name | Synopsis | Description | Options | Details | Exit status | Examples | Authors | See also | COLOPHON |
|
|
|
grog(1) General Commands Manual grog(1)
grog - “groff guess”—infer the groff command a document requires
grog [--run] [--ligatures] [groff-option ...] [--] [file ...]
grog -h
grog --help
grog -v
grog --version
grog reads its input and guesses which options are needed to
render it. If no operands are given, or if file is “-”, grog
reads the standard input stream. The corresponding groff command
is normally written to the standard output stream. With the
option --run, the inferred command is written to the standard
error stream and then executed.
-h and --help display a usage message, whereas -v and --version
display version information; all exit afterward.
--ligatures
includes the arguments -P-y -PU in the inferred groff
command. These are supported only by the pdf output
device.
--run writes the inferred command to the standard error stream
and then executes it.
All other specified short options (that is, arguments beginning
with a minus sign “-” followed by a letter) are interpreted as
groff options or option clusters with or without an option
argument. Such options are included in the constructed groff
command line.
grog reads each file operand, pattern-matching strings that are
statistically likely to be characteristic of documents. It tries
to guess which of the following groff options are required to
correctly render the input: -e, -g, -G, -j, -p, -R, -t
(preprocessors); and -man, -mdoc, -mdoc-old, -me, -mm, -mom, and
-ms (macro packages). The inferred groff command including these
options and any file parameters is written to the standard output
stream.
It is possible to specify arbitrary groff options on the command
line. These are included in the inferred command without change.
Choices of groff options include -C to enable AT&T troff
compatibility mode and -T to select a non-default output device.
If the input is not encoded in US-ASCII, ISO 8859-1, or IBM code
page 1047, specification of a groff option to run the
preprocessor is advised; see the -D, -k, and -K options of For
UTF-8 input, -k is a good choice.
groff may issue diagnostic messages when an inappropriate -m
option, or multiple conflicting ones, are specified.
Consequently, it is best to specify no -m options to grog unless
it cannot correctly infer all of the -m arguments a document
requires. A roff document can also be written without recourse
to any macro package. In such cases, grog will infer a groff
command without an -m option.
Limitations
grog presumes that the input does not change the escape, control,
or no-break control characters. grog does not parse roff input
line continuation or control structures (brace escape sequences
and the “if”, “ie”, and “el” requests) nor groff's “while”. Thus
the input
.if \
t .NH 1
.if n .SH
Introduction
will conceal the use of the ms macros NH and SH from grog. Such
constructions are regarded by grog's implementors as
insufficiently common to cause many inference problems.
Preprocessors can be even stricter when matching macro calls that
bracket the regions of an input file they replace. pic, for
example, requires PS, PE, and PF calls to immediately follow the
default control character at the beginning of a line.
Detection of the -s option (the preprocessor) is tricky; to
correctly infer its necessity would require grog to recursively
open all files given as arguments to the .so request under the
same conditions that soelim itself does so; see its man page.
Recall that soelim is only necessary if sourced files need to be
preprocessed. Therefore, as a workaround, you may want to run
the input through soelim manually, piping it to grog, and compare
the output to running grog on the input directly. If the
“soelim”ed input causes grog to infer additional preprocessor
options, then -s is likely necessary.
$ printf ".TS\nl.\nI'm a table.\n.TE\n" > 3.roff
$ printf ".so 3.roff\n" > 2.roff
$ printf ".XP\n.so 2.roff\n" > 1.roff
$ grog 1.roff
groff -ms 1.roff
$ soelim 1.roff | grog
groff -t -ms -
In the foregoing example, we see that this procedure enabled grog
to detect macros, so we would add -s as well as the detected -t
option to a revised grog or groff command.
$ grog -st 1.roff
groff -st -ms 1.roff
grog exits with error status 1 if a macro package appears to be
in use by the input document, but grog was unable to infer which
one, or 2 if there were problems handling an option or operand.
It otherwise exits with status 0. (If the --run option is
specified, groff's exit status is discarded.) Inferring no
preprocessors or macro packages is not an error condition; a
valid roff document need not use either. Even plain text is
valid input, if one is mindful of the syntax of the control and
escape characters.
Running
grog /usr/local/share/doc/groff-1.23.0/meintro.me
at the command line results in
groff -me /usr/local/share/doc/groff-1.23.0/meintro.me
because grog recognizes that the file meintro.me is written using
macros from the me package. The command
grog /usr/local/share/doc/groff-1.23.0/pic.ms
outputs
groff -e -p -t -ms /usr/local/share/doc/groff-1.23.0/pic.ms
on the other hand. Besides discerning the ms macro package, grog
recognizes that the file pic.ms additionally needs the
combination of -t for tbl, -e for eqn, and -p for pic.
Consider a file doc/grnexampl.me, which uses the grn preprocessor
to include a picture file in an me document. Let's say we want
to suppress color output, produce a DVI file, and get backtraces
for any errors that troff encounters. The command
grog -bc -Idoc -Tdvi doc/grnexmpl.me
is processed by grog into
groff -bc -Idoc -Tdvi -e -g -me doc/grnexmpl.me
where we can see that grog has inferred the me macro package
along with the eqn and grn preprocessors. (The input file is
located in /usr/local/share/doc/groff-1.23.0 if you'd like to try
this example yourself.)
grog was originally written in Bourne shell by James Clark. The
current implementation in Perl was written by Bernd Warken
⟨groff-bernd.warken-72@web.de⟩ and heavily revised by G. Branden
Robinson ⟨g.branden.robinson@gmail.com⟩.
This page is part of the groff (GNU troff) project. Information
about the project can be found at
⟨http://www.gnu.org/software/groff/⟩. If you have a bug report
for this manual page, see ⟨http://www.gnu.org/software/groff/⟩.
This page was obtained from the project's upstream Git repository
⟨https://git.savannah.gnu.org/git/groff.git⟩ on 2022-12-17. (At
that time, the date of the most recent commit that was found in
the repository was 2022-12-14.) If you discover any rendering
problems in this HTML version of the page, or you believe there
is a better or more up-to-date source for the page, or you have
corrections or improvements to the information in this COLOPHON
(which is not part of the original manual page), send a mail to
man-pages@man7.org
groff 1.23.0.rc1.3569-94746-d1i4rtDyecember 2022 grog(1)
|
HTML rendering created 2022-12-18 by Michael Kerrisk, author of The Linux Programming Interface, maintainer of the Linux man-pages project. For details of in-depth Linux/UNIX system programming training courses that I teach, look here. Hosting by jambit GmbH. |
|