{
    "mode": "man",
    "parameter": "GROFF",
    "section": "7",
    "url": "https://www.chedong.com/phpMan.php/man/GROFF/7/json",
    "generated": "2026-10-22T13:18:25Z",
    "sections": {
        "Name": {
            "content": "groff - GNU roff language reference\n",
            "subsections": []
        },
        "Description": {
            "content": "groff  is  short  for  GNU roff, a free reimplementation of the AT&T device-independent troff\ntypesetting system.  See roff(7) for a survey of and background on roff systems.\n\nThis document is intended as a reference.  The primary groff manual, Groff: The GNU Implemen‐\ntation of troff, by Trent A. Fisher and Werner Lemberg, is a better  resource  for  learners,\ncontaining  many  examples  and much discussion.  It is written in Texinfo; you can browse it\ninteractively with “info groff”.  Additional formats, including plain text,  HTML,  DVI,  and\nPDF, may be available in /usr/share/doc/groff-base.\n\ngroff  is  also a name for an extended dialect of the roff language.  We use “roff” to denote\nfeatures that are universal, or nearly so, among implementations of this  family.   We  apply\nthe  term “groff” to the language documented here, the GNU implementation of the overall sys‐\ntem, the project that develops that system, and the command of that name.\n\nGNU troff, installed on this system as troff(1), is the formatter: a program that  reads  de‐\nvice  and  font descriptions (grofffont(5)), interprets the groff language expressed in text\ninput files, and translates that input into a device-independent output format (groffout(5))\nthat is usually then post-processed by an output driver to  produce  PostScript,  PDF,  HTML,\nDVI, or terminal output.\n",
            "subsections": []
        },
        "Input format": {
            "content": "Input  to GNU troff is organized into lines separated by the Unix newline character (U+000A),\nand must be in one of two character encodings it can recognize: IBM code page 1047 on  EBCDIC\nsystems, and ISO Latin-1 (8859-1) otherwise.  Use of ISO 646-1991:IRV (“US-ASCII”) or (equiv‐\nalently) the “Basic Latin” subset of ISO 10646 (“Unicode”) is recommended; see groffchar(7).\nThe  preconv(1)  preprocessor transforms other encodings, including UTF-8, to satisfy troff's\nrequirements.\n",
            "subsections": []
        },
        "Syntax characters": {
            "content": "Several input characters are syntactically significant to groff.\n\n.   A dot at the beginning of an input line marks it as a control line.  It can  also  follow\nthe  .el and .nop requests, and the condition in .if, .ie, and .while requests.  The con‐\ntrol character invokes requests and calls macros by the name that follows  it.   The  .cc\nrequest can change the control character.\n\n'   The  neutral  apostrophe  is the no-break control character, recognized where the control\ncharacter is.  It suppresses the (first) break implied by the .bp, .cf,  .fi,  .fl,  .in,\n.nf,  .rj, .sp, .ti, and .trf requests.  The requested operation takes effect at the next\nbreak.  It makes .br nilpotent.  The no-break control character can be changed  with  the\n.c2  request.   When formatted, “'” may be typeset as a typographical quotation mark; use\nthe \\[aq] special character escape sequence to format a neutral apostrophe glyph.\n\n\"   The neutral double quote can be used to enclose arguments to macros and strings,  and  is\nrequired  if those arguments contain space or tab characters.  In the .ds, .ds1, .as, and\n.as1 requests, an initial neutral double quote in the second argument is stripped off  to\nallow  embedding  of leading spaces.  To include a double quote inside a quoted argument,\nuse the \\[dq] special character escape sequence (which also serves to typeset  the  glyph\nin text).\n\n\\   A  backslash introduces an escape sequence.  The escape character can be changed with the\n.ec request; .eo disables escape sequence recognition.  Use the \\[rs]  special  character\nescape  sequence  to format a backslash glyph, and \\e to typeset the glyph of the current\nescape character.\n\n(   An opening parenthesis is special only in certain escape sequences; when  recognized,  it\nintroduces  an argument of exactly two characters.  groff offers the more flexible square\nbracket syntax.\n\n[   An opening bracket is special only in certain escape sequences; when recognized,  it  in‐\ntroduces an argument (list) of any length, not including a closing bracket.\n\n]   A  closing bracket is special only when an escape sequence using an opening bracket as an\nargument delimiter is being interpreted.  It ends the argument (list).\n\nAdditionally, the Control+A character (U+0001) in text is interpreted as a  leader  (see  be‐\nlow).\n\nHorizontal white space characters are significant to groff, but trailing spaces on text lines\nare ignored.\n\nspace   Space  characters  separate arguments in request invocations, macro calls, and string\ninterpolations.  In text, they separate words.  Multiple adjacent space characters in\ntext cause groff to attempt end-of-sentence detection  on  the  preceding  word  (and\ntrailing punctuation).  The amount of space between words and sentences is controlled\nby the .ss request.  When filling is enabled (the default), a line may be broken at a\nspace.   When adjustment is enabled (the default), inter-word spaces are expanded un‐\ntil the output line reaches the configured length.  An  adjustable  but  non-breaking\nspace is available with \\~.  To get a space of fixed width, use one of the escape se‐\nquences  ‘\\ ’ (the escape character followed by a space), \\0, \\|, \\^, or \\h; see sec‐\ntion “Escape sequences” below.\n\nnewline In text, a newline puts an inter-word space onto the output and, if  filling  is  en‐\nabled, triggers end-of-sentence recognition on the preceding text.  See section “Line\ncontinuation” below.\n\ntab     A  tab  character  in text causes the drawing position to advance to the next defined\ntab stop.\n",
            "subsections": []
        },
        "Tabs and leaders": {
            "content": "The formatter interprets input horizontal tab characters (“tabs”)  and  Control+A  characters\n(“leaders”)  into  movements  to  the  next tab stop.  Tabs simply move to the next tab stop;\nleaders place enough periods to fill the space.  Tab stops are by default located every  half\ninch measured from the drawing position corresponding to the beginning of the input line; see\nsection  “Page  geometry”  of roff(7).  Tabs and leaders do not cause breaks and therefore do\nnot interrupt filling.  Tab stops can be configured with the ta request, and tab  and  leader\nglyphs with the tc and lc requests, respectively.\n",
            "subsections": []
        },
        "Line continuation": {
            "content": "When  filling is enabled, input and output line breaks generally do not correspond.  The roff\nlanguage therefore distinguishes input and output line continuation.\n\nA backslash \\ immediately followed by a newline, sometimes discussed as \\newline,  suppresses\nthe  effects  of that newline on the input.  The next input line thus retains the classifica‐\ntion of its predecessor as a control or text line.  \\newline  is  useful  for  managing  line\nlengths  in  the input during document maintenance; you can break an input line in the middle\nof a request invocation, macro call, or escape sequence.  Input line continuation is  invisi‐\nble  to the formatter, with two exceptions: the | operator recognizes the new input line, and\nthe input line counter register .c is incremented.\n\nThe \\c escape sequence continues an output line.  Nothing on the input line after it is  for‐\nmatted.   In  contrast to \\newline, a line after \\c is treated as a new input line, so a con‐\ntrol character is recognized at its beginning.  The visual results depend on whether  filling\nis  enabled.   An intervening control line that causes a break overrides \\c, flushing out the\npending output line in the usual way.  The register .int contains a  positive  value  if  the\nlast output line was continued with \\c; this datum is associated with the environment.\n",
            "subsections": []
        },
        "Colors": {
            "content": "groff  supports  color  output  with a variety of color spaces and up to 16 bits per channel.\nSome devices, particularly terminals, may be more limited.  When color  support  is  enabled,\ntwo colors are current at any given time: the stroke color, with which glyphs, rules (lines),\nand  geometric  objects like circles and polygons are drawn, and the fill color, which can be\nused to paint the interior of a closed geometric figure.  The color,  defcolor,  gcolor,  and\nfcolor  requests; \\m and \\M escape sequences; and .color, .m, and .M registers exercise color\nsupport.\n\nEach output device has a color named “default”, which cannot be redefined.   A  device's  de‐\nfault  stroke  and fill colors are not necessarily the same.  For the dvi, html, pdf, ps, and\nxhtml output devices, troff automatically loads a macro file defining  many  color  names  at\nstartup.  By the same mechanism, the devices supported by grotty(1) recognize the eight stan‐\ndard ISO 6429/ECMA-48 color names (also known vulgarly as “ANSI colors”).\n",
            "subsections": []
        },
        "Measurements": {
            "content": "Numeric  parameters  that specify measurements are expressed as integers or decimal fractions\nwith an optional scaling unit suffixed.  A scaling unit is a letter that immediately  follows\nthe last digit of a number.  Digits after the decimal point are optional.\n\nMeasurements  are  scaled by the scaling unit and stored internally (with any fractional part\ndiscarded) in basic units.  The device resolution can therefore  be  obtained  by  storing  a\nvalue of “1i” to a register.  The only constraint on the basic unit is that it is at least as\nsmall as any other unit.\n\nu      Basic unit.\ni      Inch; defined as 2.54 centimeters.\nc      Centimeter.\np      Point;  a  typesetter's  unit used for measuring type size.  There are 72 points to an\ninch.\nP      Pica; another typesetter's unit.  There are 6 picas to an inch  and  12  points  to  a\npica.\ns, z   Scaled  points  and multiplication by the output device's sizescale parameter, respec‐\ntively.\nf      Multiplication by 65,536; scales decimal fractions in the interval [0,  1]  to  16-bit\nunsigned integers.\n\nThe magnitudes of other scaling units depend on the text formatting parameters in effect.\n\nm      Em; an em is equal to the current type size in points.\nn      En; an en is one-half em.\nv      Vee; distance between text baselines.\nM      Hundredth of an em.\n",
            "subsections": [
                {
                    "name": "Motion quanta",
                    "content": "An  output device's basic unit u is not necessarily its smallest addressable length; u can be\nsmaller to avoid problems with integer roundoff.  The minimum distances  that  a  device  can\nwork  with  in the horizontal and vertical directions are termed its motion quanta, stored in\nthe .H and .V registers, respectively.  Measurements are rounded to applicable motion quanta.\nHalf-quantum fractions round toward zero.\n"
                },
                {
                    "name": "Default units",
                    "content": "A general-purpose register (one created or updated with the nr request; see  section  “Regis‐\nters” below) is implicitly dimensionless, or reckoned in basic units if interpreted in a mea‐\nsurement  context.   But  it  is convenient for many requests and escape sequences to infer a\nscaling unit for an argument if none is specified.  An explicit scaling  unit  (not  after  a\nclosing  parenthesis)  can override an undesirable default.  Effectively, the default unit is\nsuffixed to the expression if a scaling unit is not already present.  GNU troff's use of  in‐\nteger arithmetic should also be kept in mind; see below.\n"
                }
            ]
        },
        "Numeric expressions": {
            "content": "A numeric expression evaluates to an integer.  The following operators are recognized.\n\n+   addition\n-   subtraction\n*   multiplication\n/   truncating division\n%   modulus\n────────────────────────────────────────────\nunary +   assertion, motion, incrementation\nunary -   negation, motion, decrementation\n────────────────────────────────────────────\n;   scaling\n>?   maximum\n<?   minimum\n────────────────────────────────────────────\n<   less than\n>   greater than\n<=   less than or equal\n>=   greater than or equal\n=   equal\n==   equal\n────────────────────────────────────────────\n&   logical conjunction (“and”)\n:   logical disjunction (“or”)\n!   logical complementation (“not”)\n────────────────────────────────────────────\n( )   precedence\n────────────────────────────────────────────\n|   boundary-relative motion\n\ntroff provides a set of mathematical and logical operators familiar to programmers—as well as\nsome  unusual ones—but supports only integer arithmetic.  (Provision is made for interpreting\nand reporting decimal fractions in certain cases.)  The internal data type used for computing\nresults is usually a 32-bit signed integer, which suffices to represent magnitudes  within  a\nrange of ±2 billion.  (If that's not enough, see grofftmac(5) for the 62bit.tmac macro pack‐\nage.)\n\nArithmetic  infix  operators  perform a function on the numeric expressions to their left and\nright; they are + (addition), - (subtraction), * (multiplication), /  (truncating  division),\nand  %  (modulus).   Truncating  division rounds to the integer nearer to zero, no matter how\nlarge the fractional portion.  Overflow and division (or modulus)  by  zero  are  errors  and\nabort evaluation of a numeric expression.\n\nArithmetic  unary  operators  operate  on  the  numeric expression to their right; they are -\n(negation) and + (assertion—for completeness; it does nothing).  The unary minus  must  often\nbe  used  with parentheses to avoid confusion with the decrementation operator, discussed be‐\nlow.\n\nThe sign of the modulus of operands of mixed signs is determined by the sign  of  the  first.\nDivision and modulus operators satisfy the following property: given a dividend a and a divi‐\nsor b, a quotient q formed by “(a / b)” and a remainder r by “(a % b)”, then qb + r = a.\n\nGNU  troff's  scaling  operator,  used with parentheses as (c;e), evaluates a numeric expres‐\nsion e using c as the default scaling unit.  If c is omitted, scaling units  are  ignored  in\nthe  evaluation  of e.  GNU troff also provides a pair of operators to compute the extrema of\ntwo operands: >? (maximum) and <? (minimum).\n\nComparison operators comprise < (less than), > (greater than), <= (less than  or  equal),  >=\n(greater than or equal), and = (equal).  == is a synonym for =.  When evaluated, a comparison\nis  replaced  with “0” if it is false and “1” if true.  In the roff language, positive values\nare true, others false.\n\nWe can operate on truth values with the logical operators & (logical  conjunction  or  “and”)\nand  :  (logical  disjunction or “or”).  They evaluate as comparison operators do.  A logical\ncomplementation (“not”) operator, !, works only within  “if”,  “ie”,  and  “while”  requests.\nFurthermore,  !  is recognized only at the beginning of a numeric expression not contained by\nanother numeric expression.  In other words, it must be the “outermost” operator.   Including\nit  elsewhere  in  the expression produces a warning in the “number” category (see troff(1)),\nand its expression evaluates false.  This unfortunate limitation maintains compatibility with\nAT&T troff.  Test a numeric expression for falsity by comparing it to a false value.\n\nThe roff language has no operator precedence: expressions are evaluated strictly from left to\nright, in contrast to schoolhouse arithmetic.  Use parentheses ( ) to impose a desired prece‐\ndence upon subexpressions.\n\nFor many requests and escape sequences that cause motion on the page, the unary  operators  +\nand  - work differently when leading a numeric expression.  They then indicate a motion rela‐\ntive to the drawing position: positive is down in  vertical  contexts,  right  in  horizontal\nones.\n\n+  and - are also treated differently by the following requests and escape sequences: bp, in,\nll, pl, pn, po, ps, pvs, rt, ti, \\H, \\R, and \\s.  Here, leading plus and minus signs serve as\nincrementation and decrementation operators, respectively.  To negate an expression, subtract\nit from zero or include the unary minus in parentheses with its argument.\n\nA leading | operator indicates a motion relative not to the drawing position but to a  bound‐\nary.   For horizontal motions, the measurement specifies a distance relative to a drawing po‐\nsition corresponding to the beginning of the input line.  By default, tab stops reckon  move‐\nments  in  this  way.  Most escape sequences do not; | tells them to do so.  For vertical mo‐\ntions, the | operator specifies a distance from the first text baseline on the page or in the\ncurrent diversion, using the current vertical spacing.\n\nThe \\B escape sequence tests its argument for validity as a numeric expression.\n\nA register interpolated as an operand in a numeric expression must  have  an  Arabic  format;\nluckily, this is the default.\n\nDue to the way arguments are parsed, spaces are not allowed in numeric expressions unless the\n(sub)expression containing them is surrounded by parentheses.\n",
            "subsections": []
        },
        "Identifiers": {
            "content": "An  identifier  labels  a  GNU troff datum such as a register, name (macro, string, or diver‐\nsion), typeface, color, special character, character class, environment,  or  stream.   Valid\nidentifiers  consist  of  one or more ordinary characters.  An ordinary character is an input\ncharacter that is not the escape character, a leader, tab, newline, or invalid as  GNU  troff\ninput.\n\nInvalid  input  characters  are subset of control characters (from the sets “C0 Controls” and\n“C1 Controls” as Unicode describes them).  When troff encounters one  in  an  identifier,  it\nproduces  a  warning  in category “input” (see section “Warnings” in troff(1)).  They are re‐\nmoved during interpretation: an identifier “foo”, followed by an invalid character  and  then\n“bar”, is processed as “foobar”.\n\nOn  a machine using the ISO 646, 8859, or 10646 character encodings, invalid input characters\nare 0x00, 0x08, 0x0B, 0x0D–0x1F, and 0x80–0x9F.  On an EBCDIC host, they are 0x00–0x01, 0x08,\n0x09, 0x0B, 0x0D–0x14, 0x17–0x1F, and 0x30–0x3F.  Some of these code points are used by troff\ninternally, making it non-trivial to extend the program to accept UTF-8  or  other  encodings\nthat use characters from these ranges.\n\nAn  identifier  with  a closing bracket (“]”) in its name can't be accessed with bracket-form\nescape sequences that expect an identifier as a parameter.   Similarly,  the  identifier  “(”\ncan't be interpolated except with bracket forms.\n\nIf you begin a macro, string, or diversion name with either of the characters “[” or “]”, you\nforeclose  use  of the refer(1) preprocessor, which recognizes “.[” and “.]” as bibliographic\nreference delimiters.\n\nThe escape sequence \\A tests its argument for validity as an identifier.\n\nHow GNU troff handles the interpretation of an undefined identifier depends on  the  context.\nThere  is  no  way to invoke an undefined request; such syntax is interpreted as a macro call\ninstead.  If the identifier is interpreted as a string, macro, or diversion,  troff  emits  a\nwarning  in category “mac”, defines it as empty, and interpolates nothing.  If the identifier\nis interpreted as a register, troff emits a warning in  category  “reg”,  initializes  it  to\nzero,  and  interpolates that value.  See section “Warnings” in troff(1), and subsection “In‐\nterpolating registers” and section “Strings” below.  Attempting to use an undefined typeface,\nstyle, special character, color, character class, environment, or stream  generally  provokes\nan error diagnostic.\n\nIdentifiers for requests, macros, strings, and diversions share one name space; special char‐\nacters and character classes another.  No other object types do.\n",
            "subsections": []
        },
        "Control characters": {
            "content": "Control characters are recognized only at the beginning of an input line, or at the beginning\nof the branch of a control structure request; see section “Control structures” below.\n\nA  few  requests  cause a break implicitly; use the no-break control character to prevent the\nbreak.  Break suppression is its sole behavioral distinction.  Employing the no-break control\ncharacter to invoke requests that don't cause breaks is harmless but poor style.\n\nThe control character “.” and the no-break control character “'” can be changed with  the  cc\nand c2 requests, respectively.  Within a macro definition, register .br indicates the control\ncharacter used to call it.\n",
            "subsections": []
        },
        "Invoking requests": {
            "content": "A  control character is optionally followed by tabs and/or spaces and then an identifier nam‐\ning a request or macro.  The invocation of an unrecognized request is interpreted as a  macro\ncall.  Defining a macro with the same name as a request replaces the request.  Deleting a re‐\nquest  name  with  the  rm request makes it unavailable.  The als request can alias requests,\npermitting them to be wrapped or non-destructively replaced.  See section “Strings” below.\n\nThere is no inherent limit on argument length or quantity.  Most requests take  one  or  more\narguments,  and ignore any they do not expect.  A request may be separated from its arguments\nby tabs or spaces, but only spaces can separate an argument from its successor.  Only one be‐\ntween arguments is necessary; any excess is ignored.  GNU troff does not allow tabs for argu‐\nment separation.\n\nGenerally, a space within a request argument is not relevant, not meaningful, or is supported\nby bespoke provisions, as with the tl request's delimiters.  Some requests, like  ds,  inter‐\npret the remainder of the control line as a single argument.  See section “Strings” below.\n\nSpaces  and tabs immediately after a control character are ignored.  Commonly, authors struc‐\nture the source of documents or macro files with them.\n",
            "subsections": []
        },
        "Calling macros": {
            "content": "If a macro of the desired name does not exist when called, it is created, assigned  an  empty\ndefinition,  and a warning in category “mac” is emitted.  Calling an undefined macro does end\na macro definition naming it as its end macro (see section “Writing macros” below).\n\nTo embed spaces within a macro argument, enclose the argument in neutral double  quotes  ‘\"’.\nHorizontal  motion escape sequences are sometimes a better choice for arguments to be format‐\nted as text.\n\nThe foregoing raises the question of how to embed neutral double  quotes  or  backslashes  in\nmacro  arguments  when  those  characters are desired as literals.  In GNU troff, the special\ncharacter escape sequence \\[rs] produces a backslash and \\[dq] a neutral double quote.\n\nIn GNU troff's AT&T compatibility mode, these characters remain available as \\(rs  and  \\(dq,\nrespectively.   AT&T  troff did not consistently define these special characters, but its de‐\nscendants can be made to support them.  See grofffont(5).  If even that is not feasible, see\nthe “Calling Macros” section of the groff Texinfo manual for the complex macro argument quot‐\ning rules of AT&T troff.\n",
            "subsections": []
        },
        "Using escape sequences": {
            "content": "Whereas requests must occur on control lines, escape sequences can occur intermixed with text\nand may appear in arguments to requests, macros, and other escape sequences.  An  escape  se‐\nquence  is introduced by the escape character, a backslash \\.  The next character selects the\nescape's function.\n\nEscape sequences vary in length.  Some take an argument, and of those,  some  have  different\nsyntactical  forms  for a one-character, two-character, or arbitrary-length argument.  Others\naccept only an arbitrary-length argument.  In the former  scheme,  a  one-character  argument\nfollows the function character immediately, an opening parenthesis “(” introduces a two-char‐\nacter  argument  (no closing parenthesis is used), and an argument of arbitrary length is en‐\nclosed in brackets “[]”.  In the latter scheme, the user selects a  delimiter  character.   A\nfew  escape  sequences are idiosyncratic, and support both of the foregoing conventions (\\s),\ndesignate their own termination sequence (\\?), consume input until the next newline (\\!,  \\\",\n\\#), or support an additional modifier character (\\s again, and \\n).\n\nIf an escape character is followed by a character that does not identify a defined operation,\nthe  escape  character  is  ignored (producing a diagnostic of the “escape” warning category,\nwhich is not enabled by default) and the following character is processed normally.\n\nEscape sequence interpolation is of higher precedence than escape sequence argument interpre‐\ntation.  This rule affords flexibility in using escape sequences to construct  parameters  to\nother escape sequences.\n\nThe  escape  character  can be interpolated (\\e).  Requests permit the escape mechanism to be\ndeactivated (eo) and restored, or the escape character changed (ec), and to save and  restore\nit (ecs and ecr).\n",
            "subsections": []
        },
        "Delimiters": {
            "content": "Some  escape sequences that require parameters use delimiters.  The neutral apostrophe ' is a\npopular choice and shown in this document.  The neutral double quote \" is also commonly seen.\nLetters, numerals, and leaders  can  be  used.   Punctuation  characters  are  likely  better\nchoices, except for those defined as infix operators in numeric expressions; see below.\n\nThe  following  escape  sequences  don't  take  arguments and thus are allowed as delimiters:\n\\space, \\%, \\|, \\^, \\{, \\}, \\', \\`, \\-, \\, \\!, \\?, \\), \\/, \\,, \\&, \\:, \\~, \\0, \\a,  \\c,  \\d,\n\\e,  \\E,  \\p, \\r, \\t, and \\u.  However, using them this way is discouraged; they can make the\ninput confusing to read.\n\nA few escape sequences, \\A, \\b, \\o, \\w, \\X, and \\Z, accept a newline as  a  delimiter.   New‐\nlines  that  serve as delimiters continue to be recognized as input line terminators.  Use of\nnewlines as delimiters in escape sequences is also discouraged.\n\nFinally, the escape sequences \\D, \\h, \\H, \\l, \\L, \\N, \\R, \\s, \\S, \\v, and  \\x  prohibit  many\ndelimiters.\n\n• the numerals 0–9 and the decimal point “.”\n\n• the (single-character) operators +-/*%<>=&:()\n\n• any  escape sequences other than \\%, \\:, \\{, \\}, \\', \\`, \\-, \\, \\!, \\/, \\c, \\e, and\n\\p\n\nDelimiter syntax is complex and flexible primarily for historical reasons; the foregoing  re‐\nstrictions  need  be  kept  in  mind mainly when using groff in AT&T compatibility mode.  GNU\ntroff keeps track of the nesting depth of escape sequence interpolations, so the only charac‐\nters you need to avoid using as delimiters are those that appear in the arguments you  input,\nnot  any  that result from interpolation.  Typically, ' works fine.  See section “Implementa‐\ntion differences” in groffdiff(7).\n",
            "subsections": []
        },
        "Dummy characters": {
            "content": "As discussed in roff(7), the first character on an input line is treated specially.  Further,\nformatting a glyph has many consequences on formatter state (see section  “Environments”  be‐\nlow).   Occasionally,  we  want  to escape this context or embrace some of those consequences\nwithout actually rendering a glyph to the output.  \\& interpolates a dummy  character,  which\nis constitutive of output but invisible.  Its presence alters the interpretation context of a\nsubsequent  input character, and enjoys several applications: preventing the insertion of ex‐\ntra space after an end-of-sentence character, preventing interpretation of a control  charac‐\nter  at the beginning of an input line, preventing kerning between two glyphs, and permitting\nthe tr request to remap a character to “nothing”.  \\) works as \\& does, except that  it  does\nnot cancel a pending end-of-sentence state.\n",
            "subsections": []
        },
        "Control structures": {
            "content": "groff  has “if” and “while” control structures like other languages.  However, the syntax for\ngrouping multiple input lines in the branches or bodies of these structures is unusual.\n\nThey have a common form: the request name is (except for .el “else”)  followed  by  a  condi‐\ntional  expression  cond-expr;  the  remainder of the line, anything, is interpreted as if it\nwere an input line.  Any quantity of spaces between arguments to requests serves only to sep‐\narate them; leading spaces in anything are therefore not seen.  anything  effectively  cannot\nbe omitted; if cond-expr is true and anything is empty, the newline at the end of the control\nline is interpreted as a blank line (and therefore a blank text line).\n\nIt  is  frequently  desirable  for a control structure to govern more than one request, macro\ncall, or text line, or a combination of the foregoing.  The opening and closing brace  escape\nsequences  \\{ and \\} perform such grouping.  Brace escape sequences outside of control struc‐\ntures have no meaning and produce no output.\n\n\\{ should appear (after optional spaces and tabs) immediately  subsequent  to  the  request's\nconditional  expression.  \\} should appear on a line with other occurrences of itself as nec‐\nessary to match \\{ sequences.  It can be preceded by a control character, spaces,  and  tabs.\nInput  after  any quantity of \\} sequences on the same line is processed only if all the pre‐\nceding conditions to which they correspond are true.  Furthermore, a \\} closing the body of a\n.while request must be the last such escape sequence on an input line.\n",
            "subsections": [
                {
                    "name": "Conditional expressions",
                    "content": "The .if, .ie, and .while requests test the truth values of numeric  expressions.   They  also\nsupport  several  additional Boolean operators; the members of this expanded class are termed\nconditional expressions; their truth values are as shown below.\n\ncond-expr...   ...is true if...\n──────────────────────────────────────────────────────────────────────────────────────────────\n's1's2'   s1 produces the same formatted output as s2.\nc g   a glyph g is available.\nd m   a string, macro, diversion, or request m is defined.\ne   the current page number is even.\nF f   a font named f is available.\nm c   a color named c is defined.\nn   the formatter is in nroff mode.\no   the current page number is odd.\nr n   a register named n is defined.\nS s   a font style named s is available.\nt   the formatter is in troff mode.\nv   n/a (historical artifact; always false).\n\nIf the first argument to an .if, .ie, or .while request begins with a non-alphanumeric  char‐\nacter  apart  from  ! (see below); it performs an output comparison test.  Shown first in the\ntable above, the output comparison operator interpolates a true value if formatting its  com‐\nparands  s1  and s2 produces the same output commands.  Other delimiters can be used in place\nof the neutral apostrophes.  troff formats s1 and s2 in separate environments; after the com‐\nparison, the resulting data are discarded.  The resulting glyph  properties,  including  font\nfamily,  style,  size,  and slant, must match, but not necessarily the requests and/or escape\nsequences used to obtain them.  Motions must match in orientation and magnitude to within the\napplicable horizontal or vertical motion quantum of the device, after rounding.\n\nSurround the comparands with \\? to avoid formatting them; this causes  them  to  be  compared\ncharacter  by  character,  as  with string comparisons in other programming languages.  Since\ncomparands protected with \\? are read in copy mode, they need not even be valid groff syntax.\nThe escape character is still lexically recognized, however, and consumes the next character.\n\nThe above operators can't be combined with most others, but a leading “!”, not followed imme‐\ndiately by spaces or tabs, complements an expression.  Spaces and tabs are  optional  immedi‐\nately after the “c”, “d”, “F”, “m”, “r”, and “S” operators, but right after “!”, they end the\npredicate and the conditional evaluates true.  (This bizarre behavior maintains compatibility\nwith AT&T troff.)\n"
                }
            ]
        },
        "Syntax reference conventions": {
            "content": "In  the following request and escape sequence specifications, most argument names were chosen\nto be descriptive.  A few denotations may require introduction.\n\nc         denotes a single input character.\nfont      a font either specified as a font name or a numeric mounting position.\nanything  all characters up to the end of the line, to the ending  delimiter  for  the\nescape  sequence,  or  within  \\{ and \\}.  Escape sequences may generally be\nused freely in anything, except when it is read in copy mode.\nmessage   is a character sequence to be emitted on the standard error stream.  Special\ncharacter escape sequences are not interpreted.\nn         is a numeric expression that evaluates to a non-negative integer.\nnpl       is a numeric expression constituting a count of subsequent productive  input\nlines;  that  is,  those that directly produce formatted output.  Text lines\nproduce output, as do control lines containing requests like .tl  or  escape\nsequences like \\D.  Macro calls are not themselves productive, but their in‐\nterpolated contents can be.\n±N        is a numeric expression with a meaning dependent on its sign.\n\nIf a numeric expression presented as ±N starts with a ‘+’ sign, an increment in the amount of\nof N is applied to the value applicable to the request or escape sequence.  If it starts with\na  ‘-’  sign,  a decrement of magnitude N is applied instead.  Without a sign, N replaces any\nexisting value.  A leading minus sign in N is always interpreted as a  decrementation  opera‐\ntor,  not  an  algebraic sign.  To assign a register a negative value or the negated value of\nanother register, enclose it with its operand in parentheses or subtract it from zero.  If  a\nprior value does not exist (the register was undefined), an increment or decrement is applied\nas if to 0.\n",
            "subsections": []
        },
        "Request short reference": {
            "content": "Not  all details of request behavior are outlined here.  See the groff Texinfo manual or, for\nfeatures new to GNU troff, groffdiff(7).\n\n.ab       Abort processing; exit with failure status.\n.ab message\nAbort processing; write message to the standard error stream and exit with  failure\nstatus.\n.ad       Enable output line alignment and adjustment using the mode stored in \\n[.j].\n.ad c     Enable output line alignment and adjustment in mode c (c=b,c,l,n,r).  Sets \\n[.j].\n.af register c\nAssign  format c to register, where c is “i”, “I”, “a”, “A”, or a sequence of deci‐\nmal digits whose quantity denotes the minimum width in digits to be used  when  the\nregister  is interpolated.  “i” and “a” indicate Roman numerals and basic Latin al‐\nphabetics, respectively, in the lettercase specified.  The default is 0.\n.aln new old\nCreate alias (additional name) new for existing register named old.\n.als new old\nCreate alias (additional name) new for existing request, string, macro,  or  diver‐\nsion old.\n.am macro Append to macro until .. is encountered.\n.am macro end\nAppend to macro until .end is called.\n.am1 macro\nSame as .am but with compatibility mode switched off during macro expansion.\n.am1 macro end\nSame as .am but with compatibility mode switched off during macro expansion.\n.ami macro\nAppend  to  a macro whose name is contained in the string macro until .. is encoun‐\ntered.\n.ami macro end\nAppend to a macro indirectly.  macro and end are strings whose contents are  inter‐\npolated for the macro name and the end macro, respectively.\n.ami1 macro\nSame as .ami but with compatibility mode switched off during macro expansion.\n.ami1 macro end\nSame as .ami but with compatibility mode switched off during macro expansion.\n.as name  Create string name with empty contents; no operation if name already exists.\n.as name contents\nAppend contents to string name.\n.as1 string\n.as1 string contents\nAs .as, but with compatibility mode disabled when contents interpolated.\n.asciify diversion\nUnformat ASCII characters, spaces, and some escape sequences in diversion.",
            "subsections": [
                {
                    "name": ".backtrace",
                    "content": "Write the state of the input stack to the standard error stream.  See the -b option\nof groff(1).\n.bd font  Stop emboldening font font.\n.bd font n\nEmbolden font by overstriking its glyphs offset by n-1 units.  See register .b.\n.bd special-font font\nStop emboldening special-font when font is selected.\n.bd special-font font n\nEmbolden special-font, overstriking its glyphs offset by n-1 units when font is se‐\nlected.  See register .b.\n.blm      Unset blank line macro (trap).  Restore default handling of blank lines.\n.blm name Set blank line macro (trap) to name.\n.box      Stop directing output to current diversion; any pending output line is discarded.\n.box name Direct output to diversion name, omitting a partially collected line.\n.boxa     Stop appending output to current diversion; any pending output line is discarded.\n.boxa name\nAppend output to diversion name, omitting a partially collected line.\n.bp       Break page and start a new one.\n.bp ±N    Break page, starting a new one numbered ±N.\n.br       Break output line.\n.brp      Break output line; adjust if applicable.\n.break    Break out of a while loop.\n.c2       Reset no-break control character to “'”.\n.c2 o     Recognize ordinary character o as no-break control character.\n.cc       Reset control character to ‘.’.\n.cc o     Recognize ordinary character o as the control character.\n.ce       Break,  center  the  output  of the next productive input line without filling, and\nbreak again.\n.ce npl   Break, center the output of the next npl productive input  lines  without  filling,\nthen break again.  If npl ≤ 0, stop centering.\n.cf file  Copy contents of file without formatting to the (top-level) diversion.\n.cflags n c1 c2 ...\nAssign properties encoded by n to characters c1, c2, and so on.\n.ch name  Unplant page location trap name.\n.ch name vpos\nChange  page  location trap name planted by .wh by moving its location to vpos (de‐\nfault scaling unit v).\n.char c contents\nDefine ordinary or special character c as contents.\n.chop object\nRemove the last character from the macro, string, or diversion named object.\n.class name c1 c2 ...\nDefine a (character) class name comprising the characters or range expressions  c1,\nc2, and so on.\n.close stream\nClose the stream.\n.color    Enable output of color-related device-independent output commands.\n.color n  If  n  is zero, disable output of color-related device-independent output commands;\notherwise, enable them.\n.composite from to\nMap glyph name from to glyph name to while constructing a composite glyph name.\n.continue Finish the current iteration of a while loop.\n.cp       Enable compatibility mode.\n.cp n     If n is zero, disable compatibility mode, otherwise enable it.\n.cs font n m\nSet constant character width mode for font to n/36 ems with em m.\n.cu       Continuously underline the output of the next productive input line.\n.cu npl   Continuously underline the output of the  next  npl  productive  input  lines.   If\nnpl=0, stop continuously underlining.\n.da       Stop appending output to current diversion.\n.da name  Append output to diversion name.\n.de macro Define  or  redefine  macro until “..” occurs at the start of a control line in the\ncurrent conditional block.\n.de macro end\nDefine or redefine macro until end is invoked or called at the start of  a  control\nline in the current conditional block.\n.de1 macro\nAs .de, but disable compatibility mode during macro expansion.\n.de1 macro end\nAs “.de macro end”, but disable compatibility mode during macro expansion.\n.defcolor ident scheme color-component ...\nDefine  a  color  named  ident.  scheme identifies a color space and determines the\nnumber of required color-components; it must be one of  “rgb”  (three  components),\n“cmy”  (three), “cmyk” (four), or “gray” (one).  “grey” is accepted as a synonym of\n“gray”.  The color components can be encoded as a single hexadecimal value starting\nwith # or ##.  The former indicates that each  component  is  in  the  range  0–255\n(0–FF),  the  latter the range 0–65,535 (0–FFFF).  Alternatively, each color compo‐\nnent can be specified as a decimal fraction in the range 0–1, interpreted  using  a\ndefault scaling unit of “f”, which multiplies its value by 65,536 (but clamps it at\n65,535).   Each  output  device  has a color named “default”, which cannot be rede‐\nfined.  A device's default stroke and fill colors are not necessarily the same.\n.dei macro\nDefine macro indirectly.  As .de, but use interpolation of string macro as the name\nof the defined macro.\n.dei macro end\nDefine macro indirectly.  As .de, but use interpolations of strings macro  and  end\nas the names of the defined and end macros.\n.dei1 macro\nAs .dei, but disable compatibility mode during macro expansion.\n.dei1 macro end\nAs .dei macro end, but disable compatibility mode during macro expansion.\n.device anything\nWrite anything, read in copy mode, to troff output as a device control command.  An\ninitial neutral double quote is stripped to allow embedding of leading spaces.\n.devicem name\nWrite contents of macro or string name to troff output as a device control command.\n.di       Stop directing output to current diversion.\n.di name  Direct output to diversion name.\n.do name ...\nInterpret  the string, request, diversion, or macro name (along with any arguments)\nwith compatibility mode disabled.  Compatibility mode is restored (only if  it  was\nactive) when the expansion of name is interpreted.\n.ds name  Create empty string name.\n.ds name contents\nCreate a string name containing contents.\n.ds1 name\n.ds1 name contents\nAs .ds, but with compatibility mode disabled when contents interpolated.\n.dt       Clear diversion trap.\n.dt vertical-position name\nSet the diversion trap to macro name at vertical-position (default scaling unit v).\n.ec       Recognize \\ as the escape character.\n.ec o     Recognize ordinary character o as the escape character.\n.ecr      Restore escape character saved with .ecs.\n.ecs      Save the escape character.\n.el anything\nInterpret anything as if it were an input line if the conditional expression of the\ncorresponding .ie request was false.\n.em name  Call macro name after the end of input.\n.eo       Disable the escape mechanism in interpretation mode.\n.ev       Pop environment stack, returning to previous one.\n.ev env   Push current environment onto stack and switch to env.\n.evc env  Copy environment env to the current one.\n.ex       Exit with successful status.\n.fam      Set default font family to previous value.\n.fam name Set default font family to name.\n.fc       Disable field mechanism.\n.fc a     Set field delimiter to a and pad glyph to space.\n.fc a b   Set field delimiter to a and pad glyph to b.\n.fchar c contents\nDefine fallback character (or glyph) c as contents.\n.fcolor   Restore previous fill color.\n.fcolor c Set fill color to c.\n.fi       Enable filling of output lines; a pending output line is broken.  Sets \\n[.u].\n.fl       Flush output buffer.\n.fp pos id\nMount font with font description file name id at non-negative position n.\n.fp pos id font-description-file-name\nMount font with font-description-file-name as name id at non-negative position n.\n.fschar f c anything\nDefine fallback character (or glyph) c for font f as string anything.\n.fspecial font\nReset list of special fonts for font to be empty.\n.fspecial font s1 s2 ...\nWhen the current font is font, then the fonts s1, s2, ... are special."
                },
                {
                    "name": ".ft",
                    "content": ".ft P     Select  previous  font  mounting position (abstract style or font); same as \\f[] or\n\\fP.\n.ft font  Select typeface font, which can be a mounting position,  abstract  style,  or  font\nname; same as \\f[font] escape sequence.  font cannot be P.\n.ftr font1 font2\nTranslate font1 to font2.\n.fzoom font\n.fzoom font 0\nStop magnifying font.\n.fzoom font z\nSet zoom factor for font to z (in thousandths; default: 1000).\n.gcolor   Restore previous stroke color.\n.gcolor c Set stroke color to c.\n.hc       Reset the hyphenation character to \\% (the default).\n.hc char  Change the hyphenation character to char.\n.hcode c1 code1 [c2 code2] ...\nSet the hyphenation code of character c1 to code1, that of c2 to code2, and so on.\n.hla lang Set the hyphenation language to lang.\n.hlm n    Set the maximum quantity of consecutive hyphenated lines to n.\n.hpf pattern-file\nRead hyphenation patterns from pattern-file.\n.hpfa pattern-file\nAppend hyphenation patterns from pattern-file.\n.hpfcode a b [c d] ...\nDefine mappings for character codes in hyphenation pattern files read with .hpf and\n.hpfa.\n.hw word ...\nDefine  hyphenation  overrides  for each word; a hyphen “-” indicates a hyphenation\npoint.\n.hy       Set automatic hyphenation mode to 1.\n.hy 0     Disable automatic hyphenation; same as .nh.\n.hy mode  Set automatic hyphenation mode to mode; see section “Hyphenation” below.\n.hym      Set the (right) hyphenation margin to 0 (the default).\n.hym length\nSet the (right) hyphenation margin to length (default scaling unit m).\n.hys      Set the hyphenation space to 0 (the default).\n.hys hyphenation-space\nSuppress automatic hyphenation in adjustment modes “b” or “n” if the  line  can  be\njustified  with  the  addition  of up to hyphenation-space to each inter-word space\n(default scaling unit m).\n.ie cond-expr anything\nIf cond-expr is true, interpret anything as if it were  an  input  line,  otherwise\nskip to a corresponding .el request.\n.if cond-expr anything\nIf cond-expr is true, then interpret anything as if it were an input line.\n.ig       Ignore  input  (except for side effects of \\R on auto-incrementing registers) until\n“..” occurs at the start of a control line in the current conditional block.\n.ig end   Ignore input (except for side effects of \\R on auto-incrementing  registers)  until\n.end is called at the start of a control line in the current conditional block.\n.in       Set indentation amount to previous value.\n.in ±N    Set indentation to ±N (default scaling unit m).\n.it       Cancel any pending input line trap.\n.it npl name\nSet  (or  replace) an input line trap in the environment, calling macro name, after\nthe next npl productive input lines have been read.  Lines interrupted with the  \\c\nescape sequence are counted separately.\n.itc      Cancel any pending input line trap.\n.itc npl name\nAs  .it,  except  that  input lines interrupted with the \\c escape sequence are not\ncounted.\n.kern     Enable pairwise kerning.\n.kern n   If n is zero, disable pairwise kerning, otherwise enable it.\n.lc       Unset leader repetition character.\n.lc c     Set leader repetition character to c (default: “.”).\n.length reg anything\nCompute the number of characters of anything and store the count  in  the  register\nreg.\n.linetabs Enable  line-tabs  mode  (calculate  tab  positions relative to beginning of output\nline)."
                },
                {
                    "name": ".linetabs 0",
                    "content": "Disable line-tabs mode.\n.lf n     Set number of next input line to n.\n.lf n file\nSet number of next input line to n and input file name to file.\n.lg m     Set ligature mode to m (0 = disable, 1 = enable, 2 = enable  for  two-letter  liga‐\ntures only).\n.ll       Set line length to previous value.  Does not affect a pending output line.\n.ll ±N    Set  line length to ±N (default length 6.5i, default scaling unit m).  Does not af‐\nfect a pending output line.\n.lsm      Unset the leading space macro (trap).  Restore default handling of lines with lead‐\ning spaces.\n.lsm name Set the leading space macro (trap) to name.\n.ls       Change to the previous value of additional intra-line skip.\n.ls n     Set additional intra-line skip value to n, i.e., n-1 blank lines are inserted after\neach text output line.\n.lt       Set length of title lines to previous value.\n.lt ±N    Set length of title lines (default length 6.5i, default scaling unit m).\n.mc       Cease writing margin character.\n.mc c     Begin writing margin character c to the right of each output line.\n.mc c d   Begin writing margin character c on each output line at distance d to the right  of\nthe right margin (default distance 10p, default scaling unit m).\n.mk       Mark vertical drawing position in an internal register; see .rt.\n.mk register\nMark vertical drawing position in register.\n.mso file As .so, except that file is sought in the tmac directories.\n.msoquiet file\nAs .mso, but no warning is emitted if file does not exist.\n.na       Disable output line adjustment.\n.ne       Break page if distance to next page location trap is less than one vee.\n.ne d     Break  page if distance to next page location trap is less than distance d (default\nscaling unit v).\n.nf       Disable filling of output lines; a pending output line is broken.  Clears \\n[.u].\n.nh       Disable automatic hyphenation; same as “.hy 0”.\n.nm       Deactivate output line numbering.\n.nm ±N\n.nm ±N m\n.nm ±N m s\n.nm ±N m s i\nActivate output line numbering: number the next output  line  ±N,  writing  numbers\nevery  m  lines,  with s numeral widths (\\0) between the line number and the output\n(default 1), and indenting the line number by i numeral widths (default 0).\n.nn       Suppress numbering of the next output line to be numbered with nm.\n.nn n     Suppress numbering of the next n output lines to be numbered with nm.  If n=0, can‐\ncel suppression.\n.nop anything\nInterpret anything as if it were an input line.\n.nr reg ±N\nDefine or update register reg with value N.\n.nr reg ±N I\nDefine or update register reg with value N and auto-increment I.\n.nroff    Make the conditional expressions n true and t false.\n.ns       Enable no-space mode, ignoring .sp requests until a glyph or \\D primitive  is  out‐\nput.  See .rs.\n.nx       Immediately jump to end of current file.\n.nx file  Stop formatting current file and begin reading file.\n.open stream file\nOpen  file  for  writing and associate the stream named stream with it.  Unsafe re‐\nquest; disabled by default.\n.opena stream file\nAs .open, but append to file.  Unsafe request; disabled by default.\n.os       Output vertical distance that was saved by the .sv request.\n.output contents\nEmit contents directly to  intermediate  output,  allowing  leading  whitespace  if\nstring starts with \" (which is stripped off).\n.pc       Reset page number character to ‘%’.\n.pc c     Page number character.\n.pev      Report  the state of the current environment followed by that of all other environ‐\nments to the standard error stream.\n.pi program\nPipe output to program (nroff only).  Unsafe request; disabled by default.\n.pl       Set page length to default 11i.  The current page length is stored in register .p.\n.pl ±N    Change page length to ±N (default scaling unit v).\n.pm       Report, to the standard error stream, the names  and  sizes  in  bytes  of  defined\nmacros, strings, and diversions.\n.pn ±N    Next page number N.\n.pnr      Write the names and contents of all defined registers to the standard error stream.\n.po       Change  to  previous page offset.  The current page offset is available in register\n.o.\n.po ±N    Page offset N.\n.ps       Return to previous type size.\n.ps ±N    Set/increase/decrease the type size to/by N scaled points (a non-positive resulting\ntype size is set to 1 u); also see \\s[±N].\n.psbb file\nRetrieve the bounding box of the PostScript image found in file, which must conform\nto Adobe's Document Structuring Conventions (DSC).  See registers  llx,  lly,  urx,\nury.\n.pso command-line\nExecute  command-line  with  popen(3)  and interpolate its output.  Unsafe request;\ndisabled by default.\n.ptr      Report names and positions of all page location traps to the standard error stream.\n.pvs      Change to previous post-vertical line spacing.\n.pvs ±N   Change post-vertical line spacing according to ±N (default scaling unit p).\n.rchar c1 c2 ...\nRemove definition of each ordinary or special character c1, c2, ...  defined  by  a\n.char, .fchar, or .schar request.\n.rd prompt\nRead insertion.\n.return   Return from a macro.\n.return anything\nReturn  twice,  namely  from  the macro at the current level and from the macro one\nlevel higher.\n.rfschar f c1 c2 ...\nRemove the font-specific definitions of glyphs c1, c2, ... for font f.\n.rj npl   Break, right-align the output of the next productive input  line  without  filling,\nthen break again.\n.rj npl   Break,  right-align the output of the next npl productive input lines without fill‐\ning, then break again.  If npl ≤ 0, stop right-aligning.\n.rm name  Remove request, macro, diversion, or string name.\n.rn old new\nRename request, macro, diversion, or string old to new.\n.rnn reg1 reg2\nRename register reg1 to reg2.\n.rr ident Remove register ident.\n.rs       Restore spacing; disable no-space mode.  See .ns.\n.rt       Return (upward only) to vertical position marked by .mk on the current page.\n.rt N     Return (upward only) to vertical position N (default scaling unit v).\n.schar c contents\nDefine global fallback character (or glyph) c as contents.\n.shc      Reset the soft hyphen character to \\[hy].\n.shc c    Set the soft hyphen character to c.\n.shift n  In a macro definition, left-shift arguments by n positions.\n.sizes s1 s2 ... sn [0]\nSet available type sizes similarly to the sizes directive in a DESC file.  Each  si\nis interpreted in units of scaled points (z).\n.so file  Replace the request's control line with the contents of file, “sourcing” it.\n.soquiet file\nAs .so, but no warning is emitted if file does not exist.\n.sp       Break  and  move  the next text baseline down by one vee, or until springing a page\nlocation trap.\n.sp dist  Break and move the next text baseline down by dist, or until springing a page loca‐\ntion trap (default scaling unit v).  A negative dist will not reduce  the  position\nof the text baseline below zero.  Prefixing dist with the | operator moves to a po‐\nsition relative to the page top for positive N, and the bottom if N is negative; in\nall cases, one line height (vee) is added to dist.  dist is ignored inside a diver‐\nsion.\n.special  Reset global list of special fonts to be empty.\n.special s1 s2 ...\nFonts s1, s2, etc. are special and are searched for glyphs not in the current font."
                },
                {
                    "name": ".spreadwarn",
                    "content": "Toggle the spread warning on and off (the default) without changing its value.\n.spreadwarn N\nEmit  a break warning if the additional space inserted for each space between words\nin an adjusted output line is greater than or equal to N.  A negative N is  treated\nas 0.  The default scaling unit is m.  At startup, .spreadwarn is inactive and N is\n3 m.\n.ss n     Set minimal inter-word spacing to n 12ths of current font's space width.\n.ss n m   As  “.ss  n”,  and set additional inter-sentence space to m 12ths of current font's\nspace width.\n.stringdown stringvar\nReplace each byte in the string named stringvar with its lowercase version.\n.stringup stringvar\nReplace each byte in the string named stringvar with its uppercase version.\n.sty n style\nAssociate abstract style with font position n.\n.substring str start [end]\nReplace the string named str with its substring bounded by the  indices  start  and\nend, inclusive.  Negative indices count backwards from the end of the string.\n.sv       As .ne, but save 1 v for output with .os request.\n.sv d     As  .ne,  but  save  distance  d for later output with .os request (default scaling\nunit v).\n.sy command-line\nExecute command-line with system(3).  Unsafe request; disabled by default.\n.ta n1 n2 ... nn T r1 r2 ... rn\nSet tabs at positions n1,  n2,  ...,  nn,  then  set  tabs  at  nn+m×rn+r1  through\nnn+m×rn+rn,  where  m increments from 0, 1, 2, ... to the output line length.  Each\nn argument can be prefixed with a “+” to place the tab stop ni at a distance  rela‐\ntive to the previous, n(i-1).  Each argument ni or ri can be suffixed with a letter\nto  align  text within the tab column bounded by tab stops i and i+1; “L” for left-\naligned (the default), “C” for centered, and “R” for right-aligned."
                },
                {
                    "name": ".tag",
                    "content": ".taga     Reserved for internal use.\n.tc       Unset tab repetition character.\n.tc c     Set tab repetition character to c (default: none).\n.ti ±N    Temporarily indent next output line (default scaling unit m).\n.tkf font s1 n1 s2 n2\nEnable track kerning for font.\n.tl 'left'center'right'\nFormat three-part title.\n.tm message\nWrite message, followed by a newline, to the standard error stream.\n.tm1 message\nAs .tm, but an initial neutral double quote in message is removed, allowing  it  to\ncontain leading spaces.\n.tmc message\nAs .tm1, without emitting a newline.\n.tr abcd...\nTranslate ordinary or special characters a to b, c to d, and so on prior to output.\n.trf file Transparently output the contents of file.  Unlike .cf, invalid input characters in\nfile are rejected.\n.trin abcd...\nAs  .tr,  except that .asciify ignores the translation when a diversion is interpo‐\nlated.\n.trnt abcd...\nAs .tr, except that translations are suppressed in the argument to \\!.\n.troff    Make the conditional expressions t true and n false.\n.uf font  Set underline font used by .ul to font.\n.ul       Underline (italicize in troff mode) the output of the next productive input line.\n.ul npl   Underline (italicize in troff mode) the output of the  next  npl  productive  input\nline.  If npl=0, stop underlining.\n.unformat diversion\nUnformat space characters and tabs in diversion, preserving font information.\n.vpt      Enable vertical position traps.\n.vpt 0    Disable vertical position traps.\n.vs       Change to previous vertical spacing.\n.vs ±N    Set vertical spacing to ±N (default scaling unit p).\n.warn     Enable all warning categories.\n.warn 0   Disable all warning categories.\n.warn n   Enable warnings in categories whose codes sum to n; see troff(1).\n.warnscale su\nSet  scaling unit used in certain warnings to su (one of u, i, c, p, or P; default:\ni).\n.wh vpos  Remove visible page location trap at vpos (default scaling unit v).\n.wh vpos name\nPlant macro name as page location trap at vpos (default scaling unit  v),  removing\nany visible trap already there.\n.while cond-expr anything\nRepeatedly execute anything unless and until cond-expr evaluates false.\n.write stream anything\nWrite anything to the stream named stream.\n.writec stream anything\nSimilar to .write without emitting a final newline.\n.writem stream xx\nWrite contents of macro or string xx to the stream named stream.\n"
                }
            ]
        },
        "Escape sequence short reference": {
            "content": "The escape sequences \\\", \\#, \\$, \\*, \\?, \\a, \\e, \\n, \\t, \\g, \\V, and \\newline are interpreted\neven in copy mode.\n\n\\\"     Comment.  Everything up to the end of the line is ignored.\n\\#     Comment.  Everything up to and including the next newline is ignored.\n\\*s    Interpolate string with one-character name s.\n\\*(st  Interpolate string with two-character name st.\n\\*[string]\nInterpolate string with name string (of arbitrary length).\n\\*[string arg ...]\nInterpolate  string  with  name  string (of arbitrary length), taking arg ... as argu‐\nments.\n\\$0    Interpolate name by which currently executing macro was invoked.\n\\$n    Interpolate macro or string parameter numbered n (1≤n≤9).\n\\$(nn  Interpolate macro or string parameter numbered nn (01≤nn≤99).\n\\$[nnn]\nInterpolate macro or string parameter numbered nnn (nnn≥1).\n\\$*    Interpolate concatenation of all macro or string parameters, separated by spaces.\n\\$@    Interpolate concatenation of all macro or string parameters, with each  surrounded  by\ndouble quotes and separated by spaces.\n\\$^    Interpolate  concatenation of all macro or string parameters as if they were arguments\nto the .ds request.\n\\'     is a synonym for \\[aa], the acute accent special character.\n\\`     is a synonym for \\[ga], the grave accent special character.\n\\-     is a synonym for \\[-], the minus sign special character.\n\\     is a synonym for \\[ul], the underrule special character.\n\\%     Control hyphenation.\n\\!     Transparent line.  The remainder of the input line is interpreted (1) when the current\ndiversion is read; or (2) if in the top-level  diversion,  by  the  postprocessor  (if\nany).\n\\?anything\\?\nTransparently  embed anything, read in copy mode, in a diversion, or unformatted as an\noutput comparand in a conditional expression.\n\\space Move right one word space.\n\\~     Insert an unbreakable, adjustable space.\n\\0     Move right by the width of a numeral in the current font.\n\\|     Move one-sixth em to the right on typesetters.\n\\^     Move one-twelfth em to the right on typesetters.\n\\&     Interpolate a dummy character.\n\\)     Interpolate a dummy character that is transparent to end-of-sentence recognition.\n\\/     Apply italic correction.  Use between an immediately adjacent  oblique  glyph  on  the\nleft and an upright glyph on the right.\n\\,     Apply  left  italic  correction.  Use between an immediately adjacent upright glyph on\nthe left and an oblique glyph on the right.\n\\:     Non-printing break point (similar to \\%, but never produces a hyphen glyph).\n\\newline\nContinue current input line on the next.\n\\{     Begin conditional input.\n\\}     End conditional input.\n\\(gl   Interpolate glyph with two-character name gl.\n\\[glyph]\nInterpolate glyph with name glyph (of arbitrary length).\n\\[base-char comp ...]\nInterpolate composite glyph constructed from base-char and each component comp.\n\\[charnnn]\nInterpolate glyph of eight-bit encoded character nnn, where 0≤nnn≤255.\n\\[unnnn[n[n]]]\nInterpolate glyph of Unicode character with code point nnnn[n[n]] in  uppercase  hexa‐\ndecimal.\n\\[ubase-char[combining-component]...]\nInterpolate composite glyph from Unicode character base-char and combining-components.\n\\a     Interpolate a leader in copy mode.\n\\A'anything'\nInterpolate 1 if anything is a valid identifier, and 0 otherwise.\n\\b'string'\nBuild  bracket:  pile  a  sequence of glyphs corresponding to each character in string\nvertically, and center it vertically on the output line.\n\\B'anything'\nInterpolate 1 if anything is a valid numeric expression, and 0 otherwise.\n\\c     Continue output line at next input line.\n\\C'glyph'\nAs \\[glyph], but compatible with other troff implementations.\n\\d     Move downward ½ em on typesetters.\n\\D'drawing-command'\nSee subsection “Drawing commands” below.\n\\e     Interpolate the escape character.\n\\E     As \\e, but not interpreted in copy mode.\n\\fP    Select previous font mounting position (abstract style or  font);  same  as  “.ft”  or\n“.ft P”.\n\\fF    Select font mounting position, abstract style, or font with one-character name or one-\ndigit position F.  F cannot be P.\n\\f(ft  Select font mounting position, abstract style, or font with two-character name or two-\ndigit position ft.\n\\f[font]\nSelect  font  mounting position, abstract style, or font with arbitrarily long name or\nposition font.  font cannot be P.\n\\f[]   Select previous font mounting position (abstract style or font).\n\\Ff    Set default font family to that with one-character name f.\n\\F(fm  Set default font family to that with two-character name fm.\n\\F[fam]\nSet default font family to that with arbitrarily long name fam.\n\\F[]   Set default font family to previous value.\n\\gr    Interpolate format of register with one-character name r.\n\\g(rg  Interpolate format of register with two-character name rg.\n\\g[reg]\nInterpolate format of register with arbitrarily long name reg.\n\\h'N'  Horizontally move the drawing position by N ems (or specified units); | may  be  used.\nPositive motion is rightward.\n\\H'N'  Set height of current font to N scaled points (or specified units).\n\\kr    Mark horizontal position in one-character register name r.\n\\k(rg  Mark horizontal position in two-character register name rg.\n\\k[reg]\nMark horizontal position in register with arbitrarily long name reg.\n\\l'N[c]'\nDraw  horizontal  line  of  length N with character c (default: \\[ru]; default scaling\nunit m).\n\\L'N[c]'\nDraw vertical line of length N with  character  c  (default:  \\[br];  default  scaling\nunit v).\n\\mc    Set stroke color to that with one-character name c.\n\\m(cl  Set stroke color to that with two-character name cl.\n\\m[color]\nSet stroke color to that with arbitrarily long name color.\n\\m[]   Restore previous stroke color.\n\\Mc    Set fill color to that with one-character name c.\n\\M(cl  Set fill color to that with two-character name cl.\n\\M[color]\nSet fill color to that with arbitrarily long name color.\n\\M[]   Restore previous fill color.\n\\nr    Interpolate contents of register with one-character name r.\n\\n(rg  Interpolate contents of register with two-character name rg.\n\\n[reg]\nInterpolate contents of register with arbitrarily long name reg.\n\\N'n'  Interpolate glyph with index n in the current font.\n\\o'abc...'\nOverstrike centered glyphs of characters a, b, c, and so on.\n\\O0    At  the  outermost suppression level, disable emission of glyphs and geometric objects\nto the output driver.\n\\O1    At the outermost suppression level, enable emission of glyphs and geometric objects to\nthe output driver.\n\\O2    At the outermost suppression level, enable glyph and geometric primitive  emission  to\nthe  output driver and write to the standard error stream the page number, four bound‐\ning box registers enclosing glyphs written since the previous \\O escape sequence,  the\npage offset, line length, image file name (if any), horizontal and vertical device mo‐\ntion quanta, and input file name.\n\\O3    Begin a nested suppression level.\n\\O4    End a nested suppression level.\n\\O[5Pfile]\nAt  the  outermost suppression level, write the name file to the standard error stream\nat position P, which must be one of l, r, c, or i.\n\\p     Break output line at next word boundary; adjust if applicable.\n\\r     Move “in reverse” (upward) 1 em.\n\\R'name ±N'\nSet, increment, or decrement register name by N.\n\\s±N   Set/increase/decrease the type size to/by N scaled points.  N must be a single  digit;\n0  restores the previous type size.  (In compatibility mode only, a non-zero N must be\nin the range 4–39.)  Otherwise, as .ps request.\n\\s(±N\n\\s±(N  Set/increase/decrease the type size to/by N scaled points; N is a two-digit number ≥1.\nAs .ps request.\n\\s[±N]\n\\s±[N]\n\\s'±N'\n\\s±'N' Set/increase/decrease the type size to/by N scaled points.  As .ps request.\n\\S'N'  Slant output glyphs by N degrees; the direction of text flow is positive.\n\\t     Interpolate a tab in copy mode.\n\\u     Move upward ½ em on typesetters.\n\\v'N'  Vertically move the drawing position by N vees (or specified units); |  may  be  used.\nPositive motion is downward.\n\\Ve    Interpolate contents of environment variable with one-character name e.\n\\V(ev  Interpolate contents of environment variable with two-character name ev.\n\\V[env]\nInterpolate contents of environment variable with arbitrarily long name env.\n\\w'anything'\nInterpolate width of anything, formatted in a dummy environment.\n\\x'N'  Increase  vertical spacing of pending output line by N vees (or specified units; nega‐\ntive before, positive after).\n\\X'anything'\nWrite anything to troff output as a device control command.  Within anything, the  es‐\ncape  sequences  \\&, \\), \\%, and \\: are ignored; \\space and \\~ are converted to single\nspace characters; and \\\\ has its escape character stripped.  So that the  basic  Latin\nsubset  of  the Unicode character set can be reliably encoded in anything, the special\ncharacter escape sequences \\-, \\[aq], \\[dq], \\[ga], \\[ha], \\[rs], and \\[ti] are mapped\nto basic Latin characters; see  groffchar(7).   For  this  transformation,  character\ntranslations and special character definitions are ignored.\n\\Yn    Write contents of macro or string n to troff output as a device control command.\n\\Y(nm  Write contents of macro or string nm to troff output as a device control command.\n\\Y[name]\nWrite contents of macro or string name to troff output as a device control command.\n\\zc    Format character c with zero width—without advancing the drawing position.\n\\Z'anything'\nSave the drawing position, format anything, then restore it.\n",
            "subsections": [
                {
                    "name": "Drawing commands",
                    "content": "Drawing  commands  direct the output device to render geometrical objects rather than glyphs.\nSpecific devices may support only a subset, or may feature additional ones; consult  the  man\npage for the output driver in use.  Terminal devices in particular implement almost none.\n\nRendering  starts at the drawing position; when finished, the drawing position is left at the\nrightmost point of the object, even for closed figures, except where noted.  GNU troff  draws\nstroked (outlined) objects with the stroke color, and shades filled ones with the fill color.\nSee section “Colors” above.  Coordinates h and v are horizontal and vertical motions relative\nto the drawing position or previous point in the command.  The default scaling unit for hori‐\nzontal measurements (and diameters of circles) is m; for vertical ones, v.\n\nCircles,  ellipses, and polygons can be drawn stroked or filled.  These are independent prop‐\nerties; if you want a filled, stroked figure, you must draw the same figure twice using  each\ndrawing  command.   A filled figure is always smaller than an outlined one because the former\nis drawn only within its defined area, whereas  strokes  have  a  line  thickness  (set  with\n\\D't').\n\n\\D'~ h1 v1 ... hn vn'\nDraw B-spline to each point in sequence, leaving drawing position at (hn, vn).\n\\D'a hc vc h v'\nDraw circular arc centered at (hc, vc) counterclockwise from the drawing position to a\npoint  (h,  v)  relative to the center.  (hc, vc) is adjusted to the point nearest the\nperpendicular bisector of the arc's chord.\n\\D'c d'\nDraw circle of diameter d with its leftmost point at the drawing position.\n\\D'C d'\nAs \\D'C', but the circle is filled.\n\\D'e h v'\nDraw ellipse of width h and height v with its leftmost point at the drawing position.\n\\D'E h v'\nAs \\D'e', but the ellipse is filled.\n\\D'l h v'\nDraw line from the drawing position to (h, v).\n\\D'p h1 v1 ... hn vn'\nDraw polygon with vertices at drawing position and each point in sequence.  GNU  troff\ncloses  the  polygon by drawing a line from (hn, vn) back to the initial drawing posi‐\ntion.  Afterward, the drawing position is left at (hn, vn).\n\\D'P h1 v1 ... hn vn'\nAs \\D'p', but the polygon is filled.\n\\D't n'\nSet stroke thickness of geometric objects to to n basic units.  A zero n  selects  the\nminimal  supported  thickness.   A  negative n selects a thickness proportional to the\ntype size; this is the default.\n"
                },
                {
                    "name": "Device control commands",
                    "content": "The .device and .devicem requests, and \\X and \\Y escape sequences, enable documents  to  pass\ninformation directly to a postprocessor.  These are useful for exercising device-specific ca‐\npabilities  that  the  groff language does not abstract or generalize; such functions include\nthe embedding of hyperlinks and image files.  Device-specific  functions  are  documented  in\neach output driver's man page.\n"
                }
            ]
        },
        "Strings": {
            "content": "groff supports strings primarily for user convenience.  Conventionally, if one would define a\nmacro  only  to  interpolate a small amount of text, without invoking requests or calling any\nother macros, one defines a string instead.  Only one string is predefined by the language.\n\n\\*[.T]    Contains the name of the output device (for example, “utf8” or “pdf”).\n\nThe .ds request creates a string with a specified name and contents.  If the identifier named\nby .ds already exists as an alias, the target of the alias is redefined.  If  .ds  is  called\nwith  only one argument, the named string becomes empty.  Otherwise, troff stores the remain‐\nder of the control line in copy mode; see subsection “Copy mode” below.\n\nThe \\* escape sequence dereferences a string's name, interpolating its contents.  If the name\ndoes not exist, it is defined as empty, nothing is interpolated, and a  warning  in  category\n“mac”  is emitted.  See section “Warnings” in troff(1).  The bracketed interpolation form ac‐\ncepts arguments that are handled as macro arguments are; see section “Calling macros”  above.\nIn contrast to macro calls, however, if a closing bracket ] occurs in a string argument, that\nargument  must  be  enclosed  in  double  quotes.  \\* is interpreted even in copy mode.  When\ndefining strings, argument interpolations must be escaped if they are to reference parameters\nfrom the calling context; see section “Parameters” below.\n\nAn initial neutral double quote \" in the string contents is stripped to  allow  embedding  of\nleading  spaces.   Any  other  \"  is interpreted literally, but it is wise to use the special\ncharacter escape sequence \\[dq] instead if the string might be  interpolated  as  part  of  a\nmacro  argument; see section “Calling macros” above.  Strings are not limited to a single in‐\nput line of text.  \\newline works just as it does elsewhere.  The resulting string is  stored\nwithout the newlines.  Care is therefore required when interpolating strings while filling is\ndisabled.  It is not possible to embed a newline in a string that will be interpreted as such\nwhen  the  string is interpolated.  To achieve that effect, use \\* to interpolate a macro in‐\nstead.\n\nThe .as request is similar to .ds but appends to a string instead of redefining it.   If  .as\nis  called  with  only  one  argument,  no  operation  is performed (beyond dereferencing the\nstring).\n\nBecause strings are similar to macros, they too can be defined to suppress AT&T troff compat‐\nibility mode enablement when interpolated; see section “Compatibility mode” below.  The  .ds1\nrequest  defines  a string that suspends compatibility mode when the string is later interpo‐\nlated.  .as1 is likewise similar to .as, with compatibility mode suspended when the  appended\nportion of the string is later interpolated.\n\nCaution:  Unlike other requests, the second argument to these requests consumes the remainder\nof the input line, including trailing spaces.  Ending string  definitions  (and  appendments)\nwith  a  comment,  even  an empty one, prevents unwanted space from creeping into them during\nsource document maintenance.\n\nSeveral requests exist to perform rudimentary string  operations.   Strings  can  be  queried\n(.length)  and  modified  (.chop, .substring, .stringup, .stringdown), and their names can be\nmanipulated through renaming, removal, and aliasing (.rn, .rm, .als).\n\nWhen a request, macro, string, or diversion is aliased, redefinitions and appendments  “write\nthrough” alias names.  To replace an alias with a separately defined object, you must use the\nrm request on its name first.\n",
            "subsections": []
        },
        "Registers": {
            "content": "In  the  roff  language,  numbers can be stored in registers.  Many built-in registers exist,\nsupplying anything from the date to details of formatting parameters.  You  can  also  define\nyour own.  See section “Identifiers” above for information on constructing a valid name for a\nregister.\n\nDefine registers and update their values with the nr request or the \\R escape sequence.\n\nRegisters  can also be incremented or decremented by a configured amount at the time they are\ninterpolated.  The value of the increment is specified with a third argument to the  .nr  re‐\nquest,  and a special interpolation syntax, \\n± is used to alter and then retrieve the regis‐\nter's value.  Together, these features are called auto-increment.  (A negative auto-increment\ncan be considered an “auto-decrement”.)\n\nMany predefined registers are available.  In the following presentation, the register  inter‐\npolation syntax \\n[name] is used to refer to a register name to clearly distinguish it from a\nstring  or  request  name.   The register name space is separate from that used for requests,\nmacros, strings, and diversions.  Bear in mind that the symbols \\n[] are not part of the reg‐\nister name.\n",
            "subsections": [
                {
                    "name": "Read-only registers",
                    "content": "Predefined registers whose identifiers start with a dot are read-only.  Many are Boolean-val‐\nued.  Some are string-valued, meaning that they interpolate text.  A register  name  (without\nthe dot) is often associated with a request of the same name; exceptions are noted.\n\n\\n[.$]         Count of arguments passed to currently interpolated macro or string.\n\\n[.a]         Amount of extra post-vertical line space; see \\x.\n\\n[.A]         Approximate output is being formatted (Boolean-valued); see troff -a option.\n\\n[.b]         Font emboldening offset; see .bd.\n\\n[.br]        The normal control character was used to call the currently interpolated macro\n(Boolean-valued).\n\\n[.c]         Input line number; see .lf and register “c.”.\n\\n[.C]         Compatibility  mode  is  enabled (Boolean-valued); see .cp.  Always false when\nprocessing .do; see register .cp.\n\\n[.cdp]       Depth of last glyph formatted in the environment; positive  if  glyph  extends\nbelow the baseline.\n\\n[.ce]        Count of output lines remaining to be centered.\n\\n[.cht]       Height  of  last glyph formatted in the environment; positive if glyph extends\nabove the baseline.\n\\n[.color]     Color output is enabled (Boolean-valued).\n\\n[.cp]        Within .do, the saved value of compatibility mode; see register .C.\n\\n[.csk]       Skew of the last glyph formatted in the environment; skew is how  far  to  the\nright  of the center of a glyph the center of an accent over that glyph should\nbe placed.\n\\n[.d]         Vertical drawing position in diversion.\n\\n[.ev]        Name of environment (string-valued).\n\\n[.f]         Mounting position of selected font; see .ft and \\f.\n\\n[.F]         Name of input file (string-valued); see .lf.\n\\n[.fam]       Name of default font family (string-valued).\n\\n[.fn]        Resolved name of selected font (string-valued); see .ft and \\f.\n\\n[.fp]        Next non-zero free font mounting position index.\n\\n[.g]         Always true in GNU troff (Boolean-valued).\n\\n[.h]         Text baseline high-water mark on page or in diversion.\n\\n[.H]         Horizontal motion quantum of output device in basic units.\n\\n[.height]    Font height; see \\H.\n\\n[.hla]       Hyphenation language in environment (string-valued).\n\\n[.hlc]       Count of immediately preceding consecutive hyphenated lines in environment.\n\\n[.hlm]       Maximum quantity of consecutive hyphenated lines allowed in environment.\n\\n[.hy]        Automatic hyphenation mode in environment.\n\\n[.hym]       Hyphenation margin in environment.\n\\n[.hys]       Hyphenation space adjustment threshold in environment.\n\\n[.i]         Indentation amount; see .in.\n\\n[.in]        Indentation amount applicable to the pending output line; see .ti.\n\\n[.int]       Previous output line was “interrupted” or continued with \\c (Boolean-valued).\n\\n[.j]         Adjustment mode encoded as an integer; see .ad and .na.  Do not  interpret  or\nperform arithmetic on its value.\n\\n[.k]         Horizontal drawing position relative to indentation.\n\\n[.kern]      Pairwise kerning is enabled (Boolean-valued).\n\\n[.l]         Line length; see .ll.\n\\n[.L]         Line spacing; see .ls.\n\\n[.lg]        Ligature mode.\n\\n[.linetabs]  Line-tabs mode is enabled (Boolean-valued).\n\\n[.ll]        Line length applicable to the pending output line.\n\\n[.lt]        Title length.\n\\n[.m]         Stroke  color  (string-valued); see .gcolor and \\m.  Empty if the stroke color\nis the default.\n\\n[.M]         Fill color (string-valued); see .fcolor and \\M.  Empty if the  fill  color  is\nthe default.\n\\n[.n]         Length of formatted output on previous output line.\n\\n[.ne]        Amount of vertical space required by last .ne that caused a trap to be sprung;\nalso see register .trunc.\n\\n[.nm]        Output line numbering is enabled (Boolean-valued).\n\\n[.nn]        Count of output lines remaining to have numbering suppressed.\n\\n[.ns]        No-space mode is enabled (Boolean-valued).\n\\n[.o]         Page offset; see .po.\n\\n[.O]         Output suppression nesting level; see \\O.\n\\n[.p]         Page length; see .pl.\n\\n[.P]         The page is selected for output (Boolean-valued); see troff -o option.\n\\n[.pe]        Page ejection is in progress (Boolean-valued).\n\\n[.pn]        Number of the next page.\n\\n[.ps]        Type size in scaled points.\n\\n[.psr]       Most recently requested type size in scaled points; see .ps and \\s.\n\\n[.pvs]       Post-vertical line spacing.\n\\n[.R]         Count of available unused registers; always 10,000 in GNU troff.\n\\n[.rj]        Count of lines remaining to be right-aligned.\n\\n[.s]         Type size in points as a decimal fraction (string-valued); see .ps and \\s.\n\\n[.slant]     Slant of font in degrees; see \\S.\n\\n[.sr]        Most recently requested type size in points as a decimal fraction (string-val‐\nued); see .ps and \\s.\n\\n[.ss]        Size  of  minimal  inter-word  space in twelfths of the space width of the se‐\nlected font.\n\\n[.sss]       Size of additional inter-sentence space in twelfths of the space width of  the\nselected font.\n\\n[.sty]       Selected abstract style (string-valued); see .ft and \\f.\n\\n[.t]         Distance to next vertical position trap; see .wh and .ch.\n\\n[.T]         An  output  device  was explicitly selected (Boolean-valued); see troff -T op‐\ntion.\n\\n[.tabs]      Representation of tab settings suitable for use as argument  to  .ta  (string-\nvalued).\n\\n[.trunc]     Amount  of vertical space truncated by the most recently sprung vertical posi‐\ntion trap, or, if the trap was sprung by an .ne, minus the amount of  vertical\nmotion produced by .ne; also see register .ne.\n\\n[.u]         Filling is enabled (Boolean-valued); see .fi and .nf.\n\\n[.U]         Unsafe mode is enabled (Boolean-valued); see troff -U option.\n\\n[.v]         Vertical line spacing; see .vs.\n\\n[.V]         Vertical motion quantum of the output device in basic units.\n\\n[.vpt]       Vertical position traps are enabled (Boolean-valued).\n\\n[.w]         Width of previous glyph formatted in the environment.\n\\n[.warn]      Sum of the numeric codes of enabled warning categories.\n\\n[.x]         Major version number of the running troff formatter.\n\\n[.y]         Minor version number of the running troff formatter.\n\\n[.Y]         Revision number of the running troff formatter.\n\\n[.z]         Name  of  diversion  (string-valued).  Empty if output is directed to the top-\nlevel diversion.\n\\n[.zoom]      Zoom multiplier of current font (in thousandths; zero  if  no  magnification);\nsee .fzoom.\n"
                },
                {
                    "name": "Writable predefined registers",
                    "content": "Several registers are predefined but also modifiable; some are updated upon interpretation of\ncertain  requests or escape sequences.  Date- and time-related registers are set to the local\ntime as determined by localtime(3) when the formatter launches.  This initialization  can  be\noverridden by SOURCEDATEEPOCH and TZ; see section “Environment” of groff(1).\n\n\\n[$$]         Process ID of troff.\n\\n[%]          Page number.\n\\n[c.]         Input line number.\n\\n[ct]         Union of character types of each glyph rendered into dummy environment by \\w.\n\\n[dl]         Width of last closed diversion.\n\\n[dn]         Height of last closed diversion.\n\\n[dw]         Day of the week (1–7; 1 is Sunday).\n\\n[dy]         Day of the month (1–31).\n\\n[hours]      Count of hours elapsed since midnight (0–23).\n\\n[hp]         Horizontal drawing position relative to start of input line.\n\\n[llx]        Lower-left x coordinate (in PostScript units) of PostScript image; see .psbb.\n\\n[lly]        Lower-left y coordinate (in PostScript units) of PostScript image; see .psbb.\n\\n[ln]         Output line number; see .nm.\n\\n[lsn]        Count of leading spaces on input line.\n\\n[lss]        Amount of horizontal space corresponding to leading spaces on input line.\n\\n[minutes]    Count of minutes elapsed in the hour (0–59).\n\\n[mo]         Month of the year (1–12).\n\\n[nl]         Vertical drawing position.\n\\n[opmaxx]\n\\n[opmaxy]\n\\n[opminx]\n\\n[opminy]     These  four  registers  mark  the top left- and bottom right-hand corners of a\nrectangle encompassing all formatted output on the page.  They are reset to -1\nby \\O0 or \\O1.\n\\n[rsb]        As register sb, adding maximum glyph height to measurement.\n\\n[rst]        As register st, adding maximum glyph depth to measurement.\n\\n[sb]         Maximum displacement of text baseline below its original position  after  ren‐\ndering into dummy environment by \\w.\n\\n[seconds]    Count of seconds elapsed in the minute (0–60).\n\\n[skw]        Skew of last glyph rendered into dummy environment by \\w.\n\\n[slimit]     The  maximum depth of troff's internal input stack.  If ≤0, there is no limit:\nrecursion can continue until available memory is exhausted.   The  default  is\n1,000.\n\\n[ssc]        Subscript correction of last glyph rendered into dummy environment by \\w.\n\\n[st]         Maximum  displacement  of text baseline above its original position after ren‐\ndering into dummy environment by \\w.\n\\n[systat]     Return value of system() function; see .sy.\n\\n[urx]        Upper-right x coordinate (in PostScript units) of PostScript image; see .psbb.\n\\n[ury]        Upper-right y coordinate (in PostScript units) of PostScript image; see .psbb.\n\\n[year]       Gregorian year.\n\\n[yr]         Gregorian year minus 1900.\n"
                }
            ]
        },
        "Using fonts": {
            "content": "In digital typography, a font is a collection of characters in a specific typeface that a de‐\nvice can render as glyphs at a desired size.  (Terminals and some output devices  have  fonts\nthat render at only one or two sizes.  As examples of the latter, take the groff lj4 device's\nLineprinter,  and  lbp's  Courier and Elite faces.)  A roff formatter can change typefaces at\nany point in the text.  The basic faces are a set of styles  combining  upright  and  slanted\nshapes  with  normal and heavy stroke weights: “R”, “I”, “B”, and “BI”—these stand for roman,\nbold, italic, and bold-italic.  For linguistic text, GNU troff groups typefaces into families\ncontaining each of these styles.  (Font designers prepare families such that the styles share\nesthetic properties.)  A text font is thus often a family combined with a style, but it  need\nnot  be:  consider the ps and pdf devices' ZCMI (Zapf Chancery Medium italic)—often, no other\nstyle of Zapf Chancery Medium is provided.  On typesetting devices, at least one special font\nis available, comprising unstyled glyphs for mathematical operators and other purposes.\n\nLike AT&T troff, GNU troff does not itself load or manipulate a digital font file; instead it\nworks with a font description file that characterizes it, including its glyph repertoire  and\nthe metrics (dimensions) of each glyph.  This information permits the formatter to accurately\nplace  glyphs with respect to each other.  Before using a font description, the formatter as‐\nsociates it with a mounting position, a place in an ordered list of available typefaces.   So\nthat  a document need not be strongly coupled to a specific font family, in GNU troff an out‐\nput device can associate a style in the abstract sense with a mounting  position.   Thus  the\ndefault family can be combined with a style dynamically, producing a resolved font name.\n\nFonts  often  have  trademarked names, and even Free Software fonts can require renaming upon\nmodification.  groff maintains a convention that a device's serif font family  is  given  the\nname  T  (“Times”),  its  sans-serif  family  H  (“Helvetica”),  and  its monospaced family C\n(“Courier”).  Historical inertia has driven groff's font identifiers to short  uppercase  ab‐\nbreviations of font names, as with TR, TB, TI, TBI, and a special font S.\n\nThe  default family used with abstract styles can be changed at any time; initially, it is T.\nTypically, abstract styles are arranged in the first four mounting  positions  in  the  order\nshown  above.  The default mounting position, and therefore style, is always 1 (R).  By issu‐\ning appropriate formatter instructions, you can override these defaults before your  document\nwrites its first glyph.\n\nTerminal  output  devices  cannot  change font families and lack special fonts.  They support\nstyle changes by overstriking, or by altering ISO 6429/ECMA-48 graphic renditions  (character\ncell attributes).\n",
            "subsections": []
        },
        "Hyphenation": {
            "content": "When filling, groff hyphenates words as needed at user-specified and automatically determined\nhyphenation  points.  Explicitly hyphenated words such as “mother-in-law” are always eligible\nfor breaking after each of their hyphens.  The  hyphenation  character  \\%  and  non-printing\nbreak  point \\: escape sequences may be used to control the hyphenation and breaking of indi‐\nvidual words.  The .hw request sets user-defined hyphenation points for  specified  words  at\nany  subsequent  occurrence.  Otherwise, groff determines hyphenation points automatically by\ndefault.\n\nSeveral requests influence automatic hyphenation.  Because conventions vary, a variety of hy‐\nphenation modes is available to the .hy request; these determine whether hyphenation will ap‐\nply to a word prior to breaking a line at the end of a page (more or less; see below for  de‐\ntails),  and  at which positions within that word automatically determined hyphenation points\nare permissible.  The default is “1” for historical reasons, but this is not  an  appropriate\nvalue  for the English hyphenation patterns used by groff; localization macro files loaded by\ntroffrc and macro packages often override it.\n\n0      disables hyphenation.\n\n1      enables hyphenation except after the first and before the last character of a word.\n\nThe remaining values “imply” 1; that is, they enable hyphenation under the same conditions as\n“.hy 1”, and then apply or lift restrictions relative to that basis.\n\n2      disables hyphenation of the last word on a page.  (Hyphenation  is  prevented  if  the\nnext  page location trap is closer to the vertical drawing position than the next text\nbaseline would be.  See section “Traps” below.)\n\n4      disables hyphenation before the last two characters of a word.\n\n8      disables hyphenation after the first two characters of a word.\n\n16     enables hyphenation before the last character of a word.\n\n32     enables hyphenation after the first character of a word.\n\nApart from value 2, restrictions imposed by the hyphenation mode are not respected for  words\nwhose  hyphenations  have  been specified with the hyphenation character (“\\%” by default) or\nthe .hw request.\n\nNonzero values are additive.  For example, mode 12 causes groff to hyphenate neither the last\ntwo nor the first two characters of a word.  Some values cannot be used together because they\ncontradict; for instance, values 4 and 16, and values 8 and 32.  As noted, it is  superfluous\nto add 1 to any non-zero even mode.\n\nThe  places  within  a word that are eligible for hyphenation are determined by language-spe‐\ncific data (.hla, .hpf, and .hpfa) and lettercase relationships (.hcode and .hpfcode).   Fur‐\nthermore,  hyphenation of a word might be suppressed due to a limit on consecutive hyphenated\nlines (.hlm), a minimum line length threshold (.hym), or because the line can instead be  ad‐\njusted with additional inter-word space (.hys).\n",
            "subsections": []
        },
        "Localization": {
            "content": "The  set  of hyphenation patterns is associated with the hyphenation language set by the .hla\nrequest.  The .hpf request is usually invoked by a localization file loaded  by  the  troffrc\nfile.  groff provides localization files for several languages; see grofftmac(5).\n",
            "subsections": []
        },
        "Writing macros": {
            "content": "The  .de  request  defines a macro named for its argument.  If that name already exists as an\nalias, the target of the alias is redefined; see section “Strings” above.  troff enters “copy\nmode” (see below), storing subsequent input lines as the definition.  If the optional  second\nargument is not specified, the definition ends with the control line “..” (two dots).  Alter‐\nnatively,  a  second  argument names a macro whose call syntax ends the definition; this “end\nmacro” is then called normally.  Spaces or tabs are permitted after the first control charac‐\nter in the line containing this ending token, but a tab immediately after the token  prevents\nits  recognition  as  the end of a macro definition.  Macro definitions can be nested if they\nuse distinct end macros or if their ending tokens are sufficiently  escaped.   An  end  macro\nneed not be defined until it is called.  This fact enables a nested macro definition to begin\ninside one macro and end inside another.\n\nVariants  of .de disable compatibility mode and/or indirect the names of the macros specified\nfor definition or termination: these are .de1, .dei, and .dei1.  Append to macro  definitions\nwith .am, .am1, .ami, and .ami1.  The .als, .rm, and .rn requests create an alias of, remove,\nand  rename  a  macro, respectively.  .return stops the execution of a macro immediately, re‐\nturning to the enclosing context.\n",
            "subsections": [
                {
                    "name": "Parameters",
                    "content": "Macro call and string interpolation parameters can be accessed using escape sequences  start‐\ning  with  “\\$”.  The \\n[.$] read-only register stores the count of parameters available to a\nmacro or string; its value can be changed by the .shift request,  which  dequeues  parameters\nfrom  the  current  list.  The \\$0 escape sequence interpolates the name by which a macro was\ncalled.  Applying string interpolation to a macro does not change this name.\n"
                },
                {
                    "name": "Copy mode",
                    "content": "When troff processes certain requests, most importantly those which define  or  append  to  a\nmacro  or  string, it does so in copy mode: it copies the characters of the definition into a\ndedicated storage region, interpolating the escape sequences \\n, \\g, \\$, \\*, \\V, and \\?  nor‐\nmally;  interpreting  \\newline  immediately; discarding comments \\\" and \\#; interpolating the\ncurrent leader, escape, or tab character with \\a, \\e, and \\t, respectively; and  storing  all\nother  escape  sequences  in an encoded form.  The complement of copy mode—a roff formatter's\nbehavior when not defining or appending to a macro, string, or diversion—where all macros are\ninterpolated, requests invoked, and valid escape sequences processed immediately upon  recog‐\nnition, can be termed interpretation mode.\n\nThe escape character, \\ by default, can escape itself.  This enables you to control whether a\ngiven \\n, \\g, \\$, \\*, \\V, or \\? escape sequence is interpreted at the time the macro contain‐\ning it is defined, or later when the macro is called.\n\nYou  can think of \\\\ as a “delayed” backslash; it is the escape character followed by a back‐\nslash from which the escape character has removed its special meaning.  Consequently,  \\\\  is\nnot  an  escape  sequence  in the usual sense.  In any escape sequence \\X that troff does not\nrecognize, the escape character is ignored and X is output.  An unrecognized escape  sequence\ncauses  a  warning in category “escape”, with two exceptions, \\\\ being one.  The other is \\.,\nwhich escapes the control character.  It is used to permit nested macro  definitions  to  end\nwithout a named macro call to conclude them.  Without a syntax for escaping the control char‐\nacter,  this would not be possible.  roff documents should not use the \\\\ or \\. character se‐\nquences outside of copy mode; they serve only to obfuscate the input.  Use  \\e  to  represent\nthe  escape  character,  \\[rs] to obtain a backslash glyph, and \\& before . and ' where troff\nexpects them as control characters if you mean to use them literally.\n\nMacro definitions can be nested to arbitrary depth.  In “\\\\”, each escape character is inter‐\npreted twice—once in copy mode, when the macro is defined, and once in  interpretation  mode,\nwhen  the  macro  is called.  This fact leads to exponential growth in the quantity of escape\ncharacters required to delay interpolation of \\n, \\g, \\$, \\*, \\V,  and  \\?  at  each  nesting\nlevel.   An alternative is to use \\E, which represents an escape character that is not inter‐\npreted in copy mode.  Because \\. is not a true escape sequence, we can't use \\E to keep  “..”\nfrom  ending  a macro definition prematurely.  If the multiplicity of backslashes complicates\nmaintenance, use end macros.\n"
                }
            ]
        },
        "Traps": {
            "content": "Traps are locations in the output, or conditions on the input  that,  when  reached  or  ful‐\nfilled,  call a specified macro.  A vertical position trap calls a macro when the formatter's\nvertical drawing position reaches or passes, in the downward direction, a certain location on\nthe output page or in a diversion.  Its applications include setting page headers  and  foot‐\ners, body text in multiple columns, and footnotes.  These traps can occur at a given location\non  the  page  (.wh, .ch); at a given location in the current diversion (.dt)—together, these\nare known as vertical position traps, which can be disabled and re-enabled (.vpt).\n\nA diversion is not formatted in the context of a page, so it lacks page location  traps;  in‐\nstead  it can have a diversion trap.  There can exist at most one such vertical position trap\nper diversion.\n\nOther kinds of trap can be planted at a blank line (.blm); at a line with leading space char‐\nacters (.lsm); after a certain number of productive input lines (.it, .itc); or at the end of\ninput (.em).  Macros called by traps are passed no arguments.  Setting a trap is also  called\nplanting one.  It is said that a trap is sprung if its condition is fulfilled.\n\nRegisters  associated  with  trap management include vertical position trap enablement status\n(\\n[.vpt]), distance to the next trap (\\n[.t]), amount of needed (.ne-requested)  space  that\ncaused  the most recent vertical position trap to be sprung (\\n[.ne]), amount of needed space\ntruncated from the amount requested (\\n[.trunc]), page ejection status (\\n[.pe]), and leading\nspace count (\\n[.lsn]) with its corresponding amount of motion (\\n[.lss]).\n",
            "subsections": [
                {
                    "name": "Page location traps",
                    "content": "A page location trap is a vertical position trap that applies to the page; that is, to  undi‐\nverted  output.   Many can be present; manage them with the wh and ch requests.  Non-negative\npage locations given to these requests set the trap relative to the top of the page; negative\nvalues set the trap relative to the bottom of the page.  It is not possible to plant  a  trap\nless  than one basic unit from the page bottom: a location of “-0” is interpreted as “0”, the\ntop of the page.  An existing visible trap (see below) at the same location is removed;  this\nis .wh's sole function if its second argument is missing.\n\nA  trap  is  sprung only if it is visible, meaning that its location is reachable on the page\nand it is not hidden by another trap at the same location already  planted  there.   (A  trap\nplanted at “20i” or “-30i” will not be sprung on a page of length “11i”.)\n\nA trap above the top or at or below the bottom of the page can be made visible by either mov‐\ning  it  into  the  page  area or increasing the page length so that the trap is on the page.\nNegative trap values always use the current page length; they are not  converted  to  an  ab‐\nsolute vertical position.  Use .ptr to dump page location traps to the standard error stream;\ntheir positions are reported in basic units.\n"
                },
                {
                    "name": "The implicit page trap",
                    "content": "An  implicit page trap always exists in the top-level diversion; it works like a trap in some\nways but not others.  Its purpose is to eject the current page and start the  next  one.   It\nhas  no name, so it cannot be moved or deleted with wh or ch requests.  You cannot hide it by\nplacing another trap at its location, and can move it only by redefining the page length with\n.pl.  Its operation is suppressed when vertical page traps are disabled with the vpt request.\n"
                }
            ]
        },
        "Diversions": {
            "content": "In roff systems it is possible to format text as if for output, but instead of writing it im‐\nmediately, one can divert the formatted text into a named  storage  area.   It  is  retrieved\nlater by specifying its name after a control character.  The same name space is used for such\ndiversions  as  for  strings and macros; see section “Identifiers” above.  Such text is some‐\ntimes said to be “stored in a macro”, but this coinage obscures the important distinction be‐\ntween macros and strings on one hand and diversions on the other; the former store  unformat‐\nted  input  text,  and the latter capture formatted output.  Diversions also do not interpret\narguments.  Applications of diversions include “keeps” (preventing a page break  from  occur‐\nring  at  an inconvenient place by forcing a set of output lines to be set as a group), foot‐\nnotes, tables of contents, and indices.  For orthogonality it is said that GNU  troff  is  in\nthe  top-level  diversion  if no diversion is active (that is, formatted output is being “di‐\nverted” immediately to the output device.\n\nDereferencing an undefined diversion will create an empty one of that name and cause a  warn‐\ning  in  category mac to be emitted.  (see section “Warnings” in troff(1)).  A diversion does\nnot exist for the purpose of testing with the d conditional operator until its initial defin‐\nition ends (see subsection “Conditional expressions” above).\n\nThe di request creates a diversion, including any partially collected line.  da appends to  a\ndiversion, creating one if it does not already exist.  If the diversion's name already exists\nas an alias, the target of the alias is replaced or appended to; see section “Strings” above.\nbox and boxa works similarly, but ignore partially collected lines.  Call any of these macros\nagain without an argument to end the diversion.\n\nDiversions can be nested.  The registers .d, .z, dn, and dl report information about the cur‐\nrent (or last closed) diversion.  .h is meaningful in diversions, including the top level.\n\nThe \\!  and \\?  escape sequences and output request escape from a diversion, the first two to\nthe  enclosing  level and the last to the top level.  This facility is termed transparent em‐\nbedding.\n\nThe asciify and unformat requests reprocess diversions.\n",
            "subsections": []
        },
        "Punning names": {
            "content": "Macros, strings, and diversions share a name space; see section “Identifiers” above.   Inter‐\nnally,  the  same mechanism is used to store them.  You can thus call a macro with string in‐\nterpolation syntax and vice versa.  Interpolating a string does not hide existing macro argu‐\nments.  The sequence \\\\ can be placed at the end of a line in a macro definition or, within a\nmacro definition, immediately after the interpolation of a macro as a string to suppress  the\neffect of a newline.\n",
            "subsections": []
        },
        "Environments": {
            "content": "Environments  store  most of the parameters that control text processing.  A default environ‐\nment named “0” exists when troff starts up; it is modified by formatting-related requests and\nescape sequences.\n\nYou can create new environments and switch among them.  Only one  is  current  at  any  given\ntime.   Active environments are managed using a stack, a data structure supporting “push” and\n“pop” operations.  The current environment is at the top of the stack.  The same  environment\nname  can be pushed onto the stack multiple times, possibly interleaved with others.  Popping\nthe environment stack does not destroy the current environment; it remains accessible by name\nand can be made current again by pushing it at any time.  Environments cannot be  renamed  or\ndeleted,  and  can  only be modified when current.  To inspect the environment stack, use the\npev request; see section “Debugging” below.\n\nEnvironments store the following information.\n\n• a partially collected line, if any\n\n• data about the most recently output glyph and line (registers .cdp, .cht, .csk, .n, .w)\n\n• typeface parameters (size, family, style, height and slant, inter-word  and  inter-sentence\nspace sizes)\n\n• page  parameters  (line  length, title length, vertical spacing, line spacing, indentation,\nline numbering, centering, right-alignment, underlining, hyphenation parameters)\n\n• filling enablement; adjustment enablement and mode\n\n• tab stops; tab, leader, escape, control, no-break control, hyphenation, and margin  charac‐\nters\n\n• input line traps\n\n• stroke and fill colors\n\nThe  ev request pushes to and pops from the environment stack, while evc copies a named envi‐\nronment's contents to the current one.\n",
            "subsections": []
        },
        "Underlining": {
            "content": "In RUNOFF (see roff(7)), underlining, even of lengthy passages, was  straightforward  because\nonly  fixed-pitch  printing  devices  were targeted.  Typesetter output posed a greater chal‐\nlenge.  There exists a groff request .ul (see above) that underlines subsequent source  lines\non  terminal  devices,  but  on typesetters, it selects an italic font style instead.  The ms\nmacro package (see groffms(7)) offers a macro .UL, but it too produces  the  desired  effect\nonly on typesetters, and has other limitations.\n\nOne could adapt ms's approach to the construction of a macro as follows.\n.de UNDERLINE\n. ie n \\\\$1\\f[I]\\\\$2\\f[P]\\\\$3\n. el \\\\$1\\Z'\\\\$2'\\v'.25m'\\D'l \\w'\\\\$2'u 0'\\v'-.25m'\\\\$3\n..\nIf  doclifter(1) makes trouble, change the macro name UNDERLINE into some 2-letter word, like\nUl.  Moreover, change the form of the font selection escape sequence from \\f[P] to \\fP.\n",
            "subsections": [
                {
                    "name": "Underlining without macro definitions",
                    "content": "If one does not want to use macro definitions, e.g., when doclifter gets lost, use  the  fol‐\nlowing.\n.ds u1 before\n.ds u2 in\n.ds u3 after\n.ie n \\*[u1]\\f[I]\\*[u2]\\f[P]\\*[u3]\n.el \\*[u1]\\Z'\\*[u2]'\\v'.25m'\\D'l \\w'\\*[u2]'u 0'\\v'-.25m'\\*[u3]\nWhen  using  doclifter, it might be necessary to change syntax forms such as \\[xy] and \\*[xy]\nto those supported by AT&T troff: \\*(xy and \\(xy, and so on.\n\nThen these lines could look like\n.ds u1 before\n.ds u2 in\n.ds u3 after\n.ie n \\*[u1]\\fI\\*(u2\\fP\\*(u3\n.el \\*(u1\\Z'\\*(u2'\\v'.25m'\\D'l \\w'\\*(u2'u 0'\\v'-.25m'\\*(u3\n\nThe result looks like\nbefore in after\n"
                },
                {
                    "name": "Underlining by overstriking with \\(ul",
                    "content": "The \\z escape sequence writes a glyph without advancing the drawing position, enabling  over‐\nstriking.  Thus, \\zc\\(ul formats c with an underrule glyph on top of it.  Video terminals im‐\nplement  the  underrule  by setting a character cell's underline attribute, so this technique\nworks in both nroff and troff modes.\n\nLong words may then look intimidating in the input; a clarifying approach might be to use the\ninput line continuation escape sequence \\newline to place each underlined  character  on  its\nown input line.  Thus,\n.nf\n\\&\\fB: ${\\fIvar\\fR\\c\n\\zo\\(ul\\\n\\zp\\(ul\\c\n\\&\\fIvalue\\fB}\n.fi\nproduces\n: ${varvalue}\nas output.\n"
                }
            ]
        },
        "Compatibility mode": {
            "content": "The  differences between the roff language recognized by GNU troff and that of AT&T troff, as\nwell as the device, font, and device-independent intermediate  output  formats  described  by\nCSTR  #54  are  documented in groffdiff(7).  groff provides an AT&T compatibility mode.  The\n.cp request and registers .C and .cp set and test the enablement of this mode.\n",
            "subsections": []
        },
        "Debugging": {
            "content": "Preprocessors use the .lf request to preserve the identities of line numbers and names of in‐\nput files.  groff emits a variety of error diagnostics and  supports  several  categories  of\nwarning;  the  output  of these can be selectively suppressed with .warn (and see the -E, -w,\nand -W options of troff(1)).  A trace of the formatter's input processing stack can be  emit‐\nted  when  errors  or  warnings occur by means of troff(1)'s -b option, or produced on demand\nwith the .backtrace request.  .tm, .tmc, and .tm1 can be used to emit  customized  diagnostic\nmessages  or  for instrumentation while troubleshooting.  .ex and .ab cause early termination\nwith successful and error exit codes respectively, to halt further processing when continuing\nwould be fruitless.  Examine the state of the formatter with requests that write lists of de‐\nfined names—macros, strings, and diversions—(.pm); environments (.pev), registers (.pnr), and\npage location traps (.ptr) to the standard error stream.\n",
            "subsections": []
        },
        "Authors": {
            "content": "This document was written by by Trent A. Fisher,  Werner  Lemberg,  and  G. Branden Robinson.\nSection “Underlining” was primarily written by Bernd Warken.\n\nSee also\nGroff: The GNU Implementation of troff, by Trent A. Fisher and Werner Lemberg, is the primary\ngroff manual.  You can browse it interactively with “info groff”.\n\n“Troff  User's Manual” by Joseph F. Ossanna, 1976 (revised by Brian W. Kernighan, 1992), AT&T\nBell Laboratories Computing Science Technical Report No. 54, widely called simply “CSTR #54”,\ndocuments the language, device and font description file formats, and device-independent out‐\nput format referred to collectively in groff documentation as “AT&T troff”.\n\n“A Typesetter-independent TROFF” by Brian W. Kernighan, 1982, AT&T Bell Laboratories  Comput‐\ning  Science Technical Report No. 97 (CSTR #97), provides additional insights into the device\nand font description file formats and device-independent output format.\n\ngroff(1)\nis the preferred interface to the groff system; it manages the pipeline that carries a\nsource document through preprocessors, the troff formatter, and an  output  driver  to\nviewable  or  printable  form.  It also exhaustively lists the man pages provided with\nthe GNU roff system.\n\ngroffchar(7)\ndiscusses character encoding issues, escape sequences that produce glyphs, and enumer‐\nates groff's predefined special character escape sequences.\n\ngroffdiff(7)\ncovers differences between the GNU troff formatter, its device  and  font  description\nfile formats, its device-independent output format, and those of AT&T troff, whose de‐\nsign it reimplements.\n\ngrofffont(5)\ndescribes the formats of the files that describe devices (DESC) and fonts.\n\ngrofftmac(5)\nsurveys macro packages provided with groff, describes how documents can take advantage\nof  them, offers guidance on writing macro packages and using diversions, and includes\nhistorical information on macro package naming conventions.\n\nroff(7)\npresents a detailed history of roff systems and summarizes concepts common to them.\n\ngroff 1.23.0                                31 March 2024                                   groff(7)",
            "subsections": []
        }
    },
    "flags": [],
    "examples": [],
    "see_also": []
}