contrib/groff/doc/groff-11

   1 This is groff, produced by makeinfo version 4.2 from ./groff.texinfo.
   2
   3 This manual documents GNU `troff' version 1.18.
   4
   5    Copyright (C) 1994-2000, 2001, 2002 Free Software Foundation, Inc.
   6
   7      Permission is granted to copy, distribute and/or modify this
   8      document under the terms of the GNU Free Documentation License,
   9      Version 1.1 or any later version published by the Free Software
  10      Foundation; with no Invariant Sections, with the Front-Cover texts
  11      being `A GNU Manual," and with the Back-Cover Texts as in (a)
  12      below.  A copy of the license is included in the section entitled
  13      `GNU Free Documentation License."
  14
  15      (a) The FSF's Back-Cover Text is: `You have freedom to copy and
  16      modify this GNU Manual, like GNU software.  Copies published by
  17      the Free Software Foundation raise funds for GNU development."
  18
  19 INFO-DIR-SECTION Miscellaneous
  20 START-INFO-DIR-ENTRY
  21 * Groff: (groff).               The GNU troff document formatting system.
  22 END-INFO-DIR-ENTRY
  23
  24 \1f
  25 File: groff,  Node: Concept Index,  Prev: Program and File Index,  Up: Top
  26
  27 Concept Index
  28 *************
  29
  30 * Menu:
  31
  32 * ", at end of sentence <1>:             Using Symbols.
  33 * ", at end of sentence:                 Sentences.
  34 * ", in a macro argument:                Request Arguments.
  35 * %, as delimiter:                       Escapes.
  36 * &, as delimiter:                       Escapes.
  37 * ', as a comment:                       Comments.
  38 * ', at end of sentence <1>:             Using Symbols.
  39 * ', at end of sentence:                 Sentences.
  40 * ', delimiting arguments:               Escapes.
  41 * (, as delimiter:                       Escapes.
  42 * (, starting a two-character identifier <1>: Escapes.
  43 * (, starting a two-character identifier: Identifiers.
  44 * ), as delimiter:                       Escapes.
  45 * ), at end of sentence <1>:             Using Symbols.
  46 * ), at end of sentence:                 Sentences.
  47 * *, as delimiter:                       Escapes.
  48 * *, at end of sentence <1>:             Using Symbols.
  49 * *, at end of sentence:                 Sentences.
  50 * +, and page motion:                    Expressions.
  51 * +, as delimiter:                       Escapes.
  52 * -, and page motion:                    Expressions.
  53 * -, as delimiter:                       Escapes.
  54 * ., as delimiter:                       Escapes.
  55 * .h register, difference to nl:         Diversions.
  56 * .ps register, in comparison with .psr: Fractional Type Sizes.
  57 * .s register, in comparison with .sr:   Fractional Type Sizes.
  58 * .S register, Plan 9 alias for .tabs:   Tabs and Fields.
  59 * .t register, and diversions:           Diversion Traps.
  60 * .tabs register, Plan 9 alias (.S):     Tabs and Fields.
  61 * .V register, and vs:                   Changing Type Sizes.
  62 * /, as delimiter:                       Escapes.
  63 * 8-bit input:                           Font File Format.
  64 * <, as delimiter:                       Escapes.
  65 * <colon>, as delimiter:                 Escapes.
  66 * =, as delimiter:                       Escapes.
  67 * >, as delimiter:                       Escapes.
  68 * [, macro names starting with, and refer: Identifiers.
  69 * [, starting an identifier <1>:         Escapes.
  70 * [, starting an identifier:             Identifiers.
  71 * \!, and output:                        Diversions.
  72 * \!, and trnt:                          Character Translations.
  73 * \!, in top-level diversion:            Diversions.
  74 * \!, incompatibilities with AT&T troff: Implementation Differences.
  75 * \!, used as delimiter:                 Escapes.
  76 * \$, when reading text for a macro:     Copy-in Mode.
  77 * \%, and translations:                  Character Translations.
  78 * \%, following \X or \Y:                Manipulating Hyphenation.
  79 * \%, in \X:                             Postprocessor Access.
  80 * \%, incompatibilities with AT&T troff: Implementation Differences.
  81 * \%, used as delimiter:                 Escapes.
  82 * \&, and glyph definitions:             Using Symbols.
  83 * \&, and translations:                  Character Translations.
  84 * \&, at end of sentence:                Sentences.
  85 * \&, escaping control characters:       Requests.
  86 * \&, in \X:                             Postprocessor Access.
  87 * \&, incompatibilities with AT&T troff: Implementation Differences.
  88 * \&, used as delimiter:                 Escapes.
  89 * \', and translations:                  Character Translations.
  90 * \', incompatibilities with AT&T troff: Implementation Differences.
  91 * \', used as delimiter:                 Escapes.
  92 * \(, and translations:                  Character Translations.
  93 * \), in \X:                             Postprocessor Access.
  94 * \), used as delimiter:                 Escapes.
  95 * \*, and warnings:                      Warnings.
  96 * \*, incompatibilities with AT&T troff: Implementation Differences.
  97 * \*, when reading text for a macro:     Copy-in Mode.
  98 * \, disabling (eo):                     Character Translations.
  99 * \,, used as delimiter:                 Escapes.
 100 * \-, and translations:                  Character Translations.
 101 * \-, incompatibilities with AT&T troff: Implementation Differences.
 102 * \-, used as delimiter:                 Escapes.
 103 * \/, used as delimiter:                 Escapes.
 104 * \0, used as delimiter:                 Escapes.
 105 * \<colon>, in \X:                       Postprocessor Access.
 106 * \<colon>, used as delimiter:           Escapes.
 107 * \<RET>, when reading text for a macro: Copy-in Mode.
 108 * \<SP>, difference to \~:               Request Arguments.
 109 * \<SP>, incompatibilities with AT&T troff: Implementation Differences.
 110 * \<SP>, used as delimiter:              Escapes.
 111 * \?, in top-level diversion:            Diversions.
 112 * \?, incompatibilities with AT&T troff: Implementation Differences.
 113 * \?, used as delimiter:                 Escapes.
 114 * \@, used as delimiter:                 Escapes.
 115 * \[, and translations:                  Character Translations.
 116 * \\, when reading text for a macro:     Copy-in Mode.
 117 * \^, incompatibilities with AT&T troff: Implementation Differences.
 118 * \^, used as delimiter:                 Escapes.
 119 * \_, and translations:                  Character Translations.
 120 * \_, incompatibilities with AT&T troff: Implementation Differences.
 121 * \_, used as delimiter:                 Escapes.
 122 * \`, and translations:                  Character Translations.
 123 * \`, incompatibilities with AT&T troff: Implementation Differences.
 124 * \`, used as delimiter:                 Escapes.
 125 * \A, allowed delimiters:                Escapes.
 126 * \a, and translations:                  Character Translations.
 127 * \A, incompatibilities with AT&T troff: Implementation Differences.
 128 * \a, used as delimiter:                 Escapes.
 129 * \B, allowed delimiters:                Escapes.
 130 * \b, limitations:                       Drawing Requests.
 131 * \b, possible quote characters:         Escapes.
 132 * \C, allowed delimiters:                Escapes.
 133 * \c, and fill mode:                     Line Control.
 134 * \c, and no-fill mode:                  Line Control.
 135 * \C, and translations:                  Character Translations.
 136 * \c, incompatibilities with AT&T troff: Implementation Differences.
 137 * \c, used as delimiter:                 Escapes.
 138 * \D, allowed delimiters:                Escapes.
 139 * \d, used as delimiter:                 Escapes.
 140 * \e, and glyph definitions:             Using Symbols.
 141 * \e, and translations:                  Character Translations.
 142 * \e, incompatibilities with AT&T troff: Implementation Differences.
 143 * \e, used as delimiter:                 Escapes.
 144 * \E, used as delimiter:                 Escapes.
 145 * \e, used as delimiter:                 Escapes.
 146 * \F, and changing fonts:                Changing Fonts.
 147 * \F, and font positions:                Font Positions.
 148 * \f, and font translations:             Changing Fonts.
 149 * \f, incompatibilities with AT&T troff: Implementation Differences.
 150 * \H, allowed delimiters:                Escapes.
 151 * \h, allowed delimiters:                Escapes.
 152 * \H, incompatibilities with AT&T troff: Implementation Differences.
 153 * \H, using + and -:                     Expressions.
 154 * \H, with fractional type sizes:        Fractional Type Sizes.
 155 * \L, allowed delimiters:                Escapes.
 156 * \l, allowed delimiters:                Escapes.
 157 * \L, and glyph definitions:             Using Symbols.
 158 * \l, and glyph definitions:             Using Symbols.
 159 * \N, allowed delimiters:                Escapes.
 160 * \N, and translations:                  Character Translations.
 161 * \n, and warnings:                      Warnings.
 162 * \n, incompatibilities with AT&T troff: Implementation Differences.
 163 * \n, when reading text for a macro:     Copy-in Mode.
 164 * \o, possible quote characters:         Escapes.
 165 * \p, used as delimiter:                 Escapes.
 166 * \R, after \c:                          Line Control.
 167 * \R, allowed delimiters:                Escapes.
 168 * \R, and warnings:                      Warnings.
 169 * \R, difference to nr:                  Auto-increment.
 170 * \r, used as delimiter:                 Escapes.
 171 * \R, using + and -:                     Expressions.
 172 * \S, allowed delimiters:                Escapes.
 173 * \s, allowed delimiters:                Escapes.
 174 * \S, incompatibilities with AT&T troff: Implementation Differences.
 175 * \s, incompatibilities with AT&T troff: Implementation Differences.
 176 * \s, using + and -:                     Expressions.
 177 * \s, with fractional type sizes:        Fractional Type Sizes.
 178 * \t, and translations:                  Character Translations.
 179 * \t, and warnings:                      Warnings.
 180 * \t, used as delimiter:                 Escapes.
 181 * \u, used as delimiter:                 Escapes.
 182 * \v, allowed delimiters:                Escapes.
 183 * \v, internal representation:           Gtroff Internals.
 184 * \w, allowed delimiters:                Escapes.
 185 * \x, allowed delimiters:                Escapes.
 186 * \X, and special characters:            Postprocessor Access.
 187 * \X, followed by \%:                    Manipulating Hyphenation.
 188 * \X, possible quote characters:         Escapes.
 189 * \Y, followed by \%:                    Manipulating Hyphenation.
 190 * \Z, allowed delimiters:                Escapes.
 191 * \{, incompatibilities with AT&T troff: Implementation Differences.
 192 * \{, used as delimiter:                 Escapes.
 193 * \|, incompatibilities with AT&T troff: Implementation Differences.
 194 * \|, used as delimiter:                 Escapes.
 195 * \}, and warnings:                      Warnings.
 196 * \}, incompatibilities with AT&T troff: Implementation Differences.
 197 * \}, used as delimiter:                 Escapes.
 198 * \~, and translations:                  Character Translations.
 199 * \~, difference to \<SP>:               Request Arguments.
 200 * \~, used as delimiter:                 Escapes.
 201 * ], as part of an identifier:           Identifiers.
 202 * ], at end of sentence <1>:             Using Symbols.
 203 * ], at end of sentence:                 Sentences.
 204 * ], ending an identifier <1>:           Escapes.
 205 * ], ending an identifier:               Identifiers.
 206 * ], macro names starting with, and refer: Identifiers.
 207 * aborting (ab):                         Debugging.
 208 * absolute position operator (|):        Expressions.
 209 * accent marks [ms]:                     ms Strings and Special Characters.
 210 * access of postprocessor:               Postprocessor Access.
 211 * accessing unnamed glyphs with \N:      Font File Format.
 212 * activating kerning (kern):             Ligatures and Kerning.
 213 * activating ligatures (lg):             Ligatures and Kerning.
 214 * activating track kerning (tkf):        Ligatures and Kerning.
 215 * ad request, and hyphenation margin:    Manipulating Hyphenation.
 216 * ad request, and hyphenation space:     Manipulating Hyphenation.
 217 * adjusting:                             Filling and Adjusting.
 218 * adjusting and filling, manipulating:   Manipulating Filling and Adjusting.
 219 * adjustment mode register (.j):         Manipulating Filling and Adjusting.
 220 * alias, diversion, creating (als):      Strings.
 221 * alias, macro, creating (als):          Strings.
 222 * alias, number register, creating (aln): Setting Registers.
 223 * alias, string, creating (als):         Strings.
 224 * als request, and \$0:                  Parameters.
 225 * am, am1, ami requests, and warnings:   Warnings.
 226 * annotations:                           Footnotes and Annotations.
 227 * appending to a diversion (da):         Diversions.
 228 * appending to a file (opena):           I/O.
 229 * appending to a macro (am):             Writing Macros.
 230 * appending to a string (as):            Strings.
 231 * arc, drawing (\D'a ...'):              Drawing Requests.
 232 * argument delimiting characters:        Escapes.
 233 * arguments to requests:                 Request Arguments.
 234 * arguments, macro (\$):                 Parameters.
 235 * arguments, of strings:                 Strings.
 236 * arithmetic operators:                  Expressions.
 237 * artificial fonts:                      Artificial Fonts.
 238 * as, as1 requests, and comments:        Comments.
 239 * as, as1 requests, and warnings:        Warnings.
 240 * ASCII approximation output register (.A) <1>: Built-in Registers.
 241 * ASCII approximation output register (.A): Groff Options.
 242 * ASCII, encoding:                       Groff Options.
 243 * asciify request, and writem:           I/O.
 244 * assigning formats (af):                Assigning Formats.
 245 * assignments, indirect:                 Interpolating Registers.
 246 * assignments, nested:                   Interpolating Registers.
 247 * AT&T troff, ms macro package differences: Differences from AT&T ms.
 248 * auto-increment:                        Auto-increment.
 249 * available glyphs, list (`groff_char(7)' man page): Using Symbols.
 250 * backslash, printing (\\, \e, \E, \[rs]) <1>: Implementation Differences.
 251 * backslash, printing (\\, \e, \E, \[rs]): Escapes.
 252 * backspace character:                   Identifiers.
 253 * backspace character, and translations: Character Translations.
 254 * backtrace of input stack (backtrace):  Debugging.
 255 * baseline:                              Sizes.
 256 * basic unit (u):                        Measurements.
 257 * basics of macros:                      Basics.
 258 * bd request, and font styles:           Font Families.
 259 * bd request, and font translations:     Changing Fonts.
 260 * bd request, incompatibilities with AT&T troff: Implementation Differences.
 261 * begin of conditional block (\{):       if-else.
 262 * beginning diversion (di):              Diversions.
 263 * blank line <1>:                        Requests.
 264 * blank line:                            Implicit Line Breaks.
 265 * blank line (sp):                       Basics.
 266 * blank line macro (blm) <1>:            Blank Line Traps.
 267 * blank line macro (blm) <2>:            Requests.
 268 * blank line macro (blm):                Implicit Line Breaks.
 269 * blank line traps:                      Blank Line Traps.
 270 * blank lines, disabling:                Manipulating Spacing.
 271 * block, conditional, begin (\{):        if-else.
 272 * block, condititional, end (\}):        if-else.
 273 * bold face [man]:                       Man font macros.
 274 * bold face, imitating (bd):             Artificial Fonts.
 275 * bottom margin:                         Page Layout.
 276 * bounding box:                          Miscellaneous.
 277 * box rule glyph (\[br]):                Drawing Requests.
 278 * box, boxa requests, and warnings:      Warnings.
 279 * bp request, and top-level diversion:   Page Control.
 280 * bp request, causing implicit linebreak: Manipulating Filling and Adjusting.
 281 * bp request, using + and -:             Expressions.
 282 * br glyph, and cflags:                  Using Symbols.
 283 * break <1>:                             Manipulating Filling and Adjusting.
 284 * break:                                 Basics.
 285 * break (br):                            Basics.
 286 * break request, in a while loop:        while.
 287 * break, implicit:                       Implicit Line Breaks.
 288 * built-in registers:                    Built-in Registers.
 289 * bulleted list, example markup [ms]:    Lists in ms.
 290 * c unit:                                Measurements.
 291 * calling convention of preprocessors:   Preprocessors in man pages.
 292 * capabilities of groff:                 groff Capabilities.
 293 * ce request, causing implicit linebreak: Manipulating Filling and Adjusting.
 294 * ce request, difference to .ad c:       Manipulating Filling and Adjusting.
 295 * centered text:                         Manipulating Filling and Adjusting.
 296 * centering lines (ce) <1>:              Manipulating Filling and Adjusting.
 297 * centering lines (ce):                  Basics.
 298 * centimeter unit (c):                   Measurements.
 299 * cf request, causing implicit linebreak: Manipulating Filling and Adjusting.
 300 * changing font family (fam, \F):        Font Families.
 301 * changing font position (\f):           Font Positions.
 302 * changing font style (sty):             Font Families.
 303 * changing fonts (ft, \f):               Changing Fonts.
 304 * changing format, and read-only registers: Assigning Formats.
 305 * changing the font height (\H):         Artificial Fonts.
 306 * changing the font slant (\S):          Artificial Fonts.
 307 * changing the page number character (pc): Page Layout.
 308 * changing trap location (ch):           Page Location Traps.
 309 * changing type sizes (ps, \s):          Changing Type Sizes.
 310 * changing vertical line spacing (vs):   Changing Type Sizes.
 311 * char request, and soft hyphen character: Manipulating Hyphenation.
 312 * char request, and translations:        Character Translations.
 313 * char request, used with \N:            Using Symbols.
 314 * character:                             Using Symbols.
 315 * character properties (cflags):         Using Symbols.
 316 * character translations:                Character Translations.
 317 * character, backspace:                  Identifiers.
 318 * character, backspace, and translations: Character Translations.
 319 * character, control (.):                Requests.
 320 * character, control, changing (cc):     Character Translations.
 321 * character, defining (char):            Using Symbols.
 322 * character, escape, changing (ec):      Character Translations.
 323 * character, escape, while defining glyph: Using Symbols.
 324 * character, field delimiting (fc):      Fields.
 325 * character, field padding (fc):         Fields.
 326 * character, hyphenation (\%):           Manipulating Hyphenation.
 327 * character, leader repetition (lc):     Leaders.
 328 * character, leader, and translations:   Character Translations.
 329 * character, leader, non-interpreted (\a): Leaders.
 330 * character, named (\C):                 Using Symbols.
 331 * character, newline:                    Escapes.
 332 * character, newline, and translations:  Character Translations.
 333 * character, no-break control ('):       Requests.
 334 * character, no-break control, changing (c2): Character Translations.
 335 * character, soft hyphen, setting (shc): Manipulating Hyphenation.
 336 * character, space:                      Escapes.
 337 * character, special:                    Character Translations.
 338 * character, tab:                        Escapes.
 339 * character, tab repetition (tc):        Tabs and Fields.
 340 * character, tab, and translations:      Character Translations.
 341 * character, tab, non-interpreted (\t):  Tabs and Fields.
 342 * character, tabulator:                  Tab Stops.
 343 * character, transparent <1>:            Using Symbols.
 344 * character, transparent:                Sentences.
 345 * character, whitespace:                 Identifiers.
 346 * character, zero width space (\&) <1>:  Drawing Requests.
 347 * character, zero width space (\&) <2>:  Ligatures and Kerning.
 348 * character, zero width space (\&):      Requests.
 349 * characters, argument delimiting:       Escapes.
 350 * characters, end-of-sentence:           Using Symbols.
 351 * characters, hyphenation:               Using Symbols.
 352 * characters, input, and output glyphs, compatibility with AT&T troff: Implementation Differences.
 353 * characters, invalid for trf request:   I/O.
 354 * characters, invalid input:             Identifiers.
 355 * characters, overlapping:               Using Symbols.
 356 * characters, special:                   Special Characters.
 357 * characters, unnamed, accessing with \N: Font File Format.
 358 * circle, drawing (\D'c ...'):           Drawing Requests.
 359 * circle, solid, drawing (\D'C ...'):    Drawing Requests.
 360 * closing file (close):                  I/O.
 361 * code, hyphenation (hcode):             Manipulating Hyphenation.
 362 * color, default:                        Colors.
 363 * colors:                                Colors.
 364 * command prefix:                        Environment.
 365 * command-line options:                  Groff Options.
 366 * commands, embedded:                    Embedded Commands.
 367 * comments:                              Comments.
 368 * comments in font files:                Font File Format.
 369 * comments, lining up with tabs:         Comments.
 370 * comments, with ds:                     Strings.
 371 * common features:                       Common Features.
 372 * common name space of macros, diversions, and strings: Strings.
 373 * comparison operators:                  Expressions.
 374 * compatibility mode <1>:                Implementation Differences.
 375 * compatibility mode:                    Warnings.
 376 * conditional block, begin (\{):         if-else.
 377 * conditional block, end (\}):           if-else.
 378 * conditional page break (ne):           Page Control.
 379 * conditionals and loops:                Conditionals and Loops.
 380 * consecutive hyphenated lines (hlm):    Manipulating Hyphenation.
 381 * constant glyph space mode (cs):        Artificial Fonts.
 382 * contents, table of <1>:                Leaders.
 383 * contents, table of:                    Table of Contents.
 384 * continuation, input line (\):          Line Control.
 385 * continuation, output line (\c):        Line Control.
 386 * continue request, in a while loop:     while.
 387 * continuous underlining (cu):           Artificial Fonts.
 388 * control character (.):                 Requests.
 389 * control character, changing (cc):      Character Translations.
 390 * control character, no-break ('):       Requests.
 391 * control character, no-break, changing (c2): Character Translations.
 392 * control, line:                         Line Control.
 393 * control, page:                         Page Control.
 394 * conventions for input:                 Input Conventions.
 395 * copy-in mode:                          Copy-in Mode.
 396 * copy-in mode, and macro arguments:     Parameters.
 397 * copy-in mode, and write requests:      I/O.
 398 * copying environment (evc):             Environments.
 399 * correction between italic and roman glyph (\/, \,): Ligatures and Kerning.
 400 * correction, italic (\/):               Ligatures and Kerning.
 401 * correction, left italic (\,):          Ligatures and Kerning.
 402 * cover page macros, [ms]:               ms Cover Page Macros.
 403 * cp request, and glyph definitions:     Using Symbols.
 404 * cp1047:                                Groff Options.
 405 * creating alias, for diversion (als):   Strings.
 406 * creating alias, for macro (als):       Strings.
 407 * creating alias, for number register (aln): Setting Registers.
 408 * creating alias, for string (als):      Strings.
 409 * creating new characters (char):        Using Symbols.
 410 * credits:                               Credits.
 411 * cs request, and font styles:           Font Families.
 412 * cs request, and font translations:     Changing Fonts.
 413 * cs request, incompatibilities with AT&T troff: Implementation Differences.
 414 * cs request, with fractional type sizes: Fractional Type Sizes.
 415 * current directory:                     Macro Directories.
 416 * current input file name register (.F): Built-in Registers.
 417 * current time:                          I/O.
 418 * current time, hours (hours):           Built-in Registers.
 419 * current time, minutes (minutes):       Built-in Registers.
 420 * current time, seconds (seconds):       Built-in Registers.
 421 * da request, and warnings:              Warnings.
 422 * date, day of the month register (dy):  Built-in Registers.
 423 * date, day of the week register (dw):   Built-in Registers.
 424 * date, month of the year register (mo): Built-in Registers.
 425 * date, year register (year, yr):        Built-in Registers.
 426 * day of the month register (dy):        Built-in Registers.
 427 * day of the week register (dw):         Built-in Registers.
 428 * de request, and while:                 while.
 429 * de, de1, dei requests, and warnings:   Warnings.
 430 * debugging:                             Debugging.
 431 * default color:                         Colors.
 432 * default indentation [man]:             Miscellaneous man macros.
 433 * default indentation, resetting [man]:  Man usage.
 434 * default units:                         Default Units.
 435 * defining character (char):             Using Symbols.
 436 * defining glyph (char):                 Using Symbols.
 437 * defining symbol (char):                Using Symbols.
 438 * delayed text:                          Footnotes and Annotations.
 439 * delimited arguments, incompatibilities with AT&T troff: Implementation Differences.
 440 * delimiting character, for fields (fc): Fields.
 441 * delimiting characters for arguments:   Escapes.
 442 * DESC file, format:                     DESC File Format.
 443 * devices for output <1>:                Output Devices.
 444 * devices for output:                    Output device intro.
 445 * dg glyph, at end of sentence <1>:      Using Symbols.
 446 * dg glyph, at end of sentence:          Sentences.
 447 * di request, and warnings:              Warnings.
 448 * differences in implementation:         Implementation Differences.
 449 * digit width space (\0):                Page Motions.
 450 * digits, and delimiters:                Escapes.
 451 * dimensions, line:                      Line Layout.
 452 * directories for fonts:                 Font Directories.
 453 * directories for macros:                Macro Directories.
 454 * directory, current:                    Macro Directories.
 455 * directory, for tmac files:             Macro Directories.
 456 * directory, home:                       Macro Directories.
 457 * directory, platform-specific:          Macro Directories.
 458 * directory, site-specific <1>:          Font Directories.
 459 * directory, site-specific:              Macro Directories.
 460 * disabling \ (eo):                      Character Translations.
 461 * disabling hyphenation (\%):            Manipulating Hyphenation.
 462 * displays:                              Displays.
 463 * displays [ms]:                         ms Displays and Keeps.
 464 * distance to next trap register (.t):   Page Location Traps.
 465 * ditroff, the program:                  History.
 466 * diversion name register (.z):          Diversions.
 467 * diversion trap, setting (dt):          Diversion Traps.
 468 * diversion traps:                       Diversion Traps.
 469 * diversion, appending (da):             Diversions.
 470 * diversion, beginning (di):             Diversions.
 471 * diversion, creating alias (als):       Strings.
 472 * diversion, ending (di):                Diversions.
 473 * diversion, nested:                     Diversions.
 474 * diversion, removing (rm):              Strings.
 475 * diversion, renaming (rn):              Strings.
 476 * diversion, stripping final newline:    Strings.
 477 * diversion, top-level:                  Diversions.
 478 * diversion, top-level, and \!:          Diversions.
 479 * diversion, top-level, and \?:          Diversions.
 480 * diversion, top-level, and bp:          Page Control.
 481 * diversion, unformatting (asciify):     Diversions.
 482 * diversion, vertical position in, register (.d): Diversions.
 483 * diversions:                            Diversions.
 484 * diversions, shared name space with macros and strings: Strings.
 485 * documents, multi-file:                 Debugging.
 486 * documents, structuring the source code: Requests.
 487 * double quote, in a macro argument:     Request Arguments.
 488 * double-spacing (ls) <1>:               Manipulating Spacing.
 489 * double-spacing (ls):                   Basics.
 490 * double-spacing (vs, pvs):              Changing Type Sizes.
 491 * drawing a circle (\D'c ...'):          Drawing Requests.
 492 * drawing a line (\D'l ...'):            Drawing Requests.
 493 * drawing a polygon (\D'p ...'):         Drawing Requests.
 494 * drawing a solid circle (\D'C ...'):    Drawing Requests.
 495 * drawing a solid ellipse (\D'E ...'):   Drawing Requests.
 496 * drawing a solid polygon (\D'P ...'):   Drawing Requests.
 497 * drawing a spline (\D'~ ...'):          Drawing Requests.
 498 * drawing an arc (\D'a ...'):            Drawing Requests.
 499 * drawing an ellipse (\D'e ...'):        Drawing Requests.
 500 * drawing horizontal lines (\l):         Drawing Requests.
 501 * drawing requests:                      Drawing Requests.
 502 * drawing vertical lines (\L):           Drawing Requests.
 503 * ds request, and comments:              Strings.
 504 * ds request, and double quotes:         Request Arguments.
 505 * ds request, and leading spaces:        Strings.
 506 * ds, ds1 requests, and comments:        Comments.
 507 * ds, ds1 requests, and warnings:        Warnings.
 508 * dumping number registers (pnr):        Debugging.
 509 * dumping symbol table (pm):             Debugging.
 510 * dumping traps (ptr):                   Debugging.
 511 * EBCDIC encoding <1>:                   Tab Stops.
 512 * EBCDIC encoding:                       Groff Options.
 513 * EBCDIC encoding of a tab:              Tabs and Fields.
 514 * EBCDIC encoding of backspace:          Identifiers.
 515 * el request, and warnings:              Warnings.
 516 * ellipse, drawing (\D'e ...'):          Drawing Requests.
 517 * ellipse, solid, drawing (\D'E ...'):   Drawing Requests.
 518 * em glyph, and cflags:                  Using Symbols.
 519 * em unit (m):                           Measurements.
 520 * embedded commands:                     Embedded Commands.
 521 * embedding PostScript:                  Embedding PostScript.
 522 * embolding of special fonts:            Artificial Fonts.
 523 * empty line:                            Implicit Line Breaks.
 524 * empty line (sp):                       Basics.
 525 * empty space before a paragraph [man]:  Miscellaneous man macros.
 526 * en unit (n):                           Measurements.
 527 * enabling vertical position traps (vpt): Page Location Traps.
 528 * encoding, ASCII:                       Groff Options.
 529 * encoding, cp1047:                      Groff Options.
 530 * encoding, EBCDIC <1>:                  Tab Stops.
 531 * encoding, EBCDIC:                      Groff Options.
 532 * encoding, latin-1:                     Groff Options.
 533 * encoding, utf-8:                       Groff Options.
 534 * end of conditional block (\}):         if-else.
 535 * end-of-input macro (em):               End-of-input Traps.
 536 * end-of-input trap, setting (em):       End-of-input Traps.
 537 * end-of-input traps:                    End-of-input Traps.
 538 * end-of-sentence characters:            Using Symbols.
 539 * ending diversion (di):                 Diversions.
 540 * environment number/name register (.ev): Environments.
 541 * environment variables:                 Environment.
 542 * environment, copying (evc):            Environments.
 543 * environment, last glyph:               Environments.
 544 * environment, switching (ev):           Environments.
 545 * environments:                          Environments.
 546 * eqn, the program:                      geqn.
 547 * equations [ms]:                        ms Insertions.
 548 * escape character, changing (ec):       Character Translations.
 549 * escape character, while defining glyph: Using Symbols.
 550 * escapes:                               Escapes.
 551 * escaping newline characters, in strings: Strings.
 552 * ex request, use in debugging:          Debugging.
 553 * ex request, used with nx and rd:       I/O.
 554 * example markup, bulleted list [ms]:    Lists in ms.
 555 * example markup, glossary-style list [ms]: Lists in ms.
 556 * example markup, multi-page table [ms]: Example multi-page table.
 557 * example markup, numbered list [ms]:    Lists in ms.
 558 * example markup, title page:            ms Cover Page Macros.
 559 * examples of invocation:                Invocation Examples.
 560 * exiting (ex):                          Debugging.
 561 * expansion of strings (\*):             Strings.
 562 * explicit hyphen (\%):                  Manipulating Hyphenation.
 563 * expression, order of evaluation:       Expressions.
 564 * expressions:                           Expressions.
 565 * expressions, and space characters:     Expressions.
 566 * extra post-vertical line space (\x):   Changing Type Sizes.
 567 * extra post-vertical line space register (.a): Manipulating Spacing.
 568 * extra pre-vertical line space (\x):    Changing Type Sizes.
 569 * extra spaces:                          Filling and Adjusting.
 570 * extremum operators (>?, <?):           Expressions.
 571 * f unit:                                Measurements.
 572 * f unit, and colors:                    Colors.
 573 * fam request, and changing fonts:       Changing Fonts.
 574 * fam request, and font positions:       Font Positions.
 575 * families, font:                        Font Families.
 576 * FDL, GNU Free Documentation License:   GNU Free Documentation License.
 577 * features, common:                      Common Features.
 578 * fi request, causing implicit linebreak: Manipulating Filling and Adjusting.
 579 * field delimiting character (fc):       Fields.
 580 * field padding character (fc):          Fields.
 581 * fields:                                Fields.
 582 * fields, and tabs:                      Tabs and Fields.
 583 * figures [ms]:                          ms Insertions.
 584 * file formats:                          File formats.
 585 * file, appending to (opena):            I/O.
 586 * file, closing (close):                 I/O.
 587 * file, inclusion (so):                  I/O.
 588 * file, opening (open):                  I/O.
 589 * file, processing next (nx):            I/O.
 590 * file, writing to (write):              I/O.
 591 * files, font:                           Font Files.
 592 * files, macro, searching:               Macro Directories.
 593 * fill mode <1>:                         Warnings.
 594 * fill mode <2>:                         Manipulating Filling and Adjusting.
 595 * fill mode:                             Implicit Line Breaks.
 596 * fill mode (fi):                        Manipulating Filling and Adjusting.
 597 * fill mode, and \c:                     Line Control.
 598 * filling:                               Filling and Adjusting.
 599 * filling and adjusting, manipulating:   Manipulating Filling and Adjusting.
 600 * final newline, stripping in diversions: Strings.
 601 * fl request, causing implicit linebreak: Manipulating Filling and Adjusting.
 602 * floating keep:                         Displays.
 603 * flush output (fl):                     Debugging.
 604 * font description file, format <1>:     Font File Format.
 605 * font description file, format:         DESC File Format.
 606 * font directories:                      Font Directories.
 607 * font families:                         Font Families.
 608 * font family, changing (fam, \F):       Font Families.
 609 * font file, format:                     Font File Format.
 610 * font files:                            Font Files.
 611 * font files, comments:                  Font File Format.
 612 * font for underlining (uf):             Artificial Fonts.
 613 * font height, changing (\H):            Artificial Fonts.
 614 * font path:                             Font Directories.
 615 * font position register (.f):           Font Positions.
 616 * font position, changing (\f):          Font Positions.
 617 * font positions:                        Font Positions.
 618 * font selection [man]:                  Man font macros.
 619 * font slant, changing (\S):             Artificial Fonts.
 620 * font style, changing (sty):            Font Families.
 621 * font styles:                           Font Families.
 622 * font, mounting (fp):                   Font Positions.
 623 * font, previous (ft, \f[], \fP):        Changing Fonts.
 624 * fonts <1>:                             Changing Fonts.
 625 * fonts:                                 Fonts.
 626 * fonts, artificial:                     Artificial Fonts.
 627 * fonts, changing (ft, \f):              Changing Fonts.
 628 * fonts, PostScript:                     Font Families.
 629 * fonts, searching:                      Font Directories.
 630 * fonts, special:                        Special Fonts.
 631 * footers <1>:                           Page Location Traps.
 632 * footers:                               Page Layout.
 633 * footers [ms]:                          ms Headers and Footers.
 634 * footnotes:                             Footnotes and Annotations.
 635 * footnotes [ms]:                        ms Footnotes.
 636 * form letters:                          I/O.
 637 * format of font description file:       DESC File Format.
 638 * format of font description files:      Font File Format.
 639 * format of font files:                  Font File Format.
 640 * format of register (\g):               Assigning Formats.
 641 * formats, assigning (af):               Assigning Formats.
 642 * formats, file:                         File formats.
 643 * fp request, and font translations:     Changing Fonts.
 644 * fp request, incompatibilities with AT&T troff: Implementation Differences.
 645 * fractional point sizes <1>:            Implementation Differences.
 646 * fractional point sizes:                Fractional Type Sizes.
 647 * fractional type sizes <1>:             Implementation Differences.
 648 * fractional type sizes:                 Fractional Type Sizes.
 649 * french-spacing:                        Sentences.
 650 * fspecial request, and font styles:     Font Families.
 651 * fspecial request, and font translations: Changing Fonts.
 652 * fspecial request, and imitating bold:  Artificial Fonts.
 653 * ft request, and font translations:     Changing Fonts.
 654 * geqn, invoking:                        Invoking geqn.
 655 * geqn, the program:                     geqn.
 656 * ggrn, invoking:                        Invoking ggrn.
 657 * ggrn, the program:                     ggrn.
 658 * glossary-style list, example markup [ms]: Lists in ms.
 659 * glyph:                                 Using Symbols.
 660 * glyph for line drawing:                Drawing Requests.
 661 * glyph pile (\b):                       Drawing Requests.
 662 * glyph properties (cflags):             Using Symbols.
 663 * glyph, box rule (\[br]):               Drawing Requests.
 664 * glyph, constant space:                 Artificial Fonts.
 665 * glyph, defining (char):                Using Symbols.
 666 * glyph, for line drawing:               Drawing Requests.
 667 * glyph, for margins (mc):               Miscellaneous.
 668 * glyph, italic correction (\/):         Ligatures and Kerning.
 669 * glyph, leader repetition (lc):         Leaders.
 670 * glyph, left italic correction (\,):    Ligatures and Kerning.
 671 * glyph, numbered (\N) <1>:              Using Symbols.
 672 * glyph, numbered (\N):                  Character Translations.
 673 * glyph, removing definition (rchar):    Using Symbols.
 674 * glyph, soft hyphen (hy):               Manipulating Hyphenation.
 675 * glyph, tab repetition (tc):            Tabs and Fields.
 676 * glyph, underscore (\[ru]):             Drawing Requests.
 677 * glyphs, available, list (`groff_char(7)' man page): Using Symbols.
 678 * glyphs, output, and input characters, compatibility with AT&T troff: Implementation Differences.
 679 * glyphs, overstriking (\o):             Page Motions.
 680 * glyphs, unnamed:                       Using Symbols.
 681 * glyphs, unnamed, accessing with \N:    Font File Format.
 682 * GNU-specific register (.g):            Built-in Registers.
 683 * gpic, invoking:                        Invoking gpic.
 684 * gpic, the program:                     gpic.
 685 * grap, the program:                     grap.
 686 * gray shading (\D'f ...'):              Drawing Requests.
 687 * grefer, invoking:                      Invoking grefer.
 688 * grefer, the program:                   grefer.
 689 * grn, the program:                      ggrn.
 690 * grodvi, invoking:                      Invoking grodvi.
 691 * grodvi, the program:                   grodvi.
 692 * groff - what is it?:                   What Is groff?.
 693 * groff capabilities:                    groff Capabilities.
 694 * groff invocation:                      Invoking groff.
 695 * groff, and pi request:                 I/O.
 696 * GROFF_BIN_PATH, environment variable:  Environment.
 697 * GROFF_COMMAND_PREFIX, environment variable: Environment.
 698 * GROFF_FONT_PATH, environment variable <1>: Font Directories.
 699 * GROFF_FONT_PATH, environment variable: Environment.
 700 * GROFF_TMAC_PATH, environment variable <1>: Macro Directories.
 701 * GROFF_TMAC_PATH, environment variable: Environment.
 702 * GROFF_TMPDIR, environment variable:    Environment.
 703 * GROFF_TYPESETTER, environment variable: Environment.
 704 * grohtml, invoking:                     Invoking grohtml.
 705 * grohtml, registers and strings:        grohtml specific registers and strings.
 706 * grohtml, the program <1>:              grohtml.
 707 * grohtml, the program:                  Groff Options.
 708 * grolbp, invoking:                      Invoking grolbp.
 709 * grolbp, the program:                   grolbp.
 710 * grolj4, invoking:                      Invoking grolj4.
 711 * grolj4, the program:                   grolj4.
 712 * grops, invoking:                       Invoking grops.
 713 * grops, the program:                    grops.
 714 * grotty, invoking:                      Invoking grotty.
 715 * grotty, the program:                   grotty.
 716 * gsoelim, invoking:                     Invoking gsoelim.
 717 * gsoelim, the program:                  gsoelim.
 718 * gtbl, invoking:                        Invoking gtbl.
 719 * gtbl, the program:                     gtbl.
 720 * gtroff, identification register (.g):  Built-in Registers.
 721 * gtroff, interactive use:               Debugging.
 722 * gtroff, output:                        gtroff Output.
 723 * gtroff, process ID register ($$):      Built-in Registers.
 724 * gtroff, reference:                     gtroff Reference.
 725 * gxditview, invoking:                   Invoking gxditview.
 726 * gxditview, the program:                gxditview.
 727 * hanging indentation [man]:             Man usage.
 728 * hcode request, and glyph definitions:  Using Symbols.
 729 * headers <1>:                           Page Location Traps.
 730 * headers:                               Page Layout.
 731 * headers [ms]:                          ms Headers and Footers.
 732 * height, font, changing (\H):           Artificial Fonts.
 733 * high-water mark register (.h):         Diversions.
 734 * history:                               History.
 735 * home directory:                        Macro Directories.
 736 * horizontal input line position register (hp): Page Motions.
 737 * horizontal input line position, saving (\k): Page Motions.
 738 * horizontal line, drawing (\l):         Drawing Requests.
 739 * horizontal motion (\h):                Page Motions.
 740 * horizontal output line position register (.k): Page Motions.
 741 * horizontal resolution register (.H):   Built-in Registers.
 742 * horizontal space (\h):                 Page Motions.
 743 * horizontal space, unformatting:        Strings.
 744 * hours, current time (hours):           Built-in Registers.
 745 * hpf request, and hyphenation language: Manipulating Hyphenation.
 746 * hw request, and hyphenation language:  Manipulating Hyphenation.
 747 * hy glyph, and cflags:                  Using Symbols.
 748 * hyphen, explicit (\%):                 Manipulating Hyphenation.
 749 * hyphenated lines, consecutive (hlm):   Manipulating Hyphenation.
 750 * hyphenating characters:                Using Symbols.
 751 * hyphenation:                           Hyphenation.
 752 * hyphenation character (\%):            Manipulating Hyphenation.
 753 * hyphenation code (hcode):              Manipulating Hyphenation.
 754 * hyphenation language register (.hla):  Manipulating Hyphenation.
 755 * hyphenation margin (hym):              Manipulating Hyphenation.
 756 * hyphenation margin register (.hym):    Manipulating Hyphenation.
 757 * hyphenation patterns (hpf):            Manipulating Hyphenation.
 758 * hyphenation restrictions register (.hy): Manipulating Hyphenation.
 759 * hyphenation space (hys):               Manipulating Hyphenation.
 760 * hyphenation space register (.hys):     Manipulating Hyphenation.
 761 * hyphenation, disabling (\%):           Manipulating Hyphenation.
 762 * hyphenation, manipulating:             Manipulating Hyphenation.
 763 * i unit:                                Measurements.
 764 * i/o:                                   I/O.
 765 * IBM cp1047:                            Groff Options.
 766 * identifiers:                           Identifiers.
 767 * identifiers, undefined:                Identifiers.
 768 * ie request, and warnings:              Warnings.
 769 * if request, and the ! operator:        Expressions.
 770 * if request, operators to use with:     Operators in Conditionals.
 771 * if-else:                               if-else.
 772 * imitating bold face (bd):              Artificial Fonts.
 773 * implementation differences:            Implementation Differences.
 774 * implicit breaks of lines:              Implicit Line Breaks.
 775 * implicit line breaks:                  Implicit Line Breaks.
 776 * in request, causing implicit linebreak: Manipulating Filling and Adjusting.
 777 * in request, using + and -:             Expressions.
 778 * inch unit (i):                         Measurements.
 779 * including a file (so):                 I/O.
 780 * incompatibilities with AT&T troff:     Implementation Differences.
 781 * increment value without changing the register: Auto-increment.
 782 * increment, automatic:                  Auto-increment.
 783 * indentaion, resetting to default [man]: Man usage.
 784 * indentation (in):                      Line Layout.
 785 * index, in macro package:               Indices.
 786 * indirect assignments:                  Interpolating Registers.
 787 * input and output requests:             I/O.
 788 * input characters and output glyphs, compatibility with AT&T troff: Implementation Differences.
 789 * input characters, invalid:             Identifiers.
 790 * input conventions:                     Input Conventions.
 791 * input file name, current, register (.F): Built-in Registers.
 792 * input level in delimited arguments:    Implementation Differences.
 793 * input line continuation (\):           Line Control.
 794 * input line number register (.c, c.):   Built-in Registers.
 795 * input line number, setting (lf):       Debugging.
 796 * input line position, horizontal, saving (\k): Page Motions.
 797 * input line trap, setting (it):         Input Line Traps.
 798 * input line traps:                      Input Line Traps.
 799 * input line traps and interrupted lines (itc): Input Line Traps.
 800 * input line, horizontal position, register (hp): Page Motions.
 801 * input stack, backtrace (backtrace):    Debugging.
 802 * input stack, setting limit:            Debugging.
 803 * input token:                           Gtroff Internals.
 804 * input, 8-bit:                          Font File Format.
 805 * input, standard, reading from (rd):    I/O.
 806 * inserting horizontal space (\h):       Page Motions.
 807 * installation:                          Installation.
 808 * interactive use of gtroff:             Debugging.
 809 * intermediate output:                   gtroff Output.
 810 * interpolating registers (\n):          Interpolating Registers.
 811 * interpolation of strings (\*):         Strings.
 812 * interrupted line:                      Line Control.
 813 * interrupted line register (.int):      Line Control.
 814 * interrupted lines and input line traps (itc): Input Line Traps.
 815 * introduction:                          Introduction.
 816 * invalid characters for trf request:    I/O.
 817 * invalid input characters:              Identifiers.
 818 * invocation examples:                   Invocation Examples.
 819 * invoking geqn:                         Invoking geqn.
 820 * invoking ggrn:                         Invoking ggrn.
 821 * invoking gpic:                         Invoking gpic.
 822 * invoking grefer:                       Invoking grefer.
 823 * invoking grodvi:                       Invoking grodvi.
 824 * invoking groff:                        Invoking groff.
 825 * invoking grohtml:                      Invoking grohtml.
 826 * invoking grolbp:                       Invoking grolbp.
 827 * invoking grolj4:                       Invoking grolj4.
 828 * invoking grops:                        Invoking grops.
 829 * invoking grotty:                       Invoking grotty.
 830 * invoking gsoelim:                      Invoking gsoelim.
 831 * invoking gtbl:                         Invoking gtbl.
 832 * invoking gxditview:                    Invoking gxditview.
 833 * italic correction (\/):                Ligatures and Kerning.
 834 * italic fonts [man]:                    Man font macros.
 835 * italic glyph, correction after roman glyph (\,): Ligatures and Kerning.
 836 * italic glyph, correction before roman glyph (\/): Ligatures and Kerning.
 837 * justifying text:                       Manipulating Filling and Adjusting.
 838 * justifying text (rj):                  Manipulating Filling and Adjusting.
 839 * keep:                                  Displays.
 840 * keep, floating:                        Displays.
 841 * keeps [ms]:                            ms Displays and Keeps.
 842 * kerning and ligatures:                 Ligatures and Kerning.
 843 * kerning enabled register (.kern):      Ligatures and Kerning.
 844 * kerning, activating (kern):            Ligatures and Kerning.
 845 * kerning, track:                        Ligatures and Kerning.
 846 * last-requested point size registers (.psr, .sr): Fractional Type Sizes.
 847 * latin-1, encoding:                     Groff Options.
 848 * layout, line:                          Line Layout.
 849 * layout, page:                          Page Layout.
 850 * lc request, and glyph definitions:     Using Symbols.
 851 * leader character:                      Leaders.
 852 * leader character, and translations:    Character Translations.
 853 * leader character, non-interpreted (\a): Leaders.
 854 * leader repetition character (lc):      Leaders.
 855 * leaders:                               Leaders.
 856 * leading:                               Sizes.
 857 * leading spaces:                        Filling and Adjusting.
 858 * leading spaces with ds:                Strings.
 859 * left italic correction (\,):           Ligatures and Kerning.
 860 * left margin (po):                      Line Layout.
 861 * left margin, how to move [man]:        Man usage.
 862 * length of a string (length):           Strings.
 863 * length of line (ll):                   Line Layout.
 864 * length of page (pl):                   Page Layout.
 865 * length of title line (lt):             Page Layout.
 866 * letters, form:                         I/O.
 867 * level of warnings (warn):              Debugging.
 868 * ligature:                              Using Symbols.
 869 * ligatures and kerning:                 Ligatures and Kerning.
 870 * ligatures enabled register (.lg):      Ligatures and Kerning.
 871 * ligatures, activating (lg):            Ligatures and Kerning.
 872 * limitations of \b escape:              Drawing Requests.
 873 * line break <1>:                        Manipulating Filling and Adjusting.
 874 * line break <2>:                        Implicit Line Breaks.
 875 * line break:                            Basics.
 876 * line break (br):                       Basics.
 877 * line breaks, with vertical space [man]: Man usage.
 878 * line breaks, without vertical space [man]: Man usage.
 879 * line control:                          Line Control.
 880 * line dimensions:                       Line Layout.
 881 * line drawing glyph:                    Drawing Requests.
 882 * line indentation (in):                 Line Layout.
 883 * line layout:                           Line Layout.
 884 * line length (ll):                      Line Layout.
 885 * line length register (.l):             Line Layout.
 886 * line number, input, register (.c, c.): Built-in Registers.
 887 * line number, output, register (ln):    Built-in Registers.
 888 * line numbers, printing (nm):           Miscellaneous.
 889 * line space, extra post-vertical (\x):  Changing Type Sizes.
 890 * line space, extra pre-vertical (\x):   Changing Type Sizes.
 891 * line spacing register (.L):            Manipulating Spacing.
 892 * line spacing, post-vertical (pvs):     Changing Type Sizes.
 893 * line thickness (\D't ...'):            Drawing Requests.
 894 * line, blank:                           Implicit Line Breaks.
 895 * line, drawing (\D'l ...'):             Drawing Requests.
 896 * line, empty (sp):                      Basics.
 897 * line, horizontal, drawing (\l):        Drawing Requests.
 898 * line, implicit breaks:                 Implicit Line Breaks.
 899 * line, input, continuation (\):         Line Control.
 900 * line, input, horizontal position, register (hp): Page Motions.
 901 * line, input, horizontal position, saving (\k): Page Motions.
 902 * line, interrupted:                     Line Control.
 903 * line, output, continuation (\c):       Line Control.
 904 * line, output, horizontal position, register (.k): Page Motions.
 905 * line, vertical, drawing (\L):          Drawing Requests.
 906 * line-tabs mode:                        Tabs and Fields.
 907 * lines, blank, disabling:               Manipulating Spacing.
 908 * lines, centering (ce) <1>:             Manipulating Filling and Adjusting.
 909 * lines, centering (ce):                 Basics.
 910 * lines, consecutive hyphenated (hlm):   Manipulating Hyphenation.
 911 * lines, interrupted, and input line traps (itc): Input Line Traps.
 912 * list:                                  Displays.
 913 * list of available glyphs (`groff_char(7)' man page): Using Symbols.
 914 * ll request, using + and -:             Expressions.
 915 * location, vertical, page, marking (mk): Page Motions.
 916 * location, vertical, page, returning to marked (rt): Page Motions.
 917 * logical operators:                     Expressions.
 918 * long names:                            Implementation Differences.
 919 * loops and conditionals:                Conditionals and Loops.
 920 * lq glyph, and lq string [man]:         Predefined man strings.
 921 * ls request, alternative to (pvs):      Changing Type Sizes.
 922 * lt request, using + and -:             Expressions.
 923 * M unit:                                Measurements.
 924 * m unit:                                Measurements.
 925 * machine unit (u):                      Measurements.
 926 * macro basics:                          Basics.
 927 * macro directories:                     Macro Directories.
 928 * macro files, searching:                Macro Directories.
 929 * macro name register (\$0):             Parameters.
 930 * macro names, starting with [ or ], and refer: Identifiers.
 931 * macro packages <1>:                    Macro Packages.
 932 * macro packages:                        Macro Package Intro.
 933 * macro packages, structuring the source code: Requests.
 934 * macro, appending (am):                 Writing Macros.
 935 * macro, arguments (\$):                 Parameters.
 936 * macro, creating alias (als):           Strings.
 937 * macro, end-of-input (em):              End-of-input Traps.
 938 * macro, removing (rm):                  Strings.
 939 * macro, renaming (rn):                  Strings.
 940 * macros:                                Macros.
 941 * macros for manual pages [man]:         Man usage.
 942 * macros, recursive:                     while.
 943 * macros, searching:                     Macro Directories.
 944 * macros, shared name space with strings and diversions: Strings.
 945 * macros, tutorial for users:            Tutorial for Macro Users.
 946 * macros, writing:                       Writing Macros.
 947 * major quotes:                          Displays.
 948 * major version number register (.x):    Built-in Registers.
 949 * man macros:                            Man usage.
 950 * man macros, bold face:                 Man font macros.
 951 * man macros, default indentation:       Miscellaneous man macros.
 952 * man macros, empty space before a paragraph: Miscellaneous man macros.
 953 * man macros, hanging indentation:       Man usage.
 954 * man macros, how to set fonts:          Man font macros.
 955 * man macros, italic fonts:              Man font macros.
 956 * man macros, line breaks with vertical space: Man usage.
 957 * man macros, line breaks without vertical space: Man usage.
 958 * man macros, moving left margin:        Man usage.
 959 * man macros, resetting default indentation: Man usage.
 960 * man macros, tab stops:                 Miscellaneous man macros.
 961 * man pages:                             man.
 962 * manipulating filling and adjusting:    Manipulating Filling and Adjusting.
 963 * manipulating hyphenation:              Manipulating Hyphenation.
 964 * manipulating spacing:                  Manipulating Spacing.
 965 * manual pages:                          man.
 966 * margin for hyphenation (hym):          Manipulating Hyphenation.
 967 * margin glyph (mc):                     Miscellaneous.
 968 * margin, bottom:                        Page Layout.
 969 * margin, left (po):                     Line Layout.
 970 * margin, top:                           Page Layout.
 971 * mark, high-water, register (.h):       Diversions.
 972 * marking vertical page location (mk):   Page Motions.
 973 * maximum values of Roman numerals:      Assigning Formats.
 974 * mdoc macros:                           mdoc.
 975 * me macro package:                      me.
 976 * measurement unit:                      Measurements.
 977 * measurements:                          Measurements.
 978 * measurements, specifying safely:       Default Units.
 979 * minimum values of Roman numerals:      Assigning Formats.
 980 * minor version number register (.y):    Built-in Registers.
 981 * minutes, current time (minutes):       Built-in Registers.
 982 * mm macro package:                      mm.
 983 * mode for constant glyph space (cs):    Artificial Fonts.
 984 * mode, compatibility:                   Implementation Differences.
 985 * mode, copy-in:                         Copy-in Mode.
 986 * mode, copy-in, and write requests:     I/O.
 987 * mode, fill <1>:                        Warnings.
 988 * mode, fill <2>:                        Manipulating Filling and Adjusting.
 989 * mode, fill:                            Implicit Line Breaks.
 990 * mode, fill (fi):                       Manipulating Filling and Adjusting.
 991 * mode, fill, and \c:                    Line Control.
 992 * mode, line-tabs:                       Tabs and Fields.
 993 * mode, no-fill (nf):                    Manipulating Filling and Adjusting.
 994 * mode, no-fill, and \c:                 Line Control.
 995 * mode, no-space (ns):                   Manipulating Spacing.
 996 * mode, nroff:                           Troff and Nroff Mode.
 997 * mode, safer <1>:                       I/O.
 998 * mode, safer <2>:                       Macro Directories.
 999 * mode, safer:                           Groff Options.
1000 * mode, troff:                           Troff and Nroff Mode.
1001 * mode, unsafe <1>:                      I/O.
1002 * mode, unsafe <2>:                      Macro Directories.
1003 * mode, unsafe:                          Groff Options.
1004 * month of the year register (mo):       Built-in Registers.
1005 * motion operators:                      Expressions.
1006 * motion, horizontal (\h):               Page Motions.
1007 * motion, vertical (\v):                 Page Motions.
1008 * motions, page:                         Page Motions.
1009 * mounting font (fp):                    Font Positions.
1010 * ms macros:                             ms.
1011 * ms macros, accent marks:               ms Strings and Special Characters.
1012 * ms macros, body text:                  ms Body Text.
1013 * ms macros, cover page:                 ms Cover Page Macros.
1014 * ms macros, creating table of contents: ms TOC.
1015 * ms macros, differences from AT&T:      Differences from AT&T ms.
1016 * ms macros, displays:                   ms Displays and Keeps.
1017 * ms macros, document control registers: ms Document Control Registers.
1018 * ms macros, equations:                  ms Insertions.
1019 * ms macros, figures:                    ms Insertions.
1020 * ms macros, footers:                    ms Headers and Footers.
1021 * ms macros, footnotes:                  ms Footnotes.
1022 * ms macros, general structure:          General ms Structure.
1023 * ms macros, headers:                    ms Headers and Footers.
1024 * ms macros, headings:                   Headings in ms.
1025 * ms macros, highlighting:               Highlighting in ms.
1026 * ms macros, keeps:                      ms Displays and Keeps.
1027 * ms macros, lists:                      Lists in ms.
1028 * ms macros, margins:                    ms Margins.
1029 * ms macros, multiple columns:           ms Multiple Columns.
1030 * ms macros, nested lists:               Lists in ms.
1031 * ms macros, page layout:                ms Page Layout.
1032 * ms macros, paragraph handling:         Paragraphs in ms.
1033 * ms macros, references:                 ms Insertions.
1034 * ms macros, special characters:         ms Strings and Special Characters.
1035 * ms macros, strings:                    ms Strings and Special Characters.
1036 * ms macros, tables:                     ms Insertions.
1037 * multi-file documents:                  Debugging.
1038 * multi-line strings:                    Strings.
1039 * multi-page table, example markup [ms]: Example multi-page table.
1040 * multiple columns [ms]:                 ms Multiple Columns.
1041 * n unit:                                Measurements.
1042 * name space, common, of macros, diversions, and strings: Strings.
1043 * named character (\C):                  Using Symbols.
1044 * names, long:                           Implementation Differences.
1045 * ne request, and the .trunc register:   Page Location Traps.
1046 * ne request, comparison with sv:        Page Control.
1047 * negating register values:              Setting Registers.
1048 * nested assignments:                    Interpolating Registers.
1049 * nested diversions:                     Diversions.
1050 * nested lists [ms]:                     Lists in ms.
1051 * new page (bp) <1>:                     Page Control.
1052 * new page (bp):                         Basics.
1053 * newline character <1>:                 Escapes.
1054 * newline character:                     Identifiers.
1055 * newline character, and translations:   Character Translations.
1056 * newline character, in strings, escaping: Strings.
1057 * newline, final, stripping in diversions: Strings.
1058 * next file, processing (nx):            I/O.
1059 * next free font position register (.fp): Font Positions.
1060 * nf request, causing implicit linebreak: Manipulating Filling and Adjusting.
1061 * nl register, and .d:                   Diversions.
1062 * nl register, difference to .h:         Diversions.
1063 * nm request, using + and -:             Expressions.
1064 * no-break control character ('):        Requests.
1065 * no-break control character, changing (c2): Character Translations.
1066 * no-fill mode (nf):                     Manipulating Filling and Adjusting.
1067 * no-fill mode, and \c:                  Line Control.
1068 * no-space mode (ns):                    Manipulating Spacing.
1069 * node, output:                          Gtroff Internals.
1070 * nr request, and warnings:              Warnings.
1071 * nr request, using + and -:             Expressions.
1072 * nroff mode:                            Troff and Nroff Mode.
1073 * nroff, the program:                    History.
1074 * number of arguments register (.$):     Parameters.
1075 * number register, creating alias (aln): Setting Registers.
1076 * number register, removing (rr):        Setting Registers.
1077 * number register, renaming (rnn):       Setting Registers.
1078 * number registers, dumping (pnr):       Debugging.
1079 * number, input line, setting (lf):      Debugging.
1080 * number, page (pn):                     Page Layout.
1081 * numbered glyph (\N) <1>:               Using Symbols.
1082 * numbered glyph (\N):                   Character Translations.
1083 * numbered list, example markup [ms]:    Lists in ms.
1084 * numbers, and delimiters:               Escapes.
1085 * numbers, line, printing (nm):          Miscellaneous.
1086 * numerals, Roman:                       Assigning Formats.
1087 * numeric expression, valid:             Expressions.
1088 * offset, page (po):                     Line Layout.
1089 * open request, and safer mode:          Groff Options.
1090 * opena request, and safer mode:         Groff Options.
1091 * opening file (open):                   I/O.
1092 * operator, scaling:                     Expressions.
1093 * operators, arithmetic:                 Expressions.
1094 * operators, as delimiters:              Escapes.
1095 * operators, comparison:                 Expressions.
1096 * operators, extremum (>?, <?):          Expressions.
1097 * operators, logical:                    Expressions.
1098 * operators, motion:                     Expressions.
1099 * operators, unary:                      Expressions.
1100 * options:                               Groff Options.
1101 * order of evaluation in expressions:    Expressions.
1102 * orphan lines, preventing with ne:      Page Control.
1103 * os request, and no-space mode:         Page Control.
1104 * output and input requests:             I/O.
1105 * output device name string register (.T) <1>: Built-in Registers.
1106 * output device name string register (.T): Groff Options.
1107 * output device usage number register (.T): Groff Options.
1108 * output devices <1>:                    Output Devices.
1109 * output devices:                        Output device intro.
1110 * output glyphs, and input characters,compatibility with AT&T troff: Implementation Differences.
1111 * output line number register (ln):      Built-in Registers.
1112 * output line, continuation (\c):        Line Control.
1113 * output line, horizontal position, register (.k): Page Motions.
1114 * output node:                           Gtroff Internals.
1115 * output request, and \!:                Diversions.
1116 * output, flush (fl):                    Debugging.
1117 * output, gtroff:                        gtroff Output.
1118 * output, intermediate:                  gtroff Output.
1119 * output, suppressing (\O):              Suppressing output.
1120 * output, transparent (\!, \?):          Diversions.
1121 * output, transparent (cf, trf):         I/O.
1122 * output, transparent, incompatibilities with AT&T troff: Implementation Differences.
1123 * output, troff:                         gtroff Output.
1124 * overlapping characters:                Using Symbols.
1125 * overstriking glyphs (\o):              Page Motions.
1126 * P unit:                                Measurements.
1127 * p unit:                                Measurements.
1128 * packages, macros:                      Macro Packages.
1129 * padding character, for fields (fc):    Fields.
1130 * page break, conditional (ne):          Page Control.
1131 * page control:                          Page Control.
1132 * page footers:                          Page Location Traps.
1133 * page headers:                          Page Location Traps.
1134 * page layout:                           Page Layout.
1135 * page layout [ms]:                      ms Page Layout.
1136 * page length (pl):                      Page Layout.
1137 * page length register (.p):             Page Layout.
1138 * page location traps:                   Page Location Traps.
1139 * page location, vertical, marking (mk): Page Motions.
1140 * page location, vertical, returning to marked (rt): Page Motions.
1141 * page motions:                          Page Motions.
1142 * page number (pn):                      Page Layout.
1143 * page number character (%):             Page Layout.
1144 * page number character, changing (pc):  Page Layout.
1145 * page number register (%):              Page Layout.
1146 * page offset (po):                      Line Layout.
1147 * page, new (bp):                        Page Control.
1148 * paper formats:                         Paper Formats.
1149 * paragraphs:                            Paragraphs.
1150 * parameters:                            Parameters.
1151 * parentheses:                           Expressions.
1152 * path, for font files:                  Font Directories.
1153 * path, for tmac files:                  Macro Directories.
1154 * patterns for hyphenation (hpf):        Manipulating Hyphenation.
1155 * pi request, and groff:                 I/O.
1156 * pi request, and safer mode:            Groff Options.
1157 * pic, the program:                      gpic.
1158 * pica unit (P):                         Measurements.
1159 * pile, glyph (\b):                      Drawing Requests.
1160 * pl request, using + and -:             Expressions.
1161 * planting a trap:                       Traps.
1162 * platform-specific directory:           Macro Directories.
1163 * pn request, using + and -:             Expressions.
1164 * po request, using + and -:             Expressions.
1165 * point size registers (.s, .ps):        Changing Type Sizes.
1166 * point size registers, last-requested (.psr, .sr): Fractional Type Sizes.
1167 * point sizes, changing (ps, \s):        Changing Type Sizes.
1168 * point sizes, fractional <1>:           Implementation Differences.
1169 * point sizes, fractional:               Fractional Type Sizes.
1170 * point unit (p):                        Measurements.
1171 * polygon, drawing (\D'p ...'):          Drawing Requests.
1172 * polygon, solid, drawing (\D'P ...'):   Drawing Requests.
1173 * position of lowest text line (.h):     Diversions.
1174 * position, absolute, operator (|):      Expressions.
1175 * position, horizontal input line, saving (\k): Page Motions.
1176 * position, horizontal, in input line, register (hp): Page Motions.
1177 * position, horizontal, in output line, register (.k): Page Motions.
1178 * position, vertical, in diversion, register (.d): Diversions.
1179 * positions, font:                       Font Positions.
1180 * post-vertical line spacing:            Changing Type Sizes.
1181 * post-vertical line spacing register (.pvs): Changing Type Sizes.
1182 * post-vertical line spacing, changing (pvs): Changing Type Sizes.
1183 * postprocessor access:                  Postprocessor Access.
1184 * postprocessors:                        Output device intro.
1185 * PostScript fonts:                      Font Families.
1186 * PostScript, bounding box:              Miscellaneous.
1187 * PostScript, embedding:                 Embedding PostScript.
1188 * prefix, for commands:                  Environment.
1189 * preprocessor, calling convention:      Preprocessors in man pages.
1190 * preprocessors <1>:                     Preprocessors.
1191 * preprocessors:                         Preprocessor Intro.
1192 * previous font (ft, \f[], \fP):         Changing Fonts.
1193 * print current page register (.P):      Groff Options.
1194 * printing backslash (\\, \e, \E, \[rs]) <1>: Implementation Differences.
1195 * printing backslash (\\, \e, \E, \[rs]): Escapes.
1196 * printing line numbers (nm):            Miscellaneous.
1197 * printing to stderr (tm, tm1, tmc):     Debugging.
1198 * printing, zero-width (\z, \Z):         Page Motions.
1199 * process ID of gtroff register ($$):    Built-in Registers.
1200 * processing next file (nx):             I/O.
1201 * properties of characters (cflags):     Using Symbols.
1202 * properties of glyphs (cflags):         Using Symbols.
1203 * ps request, and constant glyph space mode: Artificial Fonts.
1204 * ps request, incompatibilities with AT&T troff: Implementation Differences.
1205 * ps request, using + and -:             Expressions.
1206 * ps request, with fractional type sizes: Fractional Type Sizes.
1207 * pso request, and safer mode:           Groff Options.
1208 * pvs request, using + and -:            Expressions.
1209 * quotes, major:                         Displays.
1210 * quotes, trailing:                      Strings.
1211 * ragged-left:                           Manipulating Filling and Adjusting.
1212 * ragged-right:                          Manipulating Filling and Adjusting.
1213 * rc request, and glyph definitions:     Using Symbols.
1214 * read-only register, changing format:   Assigning Formats.
1215 * reading from standard input (rd):      I/O.
1216 * recursive macros:                      while.
1217 * refer, and macro names starting with [ or ]: Identifiers.
1218 * refer, the program:                    grefer.
1219 * reference, gtroff:                     gtroff Reference.
1220 * references [ms]:                       ms Insertions.
1221 * register, creating alias (aln):        Setting Registers.
1222 * register, format (\g):                 Assigning Formats.
1223 * register, removing (rr):               Setting Registers.
1224 * register, renaming (rnn):              Setting Registers.
1225 * registers:                             Registers.
1226 * registers specific to grohtml:         grohtml specific registers and strings.
1227 * registers, built-in:                   Built-in Registers.
1228 * registers, interpolating (\n):         Interpolating Registers.
1229 * registers, setting (nr, \R):           Setting Registers.
1230 * removing diversion (rm):               Strings.
1231 * removing glyph definition (rchar):     Using Symbols.
1232 * removing macro (rm):                   Strings.
1233 * removing number register (rr):         Setting Registers.
1234 * removing request (rm):                 Strings.
1235 * removing string (rm):                  Strings.
1236 * renaming diversion (rn):               Strings.
1237 * renaming macro (rn):                   Strings.
1238 * renaming number register (rnn):        Setting Registers.
1239 * renaming request (rn):                 Strings.
1240 * renaming string (rn):                  Strings.
1241 * request arguments:                     Request Arguments.
1242 * request, removing (rm):                Strings.
1243 * request, renaming (rn):                Strings.
1244 * request, undefined:                    Comments.
1245 * requests:                              Requests.
1246 * requests for drawing:                  Drawing Requests.
1247 * requests for input and output:         I/O.
1248 * resolution, horizontal, register (.H): Built-in Registers.
1249 * resolution, vertical, register (.V):   Built-in Registers.
1250 * returning to marked vertical page location (rt): Page Motions.
1251 * revision number register (.Y):         Built-in Registers.
1252 * rf, the program:                       History.
1253 * right-justifying (rj):                 Manipulating Filling and Adjusting.
1254 * rj request, causing implicit linebreak: Manipulating Filling and Adjusting.
1255 * rn glyph, and cflags:                  Using Symbols.
1256 * roff, the program:                     History.
1257 * roman glyph, correction after italic glyph (\/): Ligatures and Kerning.
1258 * roman glyph, correction before italic glyph (\,): Ligatures and Kerning.
1259 * Roman numerals:                        Assigning Formats.
1260 * Roman numerals, maximum and minimum:   Assigning Formats.
1261 * rq glyph, and rq string [man]:         Predefined man strings.
1262 * rq glyph, at end of sentence <1>:      Using Symbols.
1263 * rq glyph, at end of sentence:          Sentences.
1264 * rt request, using + and -:             Expressions.
1265 * ru glyph, and cflags:                  Using Symbols.
1266 * runoff, the program:                   History.
1267 * s unit <1>:                            Fractional Type Sizes.
1268 * s unit:                                Measurements.
1269 * safer mode <1>:                        I/O.
1270 * safer mode <2>:                        Macro Directories.
1271 * safer mode:                            Groff Options.
1272 * saving horizontal input line position (\k): Page Motions.
1273 * scaling operator:                      Expressions.
1274 * searching fonts:                       Font Directories.
1275 * searching macro files:                 Macro Directories.
1276 * searching macros:                      Macro Directories.
1277 * seconds, current time (seconds):       Built-in Registers.
1278 * sentence space:                        Sentences.
1279 * sentence space size register (.sss):   Manipulating Filling and Adjusting.
1280 * sentences:                             Sentences.
1281 * setting diversion trap (dt):           Diversion Traps.
1282 * setting end-of-input trap (em):        End-of-input Traps.
1283 * setting input line number (lf):        Debugging.
1284 * setting input line trap (it):          Input Line Traps.
1285 * setting registers (nr, \R):            Setting Registers.
1286 * shading filled objects (\D'f ...'):    Drawing Requests.
1287 * shc request, and translations:         Character Translations.
1288 * site-specific directory <1>:           Font Directories.
1289 * site-specific directory:               Macro Directories.
1290 * size of sentence space register (.sss): Manipulating Filling and Adjusting.
1291 * size of type:                          Sizes.
1292 * size of word space register (.ss):     Manipulating Filling and Adjusting.
1293 * sizes:                                 Sizes.
1294 * sizes, fractional <1>:                 Implementation Differences.
1295 * sizes, fractional:                     Fractional Type Sizes.
1296 * slant, font, changing (\S):            Artificial Fonts.
1297 * soelim, the program:                   gsoelim.
1298 * soft hyphen character, setting (shc):  Manipulating Hyphenation.
1299 * soft hyphen glyph (hy):                Manipulating Hyphenation.
1300 * solid circle, drawing (\D'C ...'):     Drawing Requests.
1301 * solid ellipse, drawing (\D'E ...'):    Drawing Requests.
1302 * solid polygon, drawing (\D'P ...'):    Drawing Requests.
1303 * sp request, and no-space mode:         Manipulating Spacing.
1304 * sp request, causing implicit linebreak: Manipulating Filling and Adjusting.
1305 * space between sentences:               Sentences.
1306 * space between sentences register (.sss): Manipulating Filling and Adjusting.
1307 * space between words register (.ss):    Manipulating Filling and Adjusting.
1308 * space character:                       Escapes.
1309 * space character, zero width (\&) <1>:  Drawing Requests.
1310 * space character, zero width (\&) <2>:  Ligatures and Kerning.
1311 * space character, zero width (\&):      Requests.
1312 * space characters, in expressions:      Expressions.
1313 * space, horizontal (\h):                Page Motions.
1314 * space, horizontal, unformatting:       Strings.
1315 * space, unbreakable:                    Page Motions.
1316 * space, vertical, unit (v):             Measurements.
1317 * space, width of a digit (\0):          Page Motions.
1318 * spaces with ds:                        Strings.
1319 * spaces, leading and trailing:          Filling and Adjusting.
1320 * spacing:                               Basics.
1321 * spacing, manipulating:                 Manipulating Spacing.
1322 * spacing, vertical:                     Sizes.
1323 * special characters <1>:                Special Characters.
1324 * special characters:                    Character Translations.
1325 * special characters [ms]:               ms Strings and Special Characters.
1326 * special fonts <1>:                     Font File Format.
1327 * special fonts <2>:                     Special Fonts.
1328 * special fonts:                         Using Symbols.
1329 * special fonts, emboldening:            Artificial Fonts.
1330 * special request, and font translations: Changing Fonts.
1331 * spline, drawing (\D'~ ...'):           Drawing Requests.
1332 * springing a trap:                      Traps.
1333 * stacking glyphs (\b):                  Drawing Requests.
1334 * standard input, reading from (rd):     I/O.
1335 * stderr, printing to (tm, tm1, tmc):    Debugging.
1336 * stops, tabulator:                      Tab Stops.
1337 * string arguments:                      Strings.
1338 * string expansion (\*):                 Strings.
1339 * string interpolation (\*):             Strings.
1340 * string, appending (as):                Strings.
1341 * string, creating alias (als):          Strings.
1342 * string, length of (length):            Strings.
1343 * string, removing (rm):                 Strings.
1344 * string, renaming (rn):                 Strings.
1345 * strings:                               Strings.
1346 * strings [ms]:                          ms Strings and Special Characters.
1347 * strings specific to grohtml:           grohtml specific registers and strings.
1348 * strings, multi-line:                   Strings.
1349 * strings, shared name space with macros and diversions: Strings.
1350 * stripping final newline in diversions: Strings.
1351 * structuring source code of documents or macro packages: Requests.
1352 * sty request, and changing fonts:       Changing Fonts.
1353 * sty request, and font positions:       Font Positions.
1354 * sty request, and font translations:    Changing Fonts.
1355 * styles, font:                          Font Families.
1356 * substring (substring):                 Strings.
1357 * suppressing output (\O):               Suppressing output.
1358 * sv request, and no-space mode:         Page Control.
1359 * switching environments (ev):           Environments.
1360 * sy request, and safer mode:            Groff Options.
1361 * symbol:                                Using Symbols.
1362 * symbol table, dumping (pm):            Debugging.
1363 * symbol, defining (char):               Using Symbols.
1364 * symbols, using:                        Using Symbols.
1365 * system() return value register (systat): I/O.
1366 * tab character <1>:                     Escapes.
1367 * tab character:                         Tab Stops.
1368 * tab character, and translations:       Character Translations.
1369 * tab character, non-interpreted (\t):   Tabs and Fields.
1370 * tab repetition character (tc):         Tabs and Fields.
1371 * tab settings register (.tabs):         Tabs and Fields.
1372 * tab stops:                             Tab Stops.
1373 * tab stops [man]:                       Miscellaneous man macros.
1374 * tab stops, for TTY output devices:     Tabs and Fields.
1375 * tab, line-tabs mode:                   Tabs and Fields.
1376 * table of contents <1>:                 Leaders.
1377 * table of contents:                     Table of Contents.
1378 * table of contents, creating [ms]:      ms TOC.
1379 * tables [ms]:                           ms Insertions.
1380 * tabs, and fields:                      Tabs and Fields.
1381 * tabs, before comments:                 Comments.
1382 * tbl, the program:                      gtbl.
1383 * text line, position of lowest (.h):    Diversions.
1384 * text, gtroff processing:               Text.
1385 * text, justifying:                      Manipulating Filling and Adjusting.
1386 * text, justifying (rj):                 Manipulating Filling and Adjusting.
1387 * thickness of lines (\D't ...'):        Drawing Requests.
1388 * three-part title (tl):                 Page Layout.
1389 * ti request, causing implicit linebreak: Manipulating Filling and Adjusting.
1390 * ti request, using + and -:             Expressions.
1391 * time, current:                         I/O.
1392 * time, current, hours (hours):          Built-in Registers.
1393 * time, current, minutes (minutes):      Built-in Registers.
1394 * time, current, seconds (seconds):      Built-in Registers.
1395 * title line (tl):                       Page Layout.
1396 * title line length register (.lt):      Page Layout.
1397 * title line, length (lt):               Page Layout.
1398 * title page, example markup:            ms Cover Page Macros.
1399 * titles:                                Page Layout.
1400 * tkf request, and font styles:          Font Families.
1401 * tkf request, and font translations:    Changing Fonts.
1402 * tkf request, with fractional type sizes: Fractional Type Sizes.
1403 * tl request, and mc:                    Miscellaneous.
1404 * tmac, directory:                       Macro Directories.
1405 * tmac, path:                            Macro Directories.
1406 * TMPDIR, environment variable:          Environment.
1407 * token, input:                          Gtroff Internals.
1408 * top margin:                            Page Layout.
1409 * top-level diversion:                   Diversions.
1410 * top-level diversion, and \!:           Diversions.
1411 * top-level diversion, and \?:           Diversions.
1412 * top-level diversion, and bp:           Page Control.
1413 * tr request, and glyph definitions:     Using Symbols.
1414 * tr request, and soft hyphen character: Manipulating Hyphenation.
1415 * tr request, incompatibilities with AT&T troff: Implementation Differences.
1416 * track kerning:                         Ligatures and Kerning.
1417 * track kerning, activating (tkf):       Ligatures and Kerning.
1418 * trailing quotes:                       Strings.
1419 * trailing spaces:                       Filling and Adjusting.
1420 * translations of characters:            Character Translations.
1421 * transparent characters <1>:            Using Symbols.
1422 * transparent characters:                Sentences.
1423 * transparent output (\!, \?):           Diversions.
1424 * transparent output (cf, trf):          I/O.
1425 * transparent output, incompatibilities with AT&T troff: Implementation Differences.
1426 * trap, changing location (ch):          Page Location Traps.
1427 * trap, distance, register (.t):         Page Location Traps.
1428 * trap, diversion, setting (dt):         Diversion Traps.
1429 * trap, end-of-input, setting (em):      End-of-input Traps.
1430 * trap, input line, setting (it):        Input Line Traps.
1431 * trap, planting:                        Traps.
1432 * trap, springing:                       Traps.
1433 * traps:                                 Traps.
1434 * traps, blank line:                     Blank Line Traps.
1435 * traps, diversion:                      Diversion Traps.
1436 * traps, dumping (ptr):                  Debugging.
1437 * traps, end-of-input:                   End-of-input Traps.
1438 * traps, input line:                     Input Line Traps.
1439 * traps, input line, and interrupted lines (itc): Input Line Traps.
1440 * traps, page location:                  Page Location Traps.
1441 * trf request, and invalid characters:   I/O.
1442 * trf request, causing implicit linebreak: Manipulating Filling and Adjusting.
1443 * trin request, and asciify:             Diversions.
1444 * troff mode:                            Troff and Nroff Mode.
1445 * troff output:                          gtroff Output.
1446 * truncated vertical space register (.trunc): Page Location Traps.
1447 * tutorial for macro users:              Tutorial for Macro Users.
1448 * type size:                             Sizes.
1449 * type size registers (.s, .ps):         Changing Type Sizes.
1450 * type sizes, changing (ps, \s):         Changing Type Sizes.
1451 * type sizes, fractional <1>:            Implementation Differences.
1452 * type sizes, fractional:                Fractional Type Sizes.
1453 * u unit:                                Measurements.
1454 * uf request, and font styles:           Font Families.
1455 * ul glyph, and cflags:                  Using Symbols.
1456 * ul request, and font translations:     Changing Fonts.
1457 * unary operators:                       Expressions.
1458 * unbreakable space:                     Page Motions.
1459 * undefined identifiers:                 Identifiers.
1460 * undefined request:                     Comments.
1461 * underline font (uf):                   Artificial Fonts.
1462 * underlining (ul):                      Artificial Fonts.
1463 * underlining, continuous (cu):          Artificial Fonts.
1464 * underscore glyph (\[ru]):              Drawing Requests.
1465 * unformatting diversions (asciify):     Diversions.
1466 * unformatting horizontal space:         Strings.
1467 * Unicode <1>:                           Using Symbols.
1468 * Unicode:                               Identifiers.
1469 * unit, c:                               Measurements.
1470 * unit, f:                               Measurements.
1471 * unit, f, and colors:                   Colors.
1472 * unit, i:                               Measurements.
1473 * unit, M:                               Measurements.
1474 * unit, m:                               Measurements.
1475 * unit, n:                               Measurements.
1476 * unit, P:                               Measurements.
1477 * unit, p:                               Measurements.
1478 * unit, s <1>:                           Fractional Type Sizes.
1479 * unit, s:                               Measurements.
1480 * unit, u:                               Measurements.
1481 * unit, v:                               Measurements.
1482 * unit, z <1>:                           Fractional Type Sizes.
1483 * unit, z:                               Measurements.
1484 * units of measurement:                  Measurements.
1485 * units, default:                        Default Units.
1486 * unnamed glyphs:                        Using Symbols.
1487 * unnamed glyphs, accessing with \N:     Font File Format.
1488 * unsafe mode <1>:                       I/O.
1489 * unsafe mode <2>:                       Macro Directories.
1490 * unsafe mode:                           Groff Options.
1491 * user's macro tutorial:                 Tutorial for Macro Users.
1492 * user's tutorial for macros:            Tutorial for Macro Users.
1493 * using symbols:                         Using Symbols.
1494 * utf-8, encoding:                       Groff Options.
1495 * v unit:                                Measurements.
1496 * valid numeric expression:              Expressions.
1497 * value, incrementing without changing the register: Auto-increment.
1498 * variables in environment:              Environment.
1499 * version number, major, register (.x):  Built-in Registers.
1500 * version number, minor, register (.y):  Built-in Registers.
1501 * vertical line drawing (\L):            Drawing Requests.
1502 * vertical line spacing register (.v):   Changing Type Sizes.
1503 * vertical line spacing, changing (vs):  Changing Type Sizes.
1504 * vertical line spacing, effective value: Changing Type Sizes.
1505 * vertical motion (\v):                  Page Motions.
1506 * vertical page location, marking (mk):  Page Motions.
1507 * vertical page location, returning to marked (rt): Page Motions.
1508 * vertical position in diversion register (.d): Diversions.
1509 * vertical position trap enable register (.vpt): Page Location Traps.
1510 * vertical position traps, enabling (vpt): Page Location Traps.
1511 * vertical resolution register (.V):     Built-in Registers.
1512 * vertical space unit (v):               Measurements.
1513 * vertical spacing:                      Sizes.
1514 * warnings <1>:                          Warnings.
1515 * warnings:                              Debugging.
1516 * warnings, level (warn):                Debugging.
1517 * what is groff?:                        What Is groff?.
1518 * while:                                 while.
1519 * while request, and the ! operator:     Expressions.
1520 * while request, confusing with br:      while.
1521 * while request, operators to use with:  Operators in Conditionals.
1522 * whitespace characters:                 Identifiers.
1523 * width escape (\w):                     Page Motions.
1524 * word space size register (.ss):        Manipulating Filling and Adjusting.
1525 * writing macros:                        Writing Macros.
1526 * writing to file (write):               I/O.
1527 * year, current, register (year, yr):    Built-in Registers.
1528 * z unit <1>:                            Fractional Type Sizes.
1529 * z unit:                                Measurements.
1530 * zero width space character (\&) <1>:   Drawing Requests.
1531 * zero width space character (\&) <2>:   Ligatures and Kerning.
1532 * zero width space character (\&):       Requests.
1533 * zero-width printing (\z, \Z):          Page Motions.
1534 * |, and page motion:                    Expressions.
1535
1536