| Index Entry | | Section |
|---|
|
| " | | |
|---|
| ", as delimiter: | | Delimiters |
| ", at end of sentence: | | Sentences |
| ", at end of sentence: | | Using Symbols |
| ", embedding in a macro argument: | | Calling Macros |
|
| % | | |
|---|
| %, as delimiter: | | Delimiters |
|
| & | | |
|---|
| &, as delimiter: | | Delimiters |
|
| ' | | |
|---|
| ', as a comment: | | Comments |
| ', as delimiter: | | Delimiters |
| ', at end of sentence: | | Sentences |
| ', at end of sentence: | | Using Symbols |
|
| ( | | |
|---|
| (, as delimiter: | | Delimiters |
|
| ) | | |
|---|
| ), as delimiter: | | Delimiters |
| ), at end of sentence: | | Sentences |
| ), at end of sentence: | | Using Symbols |
|
| * | | |
|---|
| *, as delimiter: | | Delimiters |
| *, at end of sentence: | | Sentences |
| *, at end of sentence: | | Using Symbols |
|
| + | | |
|---|
| +, and page motion: | | Numeric Expressions |
| +, as delimiter: | | Delimiters |
|
| - | | |
|---|
| -, and page motion: | | Numeric Expressions |
| -, as delimiter: | | Delimiters |
|
| . | | |
|---|
| ., as delimiter: | | Delimiters |
| .h register, difference from nl: | | Diversions |
| .ps register, in comparison with .psr: | | Using Fractional Type Sizes |
| .s register, in comparison with .sr: | | Using Fractional Type Sizes |
| .S register, Plan 9 alias for .tabs: | | Tabs and Fields |
| .t register, and diversions: | | Diversion Traps |
| .tabs register, Plan 9 alias (.S): | | Tabs and Fields |
| .V register, and vs: | | Changing the Vertical Spacing |
|
| / | | |
|---|
| /, as delimiter: | | Delimiters |
|
| 8 | | |
|---|
| 8-bit input: | | Font Description File Format |
|
| : | | |
|---|
| :, as delimiter: | | Delimiters |
|
| < | | |
|---|
| <, as delimiter: | | Delimiters |
|
| = | | |
|---|
| =, as delimiter: | | Delimiters |
|
| > | | |
|---|
| >, as delimiter: | | Delimiters |
|
| [ | | |
|---|
| [, macro names starting with, and refer: | | Identifiers |
|
| \ | | |
|---|
| \!, and copy mode: | | Diversions |
| \!, and output request: | | Diversions |
| \!, and trnt: | | Character Translations |
| \!, as delimiter: | | Delimiters |
| \!, as delimiter: | | Delimiters |
| \!, in top-level diversion: | | Diversions |
| \!, incompatibilities with AT&T troff: | | Other Differences |
| \!, incompatibilities with AT&T troff: | | Other Differences |
| \$, when reading text for a macro: | | Copy Mode |
| \%, and translations: | | Character Translations |
| \%, as delimiter: | | Delimiters |
| \%, as delimiter: | | Delimiters |
| \%, following \X or \Y: | | Manipulating Hyphenation |
| \%, in \X: | | Postprocessor Access |
| \%, incompatibilities with AT&T troff: | | Other Differences |
| \&, and glyph definitions: | | Using Symbols |
| \&, and translations: | | Character Translations |
| \&, as delimiter: | | Delimiters |
| \&, at end of sentence: | | Sentences |
| \&, in \X: | | Postprocessor Access |
| \&, incompatibilities with AT&T troff: | | Other Differences |
| \', and translations: | | Character Translations |
| \', as delimiter: | | Delimiters |
| \', as delimiter: | | Delimiters |
| \', incompatibilities with AT&T troff: | | Other Differences |
| \(, and translations: | | Character Translations |
| \), as delimiter: | | Delimiters |
| \), in \X: | | Postprocessor Access |
| \*, and warnings: | | Warnings |
| \*, incompatibilities with AT&T troff: | | Compatibility Mode |
| \*, when reading text for a macro: | | Copy Mode |
| \, disabling (eo): | | Using Escape Sequences |
| \, embedding in a macro argument: | | Calling Macros |
| \,, as delimiter: | | Delimiters |
| \- glyph, and cflags: | | Using Symbols |
| \-, and translations: | | Character Translations |
| \-, as delimiter: | | Delimiters |
| \-, as delimiter: | | Delimiters |
| \-, incompatibilities with AT&T troff: | | Other Differences |
| \/, as delimiter: | | Delimiters |
| \/, as delimiter: | | Delimiters |
| \0, as delimiter: | | Delimiters |
| \:, as delimiter: | | Delimiters |
| \:, as delimiter: | | Delimiters |
| \:, in \X: | | Postprocessor Access |
| \?, and copy mode: | | Operators in Conditionals |
| \?, and copy mode: | | Diversions |
| \?, as delimiter: | | Delimiters |
| \?, in top-level diversion: | | Diversions |
| \?, incompatibilities with AT&T troff: | | Other Differences |
| \a, and copy mode: | | Leaders |
| \a, and translations: | | Character Translations |
| \a, as delimiter: | | Delimiters |
| \A, delimiters allowed by: | | Delimiters |
| \A, incompatibilities with AT&T troff: | | Other Differences |
| \b, delimiters allowed by: | | Delimiters |
| \b, limitations of: | | Drawing Geometric Objects |
| \C, and translations: | | Character Translations |
| \c, as delimiter: | | Delimiters |
| \c, as delimiter: | | Delimiters |
| \c, incompatibilities with AT&T troff: | | Other Differences |
| \c, when filling disabled: | | Line Continuation |
| \c, when filling enabled: | | Line Continuation |
| \d, as delimiter: | | Delimiters |
| \D, delimiters allowed by: | | Delimiters |
| \e, and glyph definitions: | | Using Symbols |
| \e, and translations: | | Character Translations |
| \e, as delimiter: | | Delimiters |
| \E, as delimiter: | | Delimiters |
| \e, as delimiter: | | Delimiters |
| \e, incompatibilities with AT&T troff: | | Other Differences |
| \F, and changing fonts: | | Selecting Fonts |
| \f, and font translations: | | Selecting Fonts |
| \f, incompatibilities with AT&T troff: | | Compatibility Mode |
| \h, delimiters allowed by: | | Delimiters |
| \H, delimiters allowed by: | | Delimiters |
| \H, incompatibilities with AT&T troff: | | Compatibility Mode |
| \H, using + and - with: | | Numeric Expressions |
| \H, with fractional type sizes: | | Using Fractional Type Sizes |
| \l, and glyph definitions: | | Using Symbols |
| \L, and glyph definitions: | | Using Symbols |
| \l, delimiters allowed by: | | Delimiters |
| \L, delimiters allowed by: | | Delimiters |
| \N, and translations: | | Character Translations |
| \n, and warnings: | | Warnings |
| \N, delimiters allowed by: | | Delimiters |
| \n, incompatibilities with AT&T troff: | | Compatibility Mode |
| \n, when reading text for a macro: | | Copy Mode |
| \o, delimiters allowed by: | | Delimiters |
| \p, as delimiter: | | Delimiters |
| \p, as delimiter: | | Delimiters |
| \R, after \c: | | Line Continuation |
| \R, and warnings: | | Warnings |
| \r, as delimiter: | | Delimiters |
| \R, delimiters allowed by: | | Delimiters |
| \R, difference from nr: | | Auto-increment |
| \R, using + and - with: | | Numeric Expressions |
| \RET, when reading text for a macro: | | Copy Mode |
| \s, delimiters allowed by: | | Delimiters |
| \S, delimiters allowed by: | | Delimiters |
| \s, incompatibilities with AT&T troff: | | Compatibility Mode |
| \S, incompatibilities with AT&T troff: | | Compatibility Mode |
| \s, incompatibilities with AT&T troff: | | Compatibility Mode |
| \s, using + and - with: | | Numeric Expressions |
| \s, with fractional type sizes: | | Using Fractional Type Sizes |
| \SP, as delimiter: | | Delimiters |
| \SP, difference from \~: | | Calling Macros |
| \SP, incompatibilities with AT&T troff: | | Other Differences |
| \t, and copy mode: | | Tabs and Fields |
| \t, and translations: | | Character Translations |
| \t, and warnings: | | Warnings |
| \t, as delimiter: | | Delimiters |
| \u, as delimiter: | | Delimiters |
| \V, and copy mode: | | I/O |
| \v, delimiters allowed by: | | Delimiters |
| \v, internal representation: | | Gtroff Internals |
| \w, delimiters allowed by: | | Delimiters |
| \X, and special characters: | | Postprocessor Access |
| \X, delimiters allowed by: | | Delimiters |
| \x, delimiters allowed by: | | Delimiters |
| \X, followed by \%: | | Manipulating Hyphenation |
| \Y, followed by \%: | | Manipulating Hyphenation |
| \Z, delimiters allowed by: | | Delimiters |
| \[, and translations: | | Character Translations |
| \\, when reading text for a macro: | | Copy Mode |
| \^, as delimiter: | | Delimiters |
| \^, incompatibilities with AT&T troff: | | Other Differences |
| \_, and translations: | | Character Translations |
| \_, as delimiter: | | Delimiters |
| \_, as delimiter: | | Delimiters |
| \_, incompatibilities with AT&T troff: | | Other Differences |
| \`, and translations: | | Character Translations |
| \`, as delimiter: | | Delimiters |
| \`, as delimiter: | | Delimiters |
| \`, incompatibilities with AT&T troff: | | Other Differences |
| \{, as delimiter: | | Delimiters |
| \{, as delimiter: | | Delimiters |
| \{, incompatibilities with AT&T troff: | | Other Differences |
| \|, as delimiter: | | Delimiters |
| \|, incompatibilities with AT&T troff: | | Other Differences |
| \}, and warnings: | | Warnings |
| \}, as delimiter: | | Delimiters |
| \}, as delimiter: | | Delimiters |
| \}, incompatibilities with AT&T troff: | | Other Differences |
| \~, and translations: | | Character Translations |
| \~, as delimiter: | | Delimiters |
| \~, difference from \SP: | | Calling Macros |
| \~, incompatibilities with AT&T troff: | | Other Differences |
|
| ] | | |
|---|
| ], as part of an identifier: | | Identifiers |
| ], at end of sentence: | | Sentences |
| ], at end of sentence: | | Using Symbols |
| ], macro names starting with, and refer: | | Identifiers |
|
| | | | |
|---|
| |, and page motion: | | Numeric Expressions |
|
| A | | |
|---|
| ab request, incompatibilities with AT&T troff: | | Other Differences |
| aborting (ab): | | Debugging |
| absolute (sic) position operator (|): | | Numeric Expressions |
| abstract font style: | | Using Fonts |
| abstract font style, setting up (sty): | | Font Families |
| accent marks [ms]: | | ms Legacy Features |
| access to postprocessor: | | Postprocessor Access |
| accessing unnamed glyphs with \N: | | Font Description File Format |
| activating kerning (kern): | | Ligatures and Kerning |
| activating ligatures (lg): | | Ligatures and Kerning |
| activating track kerning (tkf): | | Ligatures and Kerning |
| ad request, and hyphenation margin: | | Manipulating Hyphenation |
| ad request, and hyphenation space: | | Manipulating Hyphenation |
| addition: | | Numeric Expressions |
| additional inter-sentence space: | | Manipulating Filling and Adjustment |
| adjustment and filling, manipulating: | | Manipulating Filling and Adjustment |
| adjustment mode register (.j): | | Manipulating Filling and Adjustment |
| adjustment to both margins, difference from AT&T troff: | | Other Differences |
| Adobe Glyph List (AGL): | | Using Symbols |
| alias, diversion, creating (als): | | Strings |
| alias, diversion, removing (rm): | | Strings |
| alias, macro, creating (als): | | Strings |
| alias, macro, removing (rm): | | Strings |
| alias, register, creating (aln): | | Setting Registers |
| alias, register, removing (rr): | | Setting Registers |
| alias, string, creating (als): | | Strings |
| alias, string, removing (rm): | | Strings |
| aliasing fonts with third argument to fp request: | | Font Positions |
| als request, and \$0: | | Parameters |
| am, am1, ami requests, and warnings: | | Warnings |
| appending to a diversion (da, boxa): | | Diversions |
| appending to a file (opena): | | I/O |
| appending to a macro (am): | | Writing Macros |
| appending to a string (as): | | Strings |
| approximation output register (.A): | | Built-in Registers |
| arc, drawing (‘\D'a …'’): | | Drawing Geometric Objects |
| argument: | | Requests and Macros |
| arguments to macros: | | Calling Macros |
| arguments to macros, and tabs: | | Invoking Requests |
| arguments to requests: | | Invoking Requests |
| arguments to requests, and tabs: | | Invoking Requests |
| arguments, and compatibility mode: | | Gtroff Internals |
| arguments, to escape sequences, delimiting: | | Delimiters |
| arguments, to strings: | | Strings |
| arithmetic operators: | | Numeric Expressions |
| artificial fonts: | | Artificial Fonts |
| as, as1 requests, and comments: | | Comments |
| as, as1 requests, and warnings: | | Warnings |
| ASCII output encoding: | | Groff Options |
| asciify request, and writem: | | I/O |
| assertion (arithmetic operator): | | Numeric Expressions |
| assign number format to register (af): | | Assigning Register Formats |
| assignments, indirect: | | Interpolating Registers |
| assignments, nested: | | Interpolating Registers |
| AT&T ms, macro package differences: | | Differences from AT&T ms |
| attributes, character cell: | | Using Fonts |
| auto-incrementation of a register: | | Auto-increment |
| automatic font mounting: | | Selecting Fonts |
| automatic hyphenation: | | Manipulating Hyphenation |
| automatic hyphenation parameters: | | Manipulating Hyphenation |
| auxiliary macro package: | | Major Macro Packages |
| available glyphs, list of (groff_char(7) man page): | | Using Symbols |
|
| B | | |
|---|
| background: | | Background |
| background color name register (.M): | | Colors |
| backslash glyph, formatting (\[rs]): | | Using Escape Sequences |
| backslash, embedding in a macro argument: | | Calling Macros |
| backslash, printing (\\, \e, \E, \[rs]): | | Other Differences |
| backspace character, and translations: | | Character Translations |
| backtrace of input stack (backtrace): | | Debugging |
| baseline rule special character(\[ru]): | | Drawing Geometric Objects |
| baseline, text: | | Page Geometry |
| baseline, text: | | Manipulating Type Size and Vertical Spacing |
| basic scaling unit (u): | | Measurements |
| basic units: | | Page Geometry |
| basic units, conversion to: | | Measurements |
| basics of macro package usage: | | Basics |
| bd request, and font styles: | | Font Families |
| bd request, and font translations: | | Selecting Fonts |
| bd request, incompatibilities with AT&T troff: | | Other Differences |
| beginning diversion (di, box): | | Diversions |
| beginning of conditional block (\{): | | Conditional Blocks |
| blank line: | | Breaking |
| blank line macro (blm): | | Breaking |
| blank line macro (blm): | | Invoking Requests |
| blank line macro (blm): | | Blank Line Traps |
| blank line trap (blm): | | Invoking Requests |
| blank line traps: | | Blank Line Traps |
| blank lines, disabling: | | Manipulating Spacing |
| block, conditional, beginning (\{): | | Conditional Blocks |
| block, conditional, end (\}): | | Conditional Blocks |
| blocks, conditional: | | Conditional Blocks |
| body, of a while request: | | while |
| boldface, imitating (bd): | | Artificial Fonts |
| bottom margin: | | Page Location Traps |
| boundary-relative motion operator (|): | | Numeric Expressions |
| bounding box: | | Miscellaneous |
| box (diversion operation): | | Diversions |
| box request, and warnings: | | Warnings |
| box rule glyph (\[br]): | | Drawing Geometric Objects |
| box, boxa requests, and warnings: | | Warnings |
| boxa request, and dn (dl): | | Diversions |
| boxa request, and warnings: | | Warnings |
| boxes [ms]: | | ms keeps and displays |
| bp request, and top-level diversion: | | Page Control |
| bp request, and traps (.pe): | | Page Location Traps |
| bp request, causing implicit break: | | Manipulating Filling and Adjustment |
| bp request, incompatibilities with AT&T troff: | | Other Differences |
| bp request, using + and - with: | | Numeric Expressions |
| br glyph, and cflags: | | Using Symbols |
| brace escape sequence, closing (\}): | | Conditional Blocks |
| brace escape sequence, opening (\}): | | Conditional Blocks |
| brace escape sequences (\{, \}): | | Conditional Blocks |
| break: | | Breaking |
| break: | | Manipulating Filling and Adjustment |
| break (introduction): | | Basics |
| break request, in a while loop: | | while |
| break, page: | | Page Geometry |
| break, page: | | Page Control |
| break, page: | | The Implicit Page Trap |
| break, page (introduction): | | Basics |
| break, page, final: | | End-of-input Traps |
| break, page, prevented by vpt: | | Vertical Position Traps |
| breaking file names (\:): | | Manipulating Hyphenation |
| breaking URLs (\:): | | Manipulating Hyphenation |
| breaking without hyphens (\:): | | Manipulating Hyphenation |
| built-in register, removing: | | Built-in Registers |
| built-in registers: | | Built-in Registers |
| bulleted list, example markup [ms]: | | Lists in ms |
|
| C | | |
|---|
| c scaling unit: | | Measurements |
| calling a macro: | | Requests and Macros |
| calling macros: | | Calling Macros |
| capabilities of groff: | | groff Capabilities |
| case-transforming a string (stringdown, stringup): | | Strings |
| categories, warning: | | Warnings |
| CCSID 1047 output encoding (EBCDIC): | | Groff Options |
| ce request, causing implicit break: | | Manipulating Filling and Adjustment |
| ce request, difference from ‘.ad c’: | | Manipulating Filling and Adjustment |
| cell, character, attributes: | | Using Fonts |
| centered text (filled): | | Manipulating Filling and Adjustment |
| centered text (unfilled): | | Manipulating Filling and Adjustment |
| centering lines (ce): | | Manipulating Filling and Adjustment |
| centering lines (introduction): | | Basics |
| centimeter scaling unit (c): | | Measurements |
| cf request, and copy mode: | | I/O |
| cf request, causing implicit break: | | Manipulating Filling and Adjustment |
| changing control characters: | | Control Characters |
| changing font family (fam, \F): | | Font Families |
| changing fonts (ft, \f): | | Selecting Fonts |
| changing format, and read-only registers: | | Assigning Register Formats |
| changing the font height (\H): | | Artificial Fonts |
| changing the font slant (\S): | | Artificial Fonts |
| changing the page number character (pc): | | Page Layout |
| changing trap location (ch): | | Page Location Traps |
| changing type sizes (ps, \s): | | Changing the Type Size |
| changing vertical line spacing (vs): | | Changing the Vertical Spacing |
| char request, and soft hyphen character: | | Manipulating Hyphenation |
| char request, and translations: | | Character Translations |
| char request, used with \N: | | Using Symbols |
| character: | | Using Symbols |
| character cell attributes: | | Using Fonts |
| character class (class): | | Character Classes |
| character classes: | | Character Classes |
| character properties (cflags): | | Using Symbols |
| character translations: | | Character Translations |
| character, backspace, and translations: | | Character Translations |
| character, control (.): | | Requests and Macros |
| character, control, changing (cc): | | Control Characters |
| character, defining (char): | | Using Symbols |
| character, defining fallback (fchar, fschar, schar): | | Using Symbols |
| character, distinguished from glyph: | | Using Symbols |
| character, dummy (\&): | | Dummy Characters |
| character, dummy (\&), as control character suppressor: | | Requests and Macros |
| character, dummy (\&), effect on kerning: | | Ligatures and Kerning |
| character, dummy (\&), effect on \l escape sequence: | | Drawing Geometric Objects |
| character, escape, changing (ec): | | Using Escape Sequences |
| character, escape, while defining glyph: | | Using Symbols |
| character, field delimiting (fc): | | Fields |
| character, field padding (fc): | | Fields |
| character, horizontal tab: | | Tabs and Leaders |
| character, hyphenation (\%): | | Manipulating Hyphenation |
| character, leader: | | Tabs and Leaders |
| character, leader repetition (lc): | | Leaders |
| character, leader, and translations: | | Character Translations |
| character, leader, non-interpreted (\a): | | Leaders |
| character, named (\C): | | Using Symbols |
| character, newline, and translations: | | Character Translations |
| character, no-break control ('): | | Requests and Macros |
| character, no-break control, changing (c2): | | Control Characters |
| character, ordinary: | | Identifiers |
| character, soft hyphen, setting (shc): | | Manipulating Hyphenation |
| character, special: | | Character Translations |
| character, tab repetition (tc): | | Tabs and Fields |
| character, tab, and translations: | | Character Translations |
| character, tab, non-interpreted (\t): | | Tabs and Fields |
| character, transparent: | | Using Symbols |
| character, transparent dummy (\)): | | Dummy Characters |
| characters, end-of-sentence: | | Using Symbols |
| characters, end-of-sentence transparent: | | Sentences |
| characters, hyphenation: | | Using Symbols |
| characters, input, and output glyphs, compatibility with AT&T troff: | | Other Differences |
| characters, invalid for trf request: | | I/O |
| characters, invalid input: | | Identifiers |
| characters, overlapping: | | Using Symbols |
| characters, special: | | Sentences |
| characters, special, list of (groff_char(7) man page): | | Using Symbols |
| characters, unnamed, accessing with \N: | | Font Description File Format |
| circle, filled, drawing (‘\D'C …'’): | | Drawing Geometric Objects |
| circle, outlined, drawing (‘\D'c …'’): | | Drawing Geometric Objects |
| circle, solid, drawing (‘\D'C …'’): | | Drawing Geometric Objects |
| circle, stroked, drawing (‘\D'c …'’): | | Drawing Geometric Objects |
| class of characters (class): | | Character Classes |
| classes, character: | | Character Classes |
| clearing input line trap (it, itc): | | Input Line Traps |
| closing brace escape sequence (\}): | | Conditional Blocks |
| closing file (close): | | I/O |
| code page 1047 output encoding: | | Groff Options |
| code page 1047, input encoding: | | Input Encodings |
| code, hyphenation (hcode): | | Manipulating Hyphenation |
| color name, background, register (.M): | | Colors |
| color name, fill, register (.M): | | Colors |
| color name, stroke, register (.m): | | Colors |
| color, default: | | Colors |
| color, fill: | | Colors |
| color, stroke: | | Colors |
| colors: | | Colors |
| command prefix: | | Environment |
| command-line options: | | Groff Options |
| comments: | | Comments |
| comments in device description files: | | DESC File Format |
| comments in font description files: | | Font Description File Format |
| comments, lining up with tabs: | | Comments |
| comments, with ds: | | Strings |
| common features: | | Common Features |
| common name space of macros, diversions, and strings: | | Identifiers |
| comparison of strings: | | Operators in Conditionals |
| comparison operators: | | Numeric Expressions |
| compatibility mode: | | Warnings |
| compatibility mode: | | Compatibility Mode |
| compatibility mode, and parameters: | | Gtroff Internals |
| complementation, logical: | | Numeric Expressions |
| composite glyph names: | | Using Symbols |
| conditional block, beginning (\{): | | Conditional Blocks |
| conditional block, end (\}): | | Conditional Blocks |
| conditional blocks: | | Conditional Blocks |
| conditional expressions: | | Operators in Conditionals |
| conditional output for terminal (TTY): | | Operators in Conditionals |
| conditional page break (ne): | | Page Control |
| conditionals and loops: | | Conditionals and Loops |
| configuring control characters: | | Control Characters |
| configuring the page length (pl): | | Page Layout |
| consecutive hyphenated lines (hlm): | | Manipulating Hyphenation |
| constant glyph space mode (cs): | | Artificial Fonts |
| contents, table of: | | Table of Contents |
| contents, table of: | | Leaders |
| continuation, input line (\RET): | | Line Continuation |
| continuation, output line (\c): | | Line Continuation |
| continue request, in a while loop: | | while |
| continued output line register (.int): | | Line Continuation |
| continuous underlining (cu): | | Artificial Fonts |
| control character (.): | | Requests and Macros |
| control character, changing (cc): | | Control Characters |
| control character, no-break ('): | | Requests and Macros |
| control character, no-break, changing (c2): | | Control Characters |
| control characters: | | Control Characters |
| control line: | | Requests and Macros |
| control, line: | | Line Continuation |
| control, page: | | Page Control |
| conventions for input: | | Input Conventions |
| conversion to basic units: | | Measurements |
| copy mode: | | Copy Mode |
| copy mode: | | Copy Mode |
| copy mode, and cf request: | | I/O |
| copy mode, and device request: | | Postprocessor Access |
| copy mode, and length request: | | Strings |
| copy mode, and macro parameters: | | Parameters |
| copy mode, and output request: | | Diversions |
| copy mode, and trf request: | | I/O |
| copy mode, and write request: | | I/O |
| copy mode, and writec request: | | I/O |
| copy mode, and writem request: | | I/O |
| copy mode, and \!: | | Diversions |
| copy mode, and \?: | | Operators in Conditionals |
| copy mode, and \?: | | Diversions |
| copy mode, and \a: | | Leaders |
| copy mode, and \t: | | Tabs and Fields |
| copy mode, and \V: | | I/O |
| copying environment (evc): | | Environments |
| correction between oblique and upright glyph (\/, \,): | | Italic Corrections |
| correction between upright and oblique glyph (\/, \,): | | Italic Corrections |
| correction, italic (\/): | | Italic Corrections |
| correction, left italic (\,): | | Italic Corrections |
| cover page in [ms], example markup: | | ms Document Description Macros |
| cp request, and glyph definitions: | | Using Symbols |
| cq glyph, at end of sentence: | | Sentences |
| cq glyph, at end of sentence: | | Using Symbols |
| creating alias for register (aln): | | Setting Registers |
| creating alias, for diversion (als): | | Strings |
| creating alias, for macro (als): | | Strings |
| creating alias, for string (als): | | Strings |
| creating new characters (char): | | Using Symbols |
| credits: | | Credits |
| cs request, and font styles: | | Font Families |
| cs request, and font translations: | | Selecting Fonts |
| cs request, incompatibilities with AT&T troff: | | Other Differences |
| cs request, with fractional type sizes: | | Using Fractional Type Sizes |
| CSTR #54 errata: | | Built-in Registers |
| CSTR #54 errata: | | Line Layout |
| CSTR #54 errata: | | Page Control |
| CSTR #54 errata: | | Artificial Fonts |
| CSTR #54 errata: | | Changing the Type Size |
| CSTR #54 errata: | | Page Motions |
| CSTR #54 erratum, bp request: | | Page Control |
| CSTR #54 erratum, po request: | | Line Layout |
| CSTR #54 erratum, ps request: | | Changing the Type Size |
| CSTR #54 erratum, sb register: | | Page Motions |
| CSTR #54 erratum, st register: | | Page Motions |
| CSTR #54 erratum, yr register: | | Built-in Registers |
| CSTR #54 erratum, \S escape: | | Artificial Fonts |
| CSTR #54 erratum, \s escape sequence: | | Changing the Type Size |
| current directory: | | Macro Directories |
| current input file name register (.F): | | Built-in Registers |
| current page number (%): | | Page Control |
| current time, hours (hours): | | Built-in Registers |
| current time, minutes (minutes): | | Built-in Registers |
| current time, seconds (seconds): | | Built-in Registers |
|
| D | | |
|---|
| da request, and dn (dl): | | Diversions |
| da request, and warnings: | | Warnings |
| da request, and warnings: | | Warnings |
| date, day of the month register (dy): | | Built-in Registers |
| date, day of the week register (dw): | | Built-in Registers |
| date, month of the year register (mo): | | Built-in Registers |
| date, year register (year, yr): | | Built-in Registers |
| day of the month register (dy): | | Built-in Registers |
| day of the week register (dw): | | Built-in Registers |
| dd glyph, at end of sentence: | | Sentences |
| dd glyph, at end of sentence: | | Using Symbols |
| de request, and while: | | while |
| de, de1, dei requests, and warnings: | | Warnings |
| debugging: | | Debugging |
| debugging page location traps: | | Page Location Traps |
| decimal point, as delimiter: | | Delimiters |
| decrementation, automatic, of a register: | | Auto-increment |
| default color: | | Colors |
| default tab stops: | | Tabs and Fields |
| default units: | | Default Units |
| deferred output: | | Deferring Output |
| defining character (char): | | Using Symbols |
| defining character class (class): | | Character Classes |
| defining fallback character (fchar, fschar, schar): | | Using Symbols |
| defining glyph (char): | | Using Symbols |
| defining symbol (char): | | Using Symbols |
| delimited arguments, incompatibilities with AT&T troff: | | Compatibility Mode |
| delimiters, for escape sequence arguments: | | Delimiters |
| delimiting character, for fields (fc): | | Fields |
| delimiting escape sequence arguments: | | Delimiters |
| depth, interpolation: | | Calling Macros |
| depth, of last glyph (.cdp): | | Environments |
| DESC file format: | | DESC File Format |
| DESC file, and font mounting: | | Font Positions |
| DESC file, and use_charnames_in_special keyword: | | Postprocessor Access |
| description file, font: | | Using Fonts |
| device description files, comments: | | DESC File Format |
| device request, and copy mode: | | Postprocessor Access |
| device resolution: | | Page Geometry |
| device resolution: | | DESC File Format |
| device resolution, obtaining in the formatter: | | Measurements |
| devices for output: | | Output Device Intro |
| dg glyph, at end of sentence: | | Sentences |
| dg glyph, at end of sentence: | | Using Symbols |
| di request, and warnings: | | Warnings |
| di request, and warnings: | | Warnings |
| differences in implementation: | | Implementation Differences |
| digit-width space (\0): | | Page Motions |
| digits, as delimiters: | | Delimiters |
| dimensions, line: | | Line Layout |
| directories for fonts: | | Font Directories |
| directories for macros: | | Macro Directories |
| directory, current: | | Macro Directories |
| directory, for tmac files: | | Macro Directories |
| directory, home: | | Macro Directories |
| directory, platform-specific: | | Macro Directories |
| directory, site-local: | | Macro Directories |
| directory, site-local: | | Font Directories |
| disabling hyphenation (\%): | | Manipulating Hyphenation |
| disabling \ (eo): | | Using Escape Sequences |
| discardable horizontal space: | | Manipulating Filling and Adjustment |
| displays: | | Displays and Keeps |
| displays [ms]: | | ms keeps and displays |
| displays, and footnotes [ms]: | | ms Footnotes |
| distance to next vertical position trap register (.t): | | Page Location Traps |
| diversion: | | Deferring Output |
| diversion name register (.z): | | Diversions |
| diversion trap, setting (dt): | | Diversion Traps |
| diversion traps: | | Diversion Traps |
| diversion, appending to (da, boxa): | | Diversions |
| diversion, beginning (di, box): | | Diversions |
| diversion, creating alias for (als): | | Strings |
| diversion, ending (di, box): | | Diversions |
| diversion, nested: | | Diversions |
| diversion, removing (rm): | | Strings |
| diversion, removing alias for (rm): | | Strings |
| diversion, renaming (rn): | | Strings |
| diversion, stripping final newline: | | Punning Names |
| diversion, top-level: | | Diversions |
| diversion, top-level, and bp: | | Page Control |
| diversion, top-level, and \!: | | Diversions |
| diversion, top-level, and \?: | | Diversions |
| diversion, unformatting (asciify): | | Diversions |
| diversion, vertical position in, register (.d): | | Diversions |
| diversions: | | Diversions |
| diversions: | | Punning Names |
| diversions, and traps: | | Page Location Traps |
| diversions, shared name space with macros and strings: | | Identifiers |
| division, truncating: | | Numeric Expressions |
| dl register, and da (boxa): | | Diversions |
| dn register, and da (boxa): | | Diversions |
| document description macros, [ms]: | | ms Document Description Macros |
| document formats: | | Document Formats |
| documents, multi-file: | | Debugging |
| documents, structuring the source of: | | Invoking Requests |
| dot, as delimiter: | | Delimiters |
| double quote, embedding in a macro argument: | | Calling Macros |
| double quotes, trailing, in strings: | | Strings |
| double-spacing (ls): | | Manipulating Spacing |
| double-spacing (vs, pvs): | | Changing the Vertical Spacing |
| down-casing a string (stringdown): | | Strings |
| drawing a filled circle (‘\D'C …'’): | | Drawing Geometric Objects |
| drawing a filled ellipse (‘\D'E …'’): | | Drawing Geometric Objects |
| drawing a filled polygon (‘\D'P …'’): | | Drawing Geometric Objects |
| drawing a line (‘\D'l …'’): | | Drawing Geometric Objects |
| drawing a solid circle (‘\D'C …'’): | | Drawing Geometric Objects |
| drawing a solid ellipse (‘\D'E …'’): | | Drawing Geometric Objects |
| drawing a solid polygon (‘\D'P …'’): | | Drawing Geometric Objects |
| drawing a spline (‘\D'~ …'’): | | Drawing Geometric Objects |
| drawing a stroked circle (‘\D'c …'’): | | Drawing Geometric Objects |
| drawing a stroked ellipse (‘\D'e …'’): | | Drawing Geometric Objects |
| drawing a stroked polygon (‘\D'p …'’): | | Drawing Geometric Objects |
| drawing an arc (‘\D'a …'’): | | Drawing Geometric Objects |
| drawing an outlined circle (‘\D'c …'’): | | Drawing Geometric Objects |
| drawing an outlined ellipse (‘\D'e …'’): | | Drawing Geometric Objects |
| drawing an outlined polygon (‘\D'p …'’): | | Drawing Geometric Objects |
| drawing horizontal lines (\l): | | Drawing Geometric Objects |
| drawing position: | | Page Geometry |
| drawing position, vertical (nl): | | Page Control |
| drawing requests: | | Drawing Geometric Objects |
| drawing vertical lines (\L): | | Drawing Geometric Objects |
| ds request, and comments: | | Strings |
| ds request, and double quotes: | | Strings |
| ds request, and leading spaces: | | Strings |
| ds, ds1 requests, and comments: | | Comments |
| ds, ds1 requests, and warnings: | | Warnings |
| dummy character (\&): | | Dummy Characters |
| dummy character (\&), as control character suppressor: | | Requests and Macros |
| dummy character (\&), effect on kerning: | | Ligatures and Kerning |
| dummy character (\&), effect on \l escape sequence: | | Drawing Geometric Objects |
| dummy character, transparent (\)): | | Dummy Characters |
| dummy environment, used by \w escape sequence: | | Page Motions |
| dumping environments (pev): | | Debugging |
| dumping page location traps (ptr): | | Debugging |
| dumping registers (pnr): | | Debugging |
| dumping symbol table (pm): | | Debugging |
|
| E | | |
|---|
| EBCDIC output encoding: | | Groff Options |
| EBCDIC, input encoding: | | Input Encodings |
| ejection, page: | | Page Geometry |
| ejection, page: | | Page Control |
| ejection, page: | | The Implicit Page Trap |
| ejection, page, of final page: | | End-of-input Traps |
| ejection, page, prevented by vpt: | | Vertical Position Traps |
| el request, and warnings: | | Warnings |
| ellipse, filled, drawing (‘\D'E …'’): | | Drawing Geometric Objects |
| ellipse, outlined, drawing (‘\D'e …'’): | | Drawing Geometric Objects |
| ellipse, solid, drawing (‘\D'E …'’): | | Drawing Geometric Objects |
| ellipse, stroked, drawing (‘\D'e …'’): | | Drawing Geometric Objects |
| em glyph, and cflags: | | Using Symbols |
| em scaling unit (m): | | Measurements |
| embolding of special fonts: | | Artificial Fonts |
| empty line: | | Breaking |
| en scaling unit (n): | | Measurements |
| enabling vertical position traps (vpt): | | Vertical Position Traps |
| encoding, input, code page 1047: | | Input Encodings |
| encoding, input, EBCDIC: | | Input Encodings |
| encoding, input, Latin-1 (ISO 8859-1): | | Input Encodings |
| encoding, input, Latin-2 (ISO 8859-2): | | Input Encodings |
| encoding, input, Latin-5 (ISO 8859-9): | | Input Encodings |
| encoding, input, Latin-9 (ISO 8859-15): | | Input Encodings |
| encoding, output, ASCII: | | Groff Options |
| encoding, output, code page 1047: | | Groff Options |
| encoding, output, EBCDIC: | | Groff Options |
| encoding, output, ISO 646: | | Groff Options |
| encoding, output, Latin-1 (ISO 8859-1): | | Groff Options |
| encoding, output, UTF-8: | | Groff Options |
| end of conditional block (\}): | | Conditional Blocks |
| end-of-input macro (em): | | End-of-input Traps |
| end-of-input trap, setting (em): | | End-of-input Traps |
| end-of-input traps: | | End-of-input Traps |
| end-of-sentence characters: | | Sentences |
| end-of-sentence characters: | | Using Symbols |
| end-of-sentence transparent characters: | | Sentences |
| ending diversion (di, box): | | Diversions |
| endnotes: | | Footnotes and Endnotes |
| environment: | | Deferring Output |
| environment availability and naming, incompatibilities with: | | Other Differences |
| environment number/name register (.ev): | | Environments |
| environment variables: | | Environment |
| environment, copying (evc): | | Environments |
| environment, dimensions of last glyph (.w, .cht, .cdp, .csk): | | Environments |
| environment, dummy, used by \w escape sequence: | | Page Motions |
| environment, previous line length (.n): | | Environments |
| environment, switching (ev): | | Environments |
| environments: | | Environments |
| environments, dumping (pev): | | Debugging |
| equality operator: | | Numeric Expressions |
| equation example [ms]: | | ms Insertions |
| equations [ms]: | | ms Insertions |
| escape character, changing (ec): | | Using Escape Sequences |
| escape character, formatting (\e): | | Using Escape Sequences |
| escape character, while defining glyph: | | Using Symbols |
| escape sequence: | | Formatter Instructions |
| escape sequence argument delimiters: | | Delimiters |
| escape sequences: | | Using Escape Sequences |
| escape sequences, brace (\{, \}): | | Conditional Blocks |
| escaping newline characters, in strings: | | Strings |
| ex request, use in debugging: | | Debugging |
| ex request, used with nx and rd: | | I/O |
| example markup, bulleted list [ms]: | | Lists in ms |
| example markup, cover page in [ms]: | | ms Document Description Macros |
| example markup, glossary-style list [ms]: | | Lists in ms |
| example markup, numbered list [ms]: | | Lists in ms |
| examples of invocation: | | Invocation Examples |
| exiting (ex): | | Debugging |
| expansion of strings (\*): | | Strings |
| explicit hyphen (\%): | | Manipulating Hyphenation |
| explicit hyphenation: | | Manipulating Hyphenation |
| expression, limitation of logical not in: | | Numeric Expressions |
| expression, order of evaluation: | | Numeric Expressions |
| expressions, and register format: | | Assigning Register Formats |
| expressions, and space characters: | | Numeric Expressions |
| expressions, conditional: | | Operators in Conditionals |
| expressions, numeric: | | Numeric Expressions |
| extra post-vertical line space (\x): | | Changing the Vertical Spacing |
| extra post-vertical line space register (.a): | | Manipulating Spacing |
| extra pre-vertical line space (\x): | | Changing the Vertical Spacing |
| extra spaces between words: | | Adjustment |
| extreme values representable with Roman numerals: | | Assigning Register Formats |
| extremum operators (>?, <?): | | Numeric Expressions |
|
| F | | |
|---|
| f scaling unit: | | Colors |
| factor, zoom, of a font (fzoom): | | Selecting Fonts |
| fallback character, defining (fchar, fschar, schar): | | Using Symbols |
| fallback glyph, removing definition (rchar, rfschar): | | Using Symbols |
| fam request, and changing fonts: | | Selecting Fonts |
| families, font: | | Font Families |
| family, font: | | Using Fonts |
| features, common: | | Common Features |
| fi request, causing implicit break: | | Manipulating Filling and Adjustment |
| field delimiting character (fc): | | Fields |
| field padding character (fc): | | Fields |
| fields: | | Fields |
| fields, and tabs: | | Tabs and Fields |
| figure space (\0): | | Page Motions |
| figures [ms]: | | ms Insertions |
| file formats: | | File Formats |
| file names, breaking (\:): | | Manipulating Hyphenation |
| file, appending to (opena): | | I/O |
| file, closing (close): | | I/O |
| file, font description: | | Using Fonts |
| file, inclusion (so): | | I/O |
| file, macro, search path: | | Macro Directories |
| file, opening (open): | | I/O |
| file, processing next (nx): | | I/O |
| file, writing to (write, writec): | | I/O |
| files, font: | | Device and Font Description Files |
| fill color: | | Colors |
| fill color name register (.M): | | Colors |
| fill mode (fi), enabling: | | Manipulating Filling and Adjustment |
| fill mode, and \c: | | Line Continuation |
| fill mode, disabling: | | Manipulating Filling and Adjustment |
| filled circle, drawing (‘\D'C …'’): | | Drawing Geometric Objects |
| filled ellipse, drawing (‘\D'E …'’): | | Drawing Geometric Objects |
| filled polygon, drawing (‘\D'P …'’): | | Drawing Geometric Objects |
| filling: | | Filling |
| filling and adjustment, manipulating: | | Manipulating Filling and Adjustment |
| filling of output, disabling (nf): | | Manipulating Filling and Adjustment |
| filling of output, enabling (fi): | | Manipulating Filling and Adjustment |
| filling, and break warnings: | | Warnings |
| filling, and inter-sentence space: | | Manipulating Filling and Adjustment |
| final newline, stripping in diversions: | | Punning Names |
| fl request, causing implicit break: | | Manipulating Filling and Adjustment |
| floating keep: | | Displays and Keeps |
| flush output (fl): | | Debugging |
| font: | | Using Fonts |
| font aliasing with third argument to fp request: | | Font Positions |
| font description file: | | Using Fonts |
| font description file format: | | DESC File Format |
| font description file, format: | | Font Description File Format |
| font description files, comments: | | Font Description File Format |
| font directories: | | Font Directories |
| font families: | | Font Families |
| font family: | | Using Fonts |
| font family, changing (fam, \F): | | Font Families |
| font file, format: | | Font Description File Format |
| font files: | | Device and Font Description Files |
| font for underlining (uf): | | Artificial Fonts |
| font height, changing (\H): | | Artificial Fonts |
| font metrics: | | Using Fonts |
| font mounting, automatic: | | Selecting Fonts |
| font path: | | Font Directories |
| font position register (.f): | | Font Positions |
| font positions: | | Font Positions |
| font slant, changing (\S): | | Artificial Fonts |
| font style: | | Using Fonts |
| font style, abstract: | | Using Fonts |
| font style, abstract, setting up (sty): | | Font Families |
| font styles: | | Font Families |
| font translation (ftr): | | Selecting Fonts |
| font, magnification (fzoom): | | Selecting Fonts |
| font, mounting (fp): | | Font Positions |
| font, optical size: | | Selecting Fonts |
| font, previous, selecting (\f[], \fP): | | Selecting Fonts |
| font, previous, slecting (ft): | | Selecting Fonts |
| font, selection: | | Selecting Fonts |
| font, special: | | Using Fonts |
| font, text: | | Using Fonts |
| font, unstyled: | | Using Fonts |
| font, zoom factor (fzoom): | | Selecting Fonts |
| fonts, artificial: | | Artificial Fonts |
| fonts, changing (ft, \f): | | Selecting Fonts |
| fonts, searching: | | Font Directories |
| fonts, special: | | Special Fonts |
| footers: | | Page Layout |
| footers: | | Page Location Traps |
| footers [ms]: | | ms Headers and Footers |
| footnote marker [ms]: | | ms Footnotes |
| footnotes: | | Footnotes and Endnotes |
| footnotes [ms]: | | ms Footnotes |
| footnotes, and displays [ms]: | | ms Footnotes |
| footnotes, and keeps [ms]: | | ms Footnotes |
| form letters: | | I/O |
| format of font description file: | | DESC File Format |
| format of font description files: | | Font Description File Format |
| format of font files: | | Font Description File Format |
| format of register (\g): | | Assigning Register Formats |
| format, paper: | | Paper Format |
| formats, file: | | File Formats |
| formatter instructions: | | Formatter Instructions |
| formatting a backslash glyph (\[rs]): | | Using Escape Sequences |
| formatting a title line (tl): | | Page Layout |
| formatting the escape character (\e): | | Using Escape Sequences |
| formatting the time: | | I/O |
| fp request, and font translations: | | Selecting Fonts |
| fp request, incompatibilities with AT&T troff: | | Other Differences |
| fractional point sizes: | | Using Fractional Type Sizes |
| fractional point sizes: | | Other Differences |
| fractional type sizes: | | Using Fractional Type Sizes |
| fractional type sizes: | | Other Differences |
| fractional type sizes in ms macros: | | Differences from AT&T ms |
| French spacing: | | Sentences |
| fspecial request, and font styles: | | Font Families |
| fspecial request, and font translations: | | Selecting Fonts |
| fspecial request, and glyph search order: | | Using Symbols |
| fspecial request, and imitating bold: | | Artificial Fonts |
| ft request, and font translations: | | Selecting Fonts |
| full-service macro package: | | Major Macro Packages |
|
| G | | |
|---|
| geometry, page: | | Page Geometry |
| GGL (groff glyph list): | | Using Symbols |
| GGL (groff glyph list): | | Character Classes |
| glossary-style list, example markup [ms]: | | Lists in ms |
| glyph: | | Using Symbols |
| glyph for line drawing: | | Drawing Geometric Objects |
| glyph names, composite: | | Using Symbols |
| glyph pile (\b): | | Drawing Geometric Objects |
| glyph properties (cflags): | | Using Symbols |
| glyph, box rule (\[br]): | | Drawing Geometric Objects |
| glyph, constant space: | | Artificial Fonts |
| glyph, defining (char): | | Using Symbols |
| glyph, distinguished from character: | | Using Symbols |
| glyph, for line drawing: | | Drawing Geometric Objects |
| glyph, for margins (mc): | | Miscellaneous |
| glyph, last, dimensions (.w, .cht, .cdp, .csk): | | Environments |
| glyph, leader repetition (lc): | | Leaders |
| glyph, numbered (\N): | | Character Translations |
| glyph, numbered (\N): | | Using Symbols |
| glyph, removing definition (rchar, rfschar): | | Using Symbols |
| glyph, soft hyphen (hy): | | Manipulating Hyphenation |
| glyph, tab repetition (tc): | | Tabs and Fields |
| glyph, underscore (\[ru]): | | Drawing Geometric Objects |
| glyphs, available, list of (groff_char(7) man page): | | Using Symbols |
| glyphs, output, and input characters, compatibility with AT&T troff: | | Other Differences |
| glyphs, overstriking (\o): | | Page Motions |
| glyphs, unnamed: | | Using Symbols |
| glyphs, unnamed, accessing with \N: | | Font Description File Format |
| GNU troff, identification register (.g): | | Built-in Registers |
| GNU troff, PID register ($$): | | Built-in Registers |
| GNU troff, process ID register ($$): | | Built-in Registers |
| GNU-specific register (.g): | | Built-in Registers |
| graphic renditions: | | Using Fonts |
| greater than (or equal to) operator: | | Numeric Expressions |
| groff capabilities: | | groff Capabilities |
| groff glyph list (GGL): | | Using Symbols |
| groff glyph list (GGL): | | Character Classes |
| groff invocation: | | Invoking groff |
| groff, and pi request: | | I/O |
| groff—what is it?: | | What Is groff? |
| GROFF_BIN_PATH, environment variable: | | Environment |
| GROFF_COMMAND_PREFIX, environment variable: | | Environment |
| GROFF_ENCODING, environment variable: | | Environment |
| GROFF_FONT_PATH, environment variable: | | Environment |
| GROFF_FONT_PATH, environment variable: | | Font Directories |
| GROFF_TMAC_PATH, environment variable: | | Environment |
| GROFF_TMAC_PATH, environment variable: | | Macro Directories |
| GROFF_TMPDIR, environment variable: | | Environment |
| GROFF_TYPESETTER, environment variable: | | Environment |
| grohtml, the program: | | Groff Options |
| gtroff, interactive use: | | Debugging |
| gtroff, output: | | gtroff Output |
| gtroff, reference: | | GNU troff Reference |
|
| H | | |
|---|
| hair space (\^): | | Page Motions |
| hcode request, and glyph definitions: | | Using Symbols |
| headers: | | Page Layout |
| headers: | | Page Location Traps |
| headers [ms]: | | ms Headers and Footers |
| height, font, changing (\H): | | Artificial Fonts |
| height, of last glyph (.cht): | | Environments |
| high-water mark register (.h): | | Diversions |
| home directory: | | Macro Directories |
| horizontal discardable space: | | Manipulating Filling and Adjustment |
| horizontal input line position register (hp): | | Page Motions |
| horizontal input line position, saving (\k): | | Page Motions |
| horizontal line, drawing (\l): | | Drawing Geometric Objects |
| horizontal motion (\h): | | Page Motions |
| horizontal motion quantum: | | DESC File Format |
| horizontal motion quantum register (.H): | | Motion Quanta |
| horizontal output line position register (.k): | | Page Motions |
| horizontal resolution: | | DESC File Format |
| horizontal resolution register (.H): | | Motion Quanta |
| horizontal space (\h): | | Page Motions |
| horizontal space, unformatting: | | Punning Names |
| horizontal tab character: | | Tabs and Leaders |
| hours, current time (hours): | | Built-in Registers |
| hpf request, and hyphenation language: | | Manipulating Hyphenation |
| hw request, and hy restrictions: | | Manipulating Hyphenation |
| hw request, and hyphenation language: | | Manipulating Hyphenation |
| hy glyph, and cflags: | | Using Symbols |
| hyphen, explicit (\%): | | Manipulating Hyphenation |
| hyphenated lines, consecutive (hlm): | | Manipulating Hyphenation |
| hyphenating characters: | | Using Symbols |
| hyphenation: | | Hyphenation |
| hyphenation character (\%): | | Manipulating Hyphenation |
| hyphenation code (hcode): | | Manipulating Hyphenation |
| hyphenation consecutive line count register (.hlc): | | Manipulating Hyphenation |
| hyphenation consecutive line limit register (.hlm): | | Manipulating Hyphenation |
| hyphenation exceptions: | | Manipulating Hyphenation |
| hyphenation language register (.hla): | | Manipulating Hyphenation |
| hyphenation margin (hym): | | Manipulating Hyphenation |
| hyphenation margin register (.hym): | | Manipulating Hyphenation |
| hyphenation mode register (.hy): | | Manipulating Hyphenation |
| hyphenation parameters, automatic: | | Manipulating Hyphenation |
| hyphenation pattern files: | | Manipulating Hyphenation |
| hyphenation patterns (hpf): | | Manipulating Hyphenation |
| hyphenation space (hys): | | Manipulating Hyphenation |
| hyphenation space adjustment threshold: | | Manipulating Hyphenation |
| hyphenation space adjustment threshold register (.hys): | | Manipulating Hyphenation |
| hyphenation, automatic: | | Manipulating Hyphenation |
| hyphenation, disabling (\%): | | Manipulating Hyphenation |
| hyphenation, explicit: | | Manipulating Hyphenation |
| hyphenation, incompatibilities with AT&T troff: | | Other Differences |
| hyphenation, manipulating: | | Manipulating Hyphenation |
| hyphenation, manual: | | Manipulating Hyphenation |
|
| I | | |
|---|
| i scaling unit: | | Measurements |
| i/o: | | I/O |
| IBM code page 1047 input encoding: | | Input Encodings |
| IBM code page 1047 output encoding: | | Groff Options |
| identifiers: | | Identifiers |
| identifiers, undefined: | | Identifiers |
| ie request, and font translations: | | Selecting Fonts |
| ie request, and warnings: | | Warnings |
| ie request, operators to use with: | | Operators in Conditionals |
| if request, and font translations: | | Selecting Fonts |
| if request, and the ‘!’ operator: | | Numeric Expressions |
| if request, operators to use with: | | Operators in Conditionals |
| if-else: | | if-else |
| if-then: | | if-then |
| imitating boldface (bd): | | Artificial Fonts |
| implementation differences: | | Implementation Differences |
| implicit line break: | | Breaking |
| implicit trap: | | The Implicit Page Trap |
| in request, causing implicit break: | | Manipulating Filling and Adjustment |
| in request, using + and - with: | | Numeric Expressions |
| inch scaling unit (i): | | Measurements |
| including a file (so): | | I/O |
| incompatibilities with AT&T troff: | | Implementation Differences |
| increment value without changing the register: | | Auto-increment |
| incrementation, automatic, of a register: | | Auto-increment |
| indentation (in): | | Line Layout |
| indentation, of roff source code: | | Invoking Requests |
| index, in macro package: | | Indexing |
| indicator, scaling: | | Measurements |
| indirect assignments: | | Interpolating Registers |
| input and output requests: | | I/O |
| input characters and output glyphs, compatibility with AT&T troff: | | Other Differences |
| input characters, invalid: | | Identifiers |
| input conventions: | | Input Conventions |
| input encoding, code page 1047: | | Input Encodings |
| input encoding, EBCDIC: | | Input Encodings |
| input encoding, Latin-1 (ISO 8859-1): | | Input Encodings |
| input encoding, Latin-2 (ISO 8859-2): | | Input Encodings |
| input encoding, Latin-5 (ISO 8859-9): | | Input Encodings |
| input encoding, Latin-9 (ISO 8859-15): | | Input Encodings |
| input file name, current, register (.F): | | Built-in Registers |
| input level: | | Calling Macros |
| input level in delimited arguments: | | Compatibility Mode |
| input line continuation (\RET): | | Line Continuation |
| input line number register (.c, c.): | | Built-in Registers |
| input line number, setting (lf): | | Debugging |
| input line position, horizontal, saving (\k): | | Page Motions |
| input line trap, clearing (it, itc): | | Input Line Traps |
| input line trap, setting (it, itc): | | Input Line Traps |
| input line traps: | | Input Line Traps |
| input line traps and interrupted lines (itc): | | Input Line Traps |
| input line, horizontal position, register (hp): | | Page Motions |
| input line, productive: | | Manipulating Filling and Adjustment |
| input stack, backtrace (backtrace): | | Debugging |
| input stack, setting limit: | | Debugging |
| input token: | | Gtroff Internals |
| input, 8-bit: | | Font Description File Format |
| input, standard, reading from (rd): | | I/O |
| inserting horizontal space (\h): | | Page Motions |
| installation: | | Installation |
| instructing the formatter: | | Formatter Instructions |
| inter-sentence space size register (.sss): | | Manipulating Filling and Adjustment |
| inter-sentence space, additional: | | Manipulating Filling and Adjustment |
| inter-word spacing, minimal: | | Manipulating Filling and Adjustment |
| interactive use of gtroff: | | Debugging |
| intercepting requests: | | Control Characters |
| intermediate output: | | gtroff Output |
| interpolating registers (\n): | | Interpolating Registers |
| interpolation: | | Requests and Macros |
| interpolation depth: | | Calling Macros |
| interpolation depth in delimited arguments: | | Compatibility Mode |
| interpolation of strings (\*): | | Strings |
| interpretation mode: | | Copy Mode |
| interrupted line: | | Line Continuation |
| interrupted line register (.int): | | Line Continuation |
| interrupted lines and input line traps (itc): | | Input Line Traps |
| introduction: | | Introduction |
| invalid characters for trf request: | | I/O |
| invalid input characters: | | Identifiers |
| invocation examples: | | Invocation Examples |
| invoking groff: | | Invoking groff |
| invoking requests: | | Invoking Requests |
| ISO 646 output encoding: | | Groff Options |
| ISO 8859-1 (Latin-1) output encoding: | | Groff Options |
| ISO 8859-1 (Latin-1), input encoding: | | Input Encodings |
| ISO 8859-15 (Latin-9), input encoding: | | Input Encodings |
| ISO 8859-2 (Latin-2), input encoding: | | Input Encodings |
| ISO 8859-9 (Latin-5), input encoding: | | Input Encodings |
| italic correction (\/): | | Italic Corrections |
|
| J | | |
|---|
| justifying text: | | Manipulating Filling and Adjustment |
| justifying text (rj): | | Manipulating Filling and Adjustment |
|
| K | | |
|---|
| keep, floating: | | Displays and Keeps |
| keeps (introduction): | | Displays and Keeps |
| keeps [ms]: | | ms keeps and displays |
| keeps, and footnotes [ms]: | | ms Footnotes |
| kerning and ligatures: | | Ligatures and Kerning |
| kerning enabled register (.kern): | | Ligatures and Kerning |
| kerning, activating (kern): | | Ligatures and Kerning |
| kerning, track: | | Ligatures and Kerning |
|
| L | | |
|---|
| landscape page orientation: | | Paper Format |
| language [ms]: | | ms language and localization |
| last glyph, dimensions (.w, .cht, .cdp, .csk): | | Environments |
| last-requested point size registers (.psr, .sr): | | Using Fractional Type Sizes |
| last-requested type size registers (.psr, .sr): | | Using Fractional Type Sizes |
| Latin-1 (ISO 8859-1) output encoding: | | Groff Options |
| Latin-1 (ISO 8859-1), input encoding: | | Input Encodings |
| Latin-2 (ISO 8859-2), input encoding: | | Input Encodings |
| Latin-5 (ISO 8859-9), input encoding: | | Input Encodings |
| Latin-9 (ISO 8859-15), input encoding: | | Input Encodings |
| layout, line: | | Line Layout |
| layout, page: | | Page Layout |
| lc request, and glyph definitions: | | Using Symbols |
| leader character: | | Tabs and Leaders |
| leader character: | | Leaders |
| leader character, and translations: | | Character Translations |
| leader character, non-interpreted (\a): | | Leaders |
| leader repetition character (lc): | | Leaders |
| leaders: | | Leaders |
| leading: | | Manipulating Type Size and Vertical Spacing |
| leading space macro (lsm): | | Breaking |
| leading space traps: | | Leading Space Traps |
| leading spaces: | | Breaking |
| leading spaces macro (lsm): | | Leading Space Traps |
| leading spaces with ds: | | Strings |
| left italic correction (\,): | | Italic Corrections |
| left margin (po): | | Line Layout |
| length of a string (length): | | Strings |
| length of line (ll): | | Line Layout |
| length of previous line (.n): | | Environments |
| length of the page, configuring (pl): | | Page Layout |
| length of title line, configuring (lt): | | Page Layout |
| length request, and copy mode: | | Strings |
| less than (or equal to) operator: | | Numeric Expressions |
| letters, form: | | I/O |
| level, input: | | Calling Macros |
| level, suppression nesting, register: | | Suppressing Output |
| lf request, incompatibilities with AT&T troff: | | Other Differences |
| ligature: | | Using Symbols |
| ligatures and kerning: | | Ligatures and Kerning |
| ligatures enabled register (.lg): | | Ligatures and Kerning |
| ligatures, activating (lg): | | Ligatures and Kerning |
| limitations of \b escape sequence: | | Drawing Geometric Objects |
| line break: | | Manipulating Filling and Adjustment |
| line break (introduction): | | Basics |
| line break, output: | | Breaking |
| line control: | | Line Continuation |
| line dimensions: | | Line Layout |
| line drawing glyph: | | Drawing Geometric Objects |
| line drawing glyph: | | Drawing Geometric Objects |
| line indentation (in): | | Line Layout |
| line layout: | | Line Layout |
| line length (ll): | | Line Layout |
| line length register (.l): | | Line Layout |
| line length, previous (.n): | | Environments |
| line number, input, register (.c, c.): | | Built-in Registers |
| line number, output, register (ln): | | Miscellaneous |
| line numbers, printing (nm): | | Miscellaneous |
| line space, extra post-vertical (\x): | | Changing the Vertical Spacing |
| line space, extra pre-vertical (\x): | | Changing the Vertical Spacing |
| line spacing register (.L): | | Manipulating Spacing |
| line spacing, post-vertical (pvs): | | Changing the Vertical Spacing |
| line thickness (‘\D't …'’): | | Drawing Geometric Objects |
| line, blank: | | Breaking |
| line, drawing (‘\D'l …'’): | | Drawing Geometric Objects |
| line, horizontal, drawing (\l): | | Drawing Geometric Objects |
| line, input, continuation (\RET): | | Line Continuation |
| line, input, horizontal position, register (hp): | | Page Motions |
| line, input, horizontal position, saving (\k): | | Page Motions |
| line, interrupted: | | Line Continuation |
| line, output, continuation (\c): | | Line Continuation |
| line, output, horizontal position, register (.k): | | Page Motions |
| line, productive input: | | Manipulating Filling and Adjustment |
| line, vertical, drawing (\L): | | Drawing Geometric Objects |
| line-tabs mode: | | Tabs and Fields |
| lines, blank, disabling: | | Manipulating Spacing |
| lines, centering (ce): | | Manipulating Filling and Adjustment |
| lines, centering (introduction): | | Basics |
| lines, consecutive hyphenated (hlm): | | Manipulating Hyphenation |
| lines, interrupted, and input line traps (itc): | | Input Line Traps |
| lines, right-aligning (introduction): | | Basics |
| lines, right-justifying (introduction): | | Basics |
| list of special characters (groff_char(7) man page): | | Using Symbols |
| listing page location traps (ptr): | | Debugging |
| lists: | | Paragraphs |
| ll request, using + and - with: | | Numeric Expressions |
| localization: | | Manipulating Hyphenation |
| localization [ms]: | | ms language and localization |
| locating macro files: | | Macro Directories |
| locating macro packages: | | Macro Directories |
| location, vertical, page, marking (mk): | | Page Motions |
| location, vertical, page, returning to marked (rt): | | Page Motions |
| logical “and” operator: | | Numeric Expressions |
| logical “or” operator: | | Numeric Expressions |
| logical complementation operator: | | Numeric Expressions |
| logical conjunction operator: | | Numeric Expressions |
| logical disjunction operator: | | Numeric Expressions |
| logical not, limitation in expression: | | Numeric Expressions |
| logical operators: | | Numeric Expressions |
| long names: | | Compatibility Mode |
| loops and conditionals: | | Conditionals and Loops |
| lowercasing a string (stringdown): | | Strings |
| ls request, alternative to (pvs): | | Changing the Vertical Spacing |
| lt request, using + and - with: | | Numeric Expressions |
|
| M | | |
|---|
| m scaling unit: | | Measurements |
| M scaling unit: | | Measurements |
| machine units: | | Page Geometry |
| macro: | | Requests and Macros |
| macro arguments: | | Calling Macros |
| macro arguments, and compatibility mode: | | Gtroff Internals |
| macro arguments, and tabs: | | Invoking Requests |
| macro directories: | | Macro Directories |
| macro file search path: | | Macro Directories |
| macro name register (\$0): | | Parameters |
| macro names, starting with [ or ], and refer: | | Identifiers |
| macro package: | | Macro Packages |
| macro package search path: | | Macro Directories |
| macro package usage, basics of: | | Basics |
| macro package, auxiliary: | | Major Macro Packages |
| macro package, full-service: | | Major Macro Packages |
| macro package, introduction: | | Macro Package Intro |
| macro package, major: | | Major Macro Packages |
| macro package, minor: | | Major Macro Packages |
| macro package, structuring the source of: | | Invoking Requests |
| macro, appending to (am): | | Writing Macros |
| macro, creating alias for (als): | | Strings |
| macro, end-of-input (em): | | End-of-input Traps |
| macro, parameters (\$): | | Parameters |
| macro, removing (rm): | | Strings |
| macro, removing alias for (rm): | | Strings |
| macro, renaming (rn): | | Strings |
| macros, recursive: | | while |
| macros, searching: | | Macro Directories |
| macros, shared name space with strings and diversions: | | Identifiers |
| macros, tutorial for users: | | Tutorial for Macro Users |
| macros, writing: | | Writing Macros |
| magnification of a font (fzoom): | | Selecting Fonts |
| major macro package: | | Major Macro Packages |
| major version number register (.x): | | Built-in Registers |
| man macros, custom headers and footers: | | Optional man extensions |
| man macros, Ultrix-specific: | | Optional man extensions |
| man pages: | | man |
| manipulating filling and adjustment: | | Manipulating Filling and Adjustment |
| manipulating hyphenation: | | Manipulating Hyphenation |
| manipulating spacing: | | Manipulating Spacing |
| manipulating type size and vertical spacing: | | Manipulating Type Size and Vertical Spacing |
| manual hyphenation: | | Manipulating Hyphenation |
| manual pages: | | man |
| margin for hyphenation (hym): | | Manipulating Hyphenation |
| margin glyph (mc): | | Miscellaneous |
| margin, bottom: | | Page Location Traps |
| margin, left (po): | | Line Layout |
| margin, right: | | Line Layout |
| margin, top: | | Page Location Traps |
| mark, high-water, register (.h): | | Diversions |
| marker, footnote [ms]: | | ms Footnotes |
| marking vertical page location (mk): | | Page Motions |
| maximum operator: | | Numeric Expressions |
| maximum value representable with Roman numerals: | | Assigning Register Formats |
| mdoc macros: | | mdoc |
| me macro package: | | me |
| measurement units: | | Measurements |
| measurements: | | Measurements |
| measurements, specifying safely: | | Default Units |
| metrics, font: | | Using Fonts |
| minimal inter-word spacing: | | Manipulating Filling and Adjustment |
| minimum operator: | | Numeric Expressions |
| minimum value representable with Roman numerals: | | Assigning Register Formats |
| minor macro package: | | Major Macro Packages |
| minor version number register (.y): | | Built-in Registers |
| minutes, current time (minutes): | | Built-in Registers |
| mm macro package: | | mm |
| mode for constant glyph space (cs): | | Artificial Fonts |
| mode, compatibility: | | Compatibility Mode |
| mode, compatibility, and parameters: | | Gtroff Internals |
| mode, copy: | | Copy Mode |
| mode, copy: | | Copy Mode |
| mode, copy, and cf request: | | I/O |
| mode, copy, and device request: | | Postprocessor Access |
| mode, copy, and length request: | | Strings |
| mode, copy, and macro parameters: | | Parameters |
| mode, copy, and output request: | | Diversions |
| mode, copy, and trf request: | | I/O |
| mode, copy, and write request: | | I/O |
| mode, copy, and writec request: | | I/O |
| mode, copy, and writem request: | | I/O |
| mode, copy, and \!: | | Diversions |
| mode, copy, and \?: | | Operators in Conditionals |
| mode, copy, and \?: | | Diversions |
| mode, copy, and \a: | | Leaders |
| mode, copy, and \t: | | Tabs and Fields |
| mode, copy, and \V: | | I/O |
| mode, fill (fi), enabling: | | Manipulating Filling and Adjustment |
| mode, fill, and break warnings: | | Warnings |
| mode, fill, and inter-sentence space: | | Manipulating Filling and Adjustment |
| mode, fill, and \c: | | Line Continuation |
| mode, fill, disabling: | | Manipulating Filling and Adjustment |
| mode, interpretation: | | Copy Mode |
| mode, line-tabs: | | Tabs and Fields |
| mode, no-fill: | | Manipulating Filling and Adjustment |
| mode, no-fill, and \c: | | Line Continuation |
| mode, no-space (ns): | | Manipulating Spacing |
| mode, nroff: | | troff and nroff Modes |
| mode, safer: | | Groff Options |
| mode, safer: | | Macro Directories |
| mode, safer: | | Built-in Registers |
| mode, safer: | | I/O |
| mode, safer: | | I/O |
| mode, safer: | | I/O |
| mode, safer: | | I/O |
| mode, safer: | | Safer Mode |
| mode, troff: | | troff and nroff Modes |
| mode, unsafe: | | Groff Options |
| mode, unsafe: | | Macro Directories |
| mode, unsafe: | | Built-in Registers |
| mode, unsafe: | | I/O |
| mode, unsafe: | | I/O |
| mode, unsafe: | | I/O |
| mode, unsafe: | | I/O |
| modifying requests: | | Control Characters |
| modulus: | | Numeric Expressions |
| mom macro package: | | mom |
| month of the year register (mo): | | Built-in Registers |
| motion operators: | | Numeric Expressions |
| motion quanta: | | Motion Quanta |
| motion quantum, horizontal: | | DESC File Format |
| motion quantum, horizontal, register (.H): | | Motion Quanta |
| motion quantum, vertical: | | DESC File Format |
| motion, horizontal (\h): | | Page Motions |
| motion, vertical (\v): | | Page Motions |
| motions, page: | | Page Motions |
| mounting a font (fp): | | Font Positions |
| mounting position: | | Using Fonts |
| mounting position: | | Using Fonts |
| mounting, font, automatic: | | Selecting Fonts |
| ms macros: | | ms |
| ms macros, accent marks: | | ms Legacy Features |
| ms macros, body text: | | ms Body Text |
| ms macros, creating table of contents: | | ms TOC |
| ms macros, displays: | | ms keeps and displays |
| ms macros, document control settings: | | ms Document Control Settings |
| ms macros, document description: | | ms Document Description Macros |
| ms macros, equations: | | ms Insertions |
| ms macros, figures: | | ms Insertions |
| ms macros, footers: | | ms Headers and Footers |
| ms macros, footnotes: | | ms Footnotes |
| ms macros, fractional type sizes in: | | Differences from AT&T ms |
| ms macros, general structure: | | ms Document Structure |
| ms macros, groff differences from AT&T: | | Differences from AT&T ms |
| ms macros, headers: | | ms Headers and Footers |
| ms macros, headings: | | Headings in ms |
| ms macros, keeps: | | ms keeps and displays |
| ms macros, language: | | ms language and localization |
| ms macros, lists: | | Lists in ms |
| ms macros, localization: | | ms language and localization |
| ms macros, margins: | | ms Margins |
| ms macros, multiple columns: | | ms Multiple Columns |
| ms macros, naming conventions: | | ms Naming Conventions |
| ms macros, nested lists: | | Indented regions in ms |
| ms macros, obtaining typographical symbols: | | Typographical symbols in ms |
| ms macros, page layout: | | ms Page Layout |
| ms macros, paragraph handling: | | Paragraphs in ms |
| ms macros, references: | | ms Insertions |
| ms macros, special characters: | | ms Legacy Features |
| ms macros, strings: | | ms Legacy Features |
| ms macros, tables: | | ms Insertions |
| ms macros, text settings: | | Text settings in ms |
| multi-file documents: | | Debugging |
| multi-line strings: | | Strings |
| multi-page table example [ms]: | | ms Insertions |
| multiple columns [ms]: | | ms Multiple Columns |
| multiplication: | | Numeric Expressions |
|
| N | | |
|---|
| n scaling unit: | | Measurements |
| name space, common, of macros, diversions, and strings: | | Identifiers |
| name, background color, register (.M): | | Colors |
| name, fill color, register (.M): | | Colors |
| name, stroke color, register (.m): | | Colors |
| named character (\C): | | Using Symbols |
| names, long: | | Compatibility Mode |
| naming conventions, ms macros: | | ms Naming Conventions |
| ne request, and the .trunc register: | | Page Location Traps |
| ne request, comparison with sv: | | Page Control |
| negating register values: | | Setting Registers |
| negation: | | Numeric Expressions |
| nested assignments: | | Interpolating Registers |
| nested diversions: | | Diversions |
| nested lists [ms]: | | Indented regions in ms |
| nesting level, suppression, register: | | Suppressing Output |
| new page (bp): | | Page Control |
| newline character, and translations: | | Character Translations |
| newline character, in strings, escaping: | | Strings |
| newline, as delimiter: | | Delimiters |
| newline, final, stripping in diversions: | | Punning Names |
| next file, processing (nx): | | I/O |
| next free font position register (.fp): | | Font Positions |
| next page number register (.pn): | | Page Layout |
| next page number, configuring (pn): | | Page Layout |
| nf request, causing implicit break: | | Manipulating Filling and Adjustment |
| nl register, and .d: | | Diversions |
| nl register, difference from .h: | | Diversions |
| nm request, using + and - with: | | Numeric Expressions |
| no-break control character ('): | | Requests and Macros |
| no-break control character, changing (c2): | | Control Characters |
| no-fill mode: | | Manipulating Filling and Adjustment |
| no-fill mode, and \c: | | Line Continuation |
| no-space mode (ns): | | Manipulating Spacing |
| node, output: | | Gtroff Internals |
| non-printing break point (\:): | | Manipulating Hyphenation |
| nr request, and warnings: | | Warnings |
| nr request, using + and - with: | | Numeric Expressions |
| nroff mode: | | troff and nroff Modes |
| number formats, assigning to register (af): | | Assigning Register Formats |
| number of registers register (.R): | | Built-in Registers |
| number, input line, setting (lf): | | Debugging |
| number, page, next, configuring (pn): | | Page Layout |
| numbered glyph (\N): | | Character Translations |
| numbered glyph (\N): | | Using Symbols |
| numbered list, example markup [ms]: | | Lists in ms |
| numbers, line, printing (nm): | | Miscellaneous |
| numeral-width space (\0): | | Page Motions |
| numerals, as delimiters: | | Delimiters |
| numerals, Roman: | | Assigning Register Formats |
| numeric expression, valid: | | Numeric Expressions |
| numeric expressions: | | Numeric Expressions |
|
| O | | |
|---|
| object creation: | | Writing Macros |
| offset, page: | | Page Geometry |
| offset, page (po): | | Line Layout |
| open request, and safer mode: | | Groff Options |
| opena request, and safer mode: | | Groff Options |
| opening brace escape sequence (\}): | | Conditional Blocks |
| opening file (open): | | I/O |
| operator, scaling: | | Numeric Expressions |
| operators, arithmetic: | | Numeric Expressions |
| operators, as delimiters: | | Delimiters |
| operators, comparison: | | Numeric Expressions |
| operators, extremum (>?, <?): | | Numeric Expressions |
| operators, logical: | | Numeric Expressions |
| operators, motion: | | Numeric Expressions |
| operators, unary arithmetic: | | Numeric Expressions |
| optical size of a font: | | Selecting Fonts |
| options: | | Groff Options |
| order of evaluation in expressions: | | Numeric Expressions |
| ordinary character: | | Identifiers |
| orientation, landscape: | | Paper Format |
| orphan: | | Page Control |
| orphan lines, preventing with ne: | | Page Control |
| os request, and no-space mode: | | Page Control |
| outlined circle, drawing (‘\D'c …'’): | | Drawing Geometric Objects |
| outlined ellipse, drawing (‘\D'e …'’): | | Drawing Geometric Objects |
| outlined polygon, drawing (‘\D'p …'’): | | Drawing Geometric Objects |
| output and input requests: | | I/O |
| output comparison operator: | | Operators in Conditionals |
| output device name string (.T): | | Groff Options |
| output device name string (.T): | | Strings |
| output device name string (.T), in other implementations: | | Other Differences |
| output device usage register (.T): | | Groff Options |
| output device usage register (.T), incompatibility with AT&T troff: | | Other Differences |
| output devices: | | Output Device Intro |
| output encoding, ASCII: | | Groff Options |
| output encoding, code page 1047: | | Groff Options |
| output encoding, EBCDIC: | | Groff Options |
| output encoding, ISO 646: | | Groff Options |
| output encoding, Latin-1 (ISO 8859-1): | | Groff Options |
| output encoding, UTF-8: | | Groff Options |
| output glyphs, and input characters, compatibility with AT&T troff: | | Other Differences |
| output line break: | | Breaking |
| output line number register (ln): | | Miscellaneous |
| output line properties: | | Manipulating Filling and Adjustment |
| output line, continuation (\c): | | Line Continuation |
| output line, horizontal position, register (.k): | | Page Motions |
| output node: | | Gtroff Internals |
| output request, and copy mode: | | Diversions |
| output request, and \!: | | Diversions |
| output, filling, disablement of (nf): | | Manipulating Filling and Adjustment |
| output, filling, enablement of (fi): | | Manipulating Filling and Adjustment |
| output, flush (fl): | | Debugging |
| output, gtroff: | | gtroff Output |
| output, intermediate: | | gtroff Output |
| output, suppressing (\O): | | Suppressing Output |
| output, transparent (cf, trf): | | I/O |
| output, transparent (\!, \?): | | Diversions |
| output, transparent, incompatibilities with AT&T troff: | | Other Differences |
| output, troff: | | gtroff Output |
| overlapping characters: | | Using Symbols |
| overstriking glyphs (\o): | | Page Motions |
|
| P | | |
|---|
| p scaling unit: | | Measurements |
| P scaling unit: | | Measurements |
| package, macro: | | Macro Packages |
| package, macro, auxiliary: | | Major Macro Packages |
| package, macro, full-service: | | Major Macro Packages |
| package, macro, introduction: | | Macro Package Intro |
| package, macro, major: | | Major Macro Packages |
| package, macro, minor: | | Major Macro Packages |
| package, macro, search path: | | Macro Directories |
| package, package, structuring the source of: | | Invoking Requests |
| padding character, for fields (fc): | | Fields |
| page: | | Page Geometry |
| page break: | | Page Geometry |
| page break: | | Page Control |
| page break: | | The Implicit Page Trap |
| page break (introduction): | | Basics |
| page break, conditional (ne): | | Page Control |
| page break, final: | | End-of-input Traps |
| page break, prevented by vpt: | | Vertical Position Traps |
| page control: | | Page Control |
| page ejection: | | Page Geometry |
| page ejection: | | Page Control |
| page ejection: | | The Implicit Page Trap |
| page ejection status register (.pe): | | Page Location Traps |
| page ejection, of final page: | | End-of-input Traps |
| page ejection, prevented by vpt: | | Vertical Position Traps |
| page footers: | | Page Location Traps |
| page headers: | | Page Location Traps |
| page layout: | | Page Layout |
| page layout [ms]: | | ms Page Layout |
| page length register (.p): | | Page Layout |
| page length, configuring (pl): | | Page Layout |
| page location traps: | | Page Location Traps |
| page location traps, debugging: | | Page Location Traps |
| page location, vertical, marking (mk): | | Page Motions |
| page location, vertical, returning to marked (rt): | | Page Motions |
| page motions: | | Page Motions |
| page number character (%): | | Page Layout |
| page number character, changing (pc): | | Page Layout |
| page number register (%): | | Page Control |
| page number, configuring next (pn): | | Page Layout |
| page number, next, register (.pn): | | Page Layout |
| page offset: | | Page Geometry |
| page offset (po): | | Line Layout |
| page orientation, landscape: | | Paper Format |
| page, geometry of: | | Page Geometry |
| page, new (bp): | | Page Control |
| paper format: | | Paper Format |
| paper size: | | Paper Format |
| paragraphs: | | Paragraphs |
| parameter count register (.$): | | Parameters |
| parameters: | | Parameters |
| parameters, and compatibility mode: | | Gtroff Internals |
| parameters, macro (\$): | | Parameters |
| parentheses: | | Numeric Expressions |
| partially collected line: | | Manipulating Filling and Adjustment |
| path, for font files: | | Font Directories |
| path, for tmac files: | | Macro Directories |
| pattern files, for hyphenation: | | Manipulating Hyphenation |
| patterns for hyphenation (hpf): | | Manipulating Hyphenation |
| pending output line: | | Manipulating Filling and Adjustment |
| pi request, and groff: | | I/O |
| pi request, and safer mode: | | Groff Options |
| pi request, disabled by default: | | Safer Mode |
| pica scaling unit (P): | | Measurements |
| PID of GNU troff register ($$): | | Built-in Registers |
| pile, glyph (\b): | | Drawing Geometric Objects |
| pl request, using + and - with: | | Numeric Expressions |
| plain text approximation output register (.A): | | Groff Options |
| plain text approximation output register (.A): | | Built-in Registers |
| planting a trap: | | Traps |
| platform-specific directory: | | Macro Directories |
| pm request, incompatibilities with AT&T troff: | | Other Differences |
| pn request, using + and - with: | | Numeric Expressions |
| PNG image generation from PostScript: | | DESC File Format |
| po request, using + and - with: | | Numeric Expressions |
| point scaling unit (p): | | Measurements |
| point size registers (.s, .ps): | | Changing the Type Size |
| point size registers, last-requested (.psr, .sr): | | Using Fractional Type Sizes |
| point sizes, changing (ps, \s): | | Changing the Type Size |
| point sizes, fractional: | | Using Fractional Type Sizes |
| point sizes, fractional: | | Other Differences |
| polygon, filled, drawing (‘\D'P …'’): | | Drawing Geometric Objects |
| polygon, outlined, drawing (‘\D'p …'’): | | Drawing Geometric Objects |
| polygon, solid, drawing (‘\D'P …'’): | | Drawing Geometric Objects |
| polygon, stroked, drawing (‘\D'p …'’): | | Drawing Geometric Objects |
| position of lowest text line (.h): | | Diversions |
| position, absolute (sic) operator (|): | | Numeric Expressions |
| position, drawing: | | Page Geometry |
| position, horizontal input line, saving (\k): | | Page Motions |
| position, horizontal, in input line, register (hp): | | Page Motions |
| position, horizontal, in output line, register (.k): | | Page Motions |
| position, mounting: | | Using Fonts |
| position, vertical, in diversion, register (.d): | | Diversions |
| positions, font: | | Font Positions |
| post-vertical line spacing: | | Changing the Vertical Spacing |
| post-vertical line spacing register (.pvs): | | Changing the Vertical Spacing |
| post-vertical line spacing, changing (pvs): | | Changing the Vertical Spacing |
| postprocessor access: | | Postprocessor Access |
| postprocessors: | | Output Device Intro |
| PostScript, bounding box: | | Miscellaneous |
| PostScript, PNG image generation: | | DESC File Format |
| prefix, for commands: | | Environment |
| preprocessors: | | Preprocessor Intro |
| previous font, selecting (ft): | | Selecting Fonts |
| previous font, selecting (\f[], \fP): | | Selecting Fonts |
| previous line length (.n): | | Environments |
| print current page register (.P): | | Groff Options |
| printing backslash (\\, \e, \E, \[rs]): | | Other Differences |
| printing line numbers (nm): | | Miscellaneous |
| printing to stderr (tm, tm1, tmc): | | Debugging |
| printing, zero-width (\z, \Z): | | Page Motions |
| printing, zero-width (\z, \Z): | | Page Motions |
| process ID of GNU troff register ($$): | | Built-in Registers |
| processing next file (nx): | | I/O |
| productive input line: | | Manipulating Filling and Adjustment |
| properties of characters (cflags): | | Using Symbols |
| properties of glyphs (cflags): | | Using Symbols |
| properties of output lines: | | Manipulating Filling and Adjustment |
| ps request, and constant glyph space mode: | | Artificial Fonts |
| ps request, incompatibilities with AT&T troff: | | Other Differences |
| ps request, using + and - with: | | Numeric Expressions |
| ps request, with fractional type sizes: | | Using Fractional Type Sizes |
| pso request, and safer mode: | | Groff Options |
| pvs request, using + and - with: | | Numeric Expressions |
|
| Q | | |
|---|
| quanta, motion: | | Motion Quanta |
| quantum, horizontal motion: | | DESC File Format |
| quantum, vertical motion: | | DESC File Format |
|
| R | | |
|---|
| radicalex glyph, and cflags: | | Using Symbols |
| ragged-left text: | | Manipulating Filling and Adjustment |
| ragged-right text: | | Manipulating Filling and Adjustment |
| rc request, and glyph definitions: | | Using Symbols |
| read-only register removal, incompatibility with AT&T troff: | | Other Differences |
| read-only register, changing format: | | Assigning Register Formats |
| reading from standard input (rd): | | I/O |
| recursive macros: | | while |
| refer, and macro names starting with [ or ]: | | Identifiers |
| reference, gtroff: | | GNU troff Reference |
| references [ms]: | | ms Insertions |
| register format, in expressions: | | Assigning Register Formats |
| register, assigning number format to (af): | | Assigning Register Formats |
| register, built-in, removing: | | Built-in Registers |
| register, creating alias for (aln): | | Setting Registers |
| register, format (\g): | | Assigning Register Formats |
| register, read-only, removal, incompatibility with AT&T troff: | | Other Differences |
| register, removing (rr): | | Setting Registers |
| register, removing alias for (rr): | | Setting Registers |
| register, renaming (rnn): | | Setting Registers |
| registers: | | Registers |
| registers, built-in: | | Built-in Registers |
| registers, dumping (pnr): | | Debugging |
| registers, interpolating (\n): | | Interpolating Registers |
| registers, number of, register (.R): | | Built-in Registers |
| registers, setting (nr, \R): | | Setting Registers |
| removal of read-only registers, incompatibility with AT&T troff: | | Other Differences |
| removing a built-in register: | | Built-in Registers |
| removing a register (rr): | | Setting Registers |
| removing alias for register (rr): | | Setting Registers |
| removing alias, for diversion (rm): | | Strings |
| removing alias, for macro (rm): | | Strings |
| removing alias, for string (rm): | | Strings |
| removing diversion (rm): | | Strings |
| removing glyph definition (rchar, rfschar): | | Using Symbols |
| removing macro (rm): | | Strings |
| removing request (rm): | | Strings |
| removing string (rm): | | Strings |
| renaming a register (rnn): | | Setting Registers |
| renaming diversion (rn): | | Strings |
| renaming macro (rn): | | Strings |
| renaming request (rn): | | Strings |
| renaming string (rn): | | Strings |
| renditions, graphic: | | Using Fonts |
| request: | | Requests and Macros |
| request: | | Formatter Instructions |
| request arguments: | | Invoking Requests |
| request arguments, and compatibility mode: | | Gtroff Internals |
| request arguments, and tabs: | | Invoking Requests |
| request, removing (rm): | | Strings |
| request, renaming (rn): | | Strings |
| request, undefined: | | Comments |
| requests for drawing: | | Drawing Geometric Objects |
| requests for input and output: | | I/O |
| requests, intercepting: | | Control Characters |
| requests, invoking: | | Invoking Requests |
| requests, modifying: | | Control Characters |
| resolution, device: | | Page Geometry |
| resolution, device: | | DESC File Format |
| resolution, device, obtaining in the formatter: | | Measurements |
| resolution, horizontal: | | DESC File Format |
| resolution, horizontal, register (.H): | | Motion Quanta |
| resolution, vertical: | | DESC File Format |
| returning to marked vertical page location (rt): | | Page Motions |
| revision number register (.Y): | | Built-in Registers |
| right margin: | | Line Layout |
| right-aligning lines (introduction): | | Basics |
| right-justifying (rj): | | Manipulating Filling and Adjustment |
| right-justifying lines (introduction): | | Basics |
| rivers: | | Other Differences |
| rj request, causing implicit break: | | Manipulating Filling and Adjustment |
| rn glyph, and cflags: | | Using Symbols |
| roman glyph, correction after italic glyph (\/): | | Italic Corrections |
| roman glyph, correction before italic glyph (\,): | | Italic Corrections |
| Roman numerals: | | Assigning Register Formats |
| Roman numerals, extrema (maximum and minimum): | | Assigning Register Formats |
| rq glyph, at end of sentence: | | Sentences |
| rq glyph, at end of sentence: | | Using Symbols |
| rt request, using + and - with: | | Numeric Expressions |
| ru glyph, and cflags: | | Using Symbols |
| running system commands: | | I/O |
|
| S | | |
|---|
| s scaling unit: | | Using Fractional Type Sizes |
| safer mode: | | Groff Options |
| safer mode: | | Macro Directories |
| safer mode: | | Built-in Registers |
| safer mode: | | I/O |
| safer mode: | | I/O |
| safer mode: | | I/O |
| safer mode: | | I/O |
| safer mode: | | Safer Mode |
| saving horizontal input line position (\k): | | Page Motions |
| scaling indicator: | | Measurements |
| scaling operator: | | Numeric Expressions |
| scaling unit c: | | Measurements |
| scaling unit f: | | Colors |
| scaling unit i: | | Measurements |
| scaling unit m: | | Measurements |
| scaling unit M: | | Measurements |
| scaling unit n: | | Measurements |
| scaling unit p: | | Measurements |
| scaling unit P: | | Measurements |
| scaling unit s: | | Using Fractional Type Sizes |
| scaling unit u: | | Measurements |
| scaling unit v: | | Measurements |
| scaling unit z: | | Using Fractional Type Sizes |
| searching fonts: | | Font Directories |
| searching macros: | | Macro Directories |
| seconds, current time (seconds): | | Built-in Registers |
| selecting the previous font (ft): | | Selecting Fonts |
| sentence space: | | Sentences |
| sentence space size register (.sss): | | Manipulating Filling and Adjustment |
| sentences: | | Sentences |
| sequence, escape: | | Formatter Instructions |
| setting diversion trap (dt): | | Diversion Traps |
| setting end-of-input trap (em): | | End-of-input Traps |
| setting input line number (lf): | | Debugging |
| setting input line trap (it, itc): | | Input Line Traps |
| setting registers (nr, \R): | | Setting Registers |
| setting the page length (pl): | | Page Layout |
| setting up an abstract font style (sty): | | Font Families |
| shc request, and translations: | | Character Translations |
| site-local directory: | | Macro Directories |
| site-local directory: | | Font Directories |
| size of sentence space register (.sss): | | Manipulating Filling and Adjustment |
| size of word space register (.ss): | | Manipulating Filling and Adjustment |
| size, optical, of a font: | | Selecting Fonts |
| size, paper: | | Paper Format |
| size, size: | | Manipulating Type Size and Vertical Spacing |
| sizes, fractional: | | Other Differences |
| sizes, fractional type: | | Using Fractional Type Sizes |
| skew, of last glyph (.csk): | | Environments |
| slant, font, changing (\S): | | Artificial Fonts |
| soft hyphen character, setting (shc): | | Manipulating Hyphenation |
| soft hyphen glyph (hy): | | Manipulating Hyphenation |
| solid circle, drawing (‘\D'C …'’): | | Drawing Geometric Objects |
| solid ellipse, drawing (‘\D'E …'’): | | Drawing Geometric Objects |
| solid polygon, drawing (‘\D'P …'’): | | Drawing Geometric Objects |
| SOURCE_DATE_EPOCH, environment variable: | | Environment |
| sp request, and no-space mode: | | Manipulating Spacing |
| sp request, causing implicit break: | | Manipulating Filling and Adjustment |
| space between sentences: | | Sentences |
| space between sentences register (.sss): | | Manipulating Filling and Adjustment |
| space between words register (.ss): | | Manipulating Filling and Adjustment |
| space character, as delimiter: | | Delimiters |
| space characters, in expressions: | | Numeric Expressions |
| space, between sentences: | | Manipulating Filling and Adjustment |
| space, between words: | | Manipulating Filling and Adjustment |
| space, discardable, horizontal: | | Manipulating Filling and Adjustment |
| space, hair (\^): | | Page Motions |
| space, horizontal (\h): | | Page Motions |
| space, horizontal, unformatting: | | Punning Names |
| space, thin (\|): | | Page Motions |
| space, unbreakable (\~): | | Manipulating Filling and Adjustment |
| space, unbreakable and unadjustable (\SP): | | Page Motions |
| space, vertical, unit (v): | | Measurements |
| space, width of a digit (numeral) (\0): | | Page Motions |
| spaces with ds: | | Strings |
| spaces, in a macro argument: | | Calling Macros |
| spaces, leading and trailing: | | Breaking |
| spacing (introduction): | | Basics |
| spacing, manipulating: | | Manipulating Spacing |
| spacing, vertical: | | Page Geometry |
| spacing, vertical: | | Manipulating Type Size and Vertical Spacing |
| spacing, vertical (introduction): | | Basics |
| special characters: | | Sentences |
| special characters: | | Character Translations |
| special characters [ms]: | | ms Legacy Features |
| special characters, list of (groff_char(7) man page): | | Using Symbols |
| special font: | | Using Fonts |
| special fonts: | | Using Symbols |
| special fonts: | | Special Fonts |
| special fonts: | | Font Description File Format |
| special fonts, emboldening: | | Artificial Fonts |
| special request, and font translations: | | Selecting Fonts |
| special request, and glyph search order: | | Using Symbols |
| spline, drawing (‘\D'~ …'’): | | Drawing Geometric Objects |
| springing a trap: | | Traps |
| sqrtex glyph, and cflags: | | Using Symbols |
| ss request, incompatibilities with AT&T troff: | | Other Differences |
| stack: | | Environments |
| stacking glyphs (\b): | | Drawing Geometric Objects |
| standard input, reading from (rd): | | I/O |
| stderr, printing to (tm, tm1, tmc): | | Debugging |
| stops, tab: | | Tabs and Leaders |
| string arguments: | | Strings |
| string comparison: | | Operators in Conditionals |
| string expansion (\*): | | Strings |
| string interpolation (\*): | | Strings |
| string, appending (as): | | Strings |
| string, creating alias for (als): | | Strings |
| string, length of (length): | | Strings |
| string, removing (rm): | | Strings |
| string, removing alias for (rm): | | Strings |
| string, renaming (rn): | | Strings |
| strings: | | Strings |
| strings [ms]: | | ms Legacy Features |
| strings, multi-line: | | Strings |
| strings, shared name space with macros and diversions: | | Identifiers |
| stripping final newline in diversions: | | Punning Names |
| stroke color: | | Colors |
| stroke color name register (.m): | | Colors |
| stroked circle, drawing (‘\D'c …'’): | | Drawing Geometric Objects |
| stroked ellipse, drawing (‘\D'e …'’): | | Drawing Geometric Objects |
| stroked polygon, drawing (‘\D'p …'’): | | Drawing Geometric Objects |
| structuring source code of documents or macro packages: | | Invoking Requests |
| sty request, and changing fonts: | | Selecting Fonts |
| sty request, and font translations: | | Selecting Fonts |
| style, font: | | Using Fonts |
| style, font, abstract: | | Using Fonts |
| style, font, abstract, setting up (sty): | | Font Families |
| styles, font: | | Font Families |
| substring (substring): | | Strings |
| subtraction: | | Numeric Expressions |
| suppressing output (\O): | | Suppressing Output |
| suppression nesting level register: | | Suppressing Output |
| sv request, and no-space mode: | | Page Control |
| switching environments (ev): | | Environments |
| sy request, and safer mode: | | Groff Options |
| sy request, disabled by default: | | Safer Mode |
| symbol: | | Using Symbols |
| symbol table, dumping (pm): | | Debugging |
| symbol, defining (char): | | Using Symbols |
| symbols, using: | | Using Symbols |
| system commands, running: | | I/O |
| system() return value register (systat): | | I/O |
|
| T | | |
|---|
| tab character: | | Tabs and Leaders |
| tab character encoding: | | Tabs and Fields |
| tab character, and translations: | | Character Translations |
| tab character, as delimiter: | | Delimiters |
| tab character, non-interpreted (\t): | | Tabs and Fields |
| tab repetition character (tc): | | Tabs and Fields |
| tab stop settings register (.tabs): | | Tabs and Fields |
| tab stops: | | Tabs and Leaders |
| tab stops, default: | | Tabs and Fields |
| tab, line-tabs mode: | | Tabs and Fields |
| table of contents: | | Table of Contents |
| table of contents: | | Leaders |
| table of contents, creating [ms]: | | ms TOC |
| table, multi-page, example [ms]: | | ms Insertions |
| tables [ms]: | | ms Insertions |
| tabs, and fields: | | Tabs and Fields |
| tabs, and macro arguments: | | Invoking Requests |
| tabs, and request arguments: | | Invoking Requests |
| tabs, before comments: | | Comments |
| tagged paragraphs: | | Paragraphs |
| tags, paragraph: | | Paragraphs |
| terminal, conditional output for: | | Operators in Conditionals |
| text baseline: | | Page Geometry |
| text baseline: | | Manipulating Type Size and Vertical Spacing |
| text font: | | Using Fonts |
| text line: | | Requests and Macros |
| text line, position of lowest (.h): | | Diversions |
| text, GNU troff processing: | | Text |
| text, justifying: | | Manipulating Filling and Adjustment |
| text, justifying (rj): | | Manipulating Filling and Adjustment |
| thickness of lines (‘\D't …'’): | | Drawing Geometric Objects |
| thin space (\|): | | Page Motions |
| three-part title (tl): | | Page Layout |
| ti request, causing implicit break: | | Manipulating Filling and Adjustment |
| ti request, using + and - with: | | Numeric Expressions |
| time, current, hours (hours): | | Built-in Registers |
| time, current, minutes (minutes): | | Built-in Registers |
| time, current, seconds (seconds): | | Built-in Registers |
| time, formatting: | | I/O |
| title length, configuring (lt): | | Page Layout |
| title line length register (.lt): | | Page Layout |
| title line, formatting (tl): | | Page Layout |
| titles: | | Page Layout |
| tkf request, and font styles: | | Font Families |
| tkf request, and font translations: | | Selecting Fonts |
| tkf request, with fractional type sizes: | | Using Fractional Type Sizes |
| tl request, and mc: | | Miscellaneous |
| tmac, directory: | | Macro Directories |
| tmac, path: | | Macro Directories |
| TMPDIR, environment variable: | | Environment |
| token, input: | | Gtroff Internals |
| top margin: | | Page Location Traps |
| top-level diversion: | | Diversions |
| top-level diversion, and bp: | | Page Control |
| top-level diversion, and \!: | | Diversions |
| top-level diversion, and \?: | | Diversions |
| tr request, and glyph definitions: | | Using Symbols |
| tr request, and soft hyphen character: | | Manipulating Hyphenation |
| tr request, incompatibilities with AT&T troff: | | Other Differences |
| track kerning: | | Ligatures and Kerning |
| track kerning, activating (tkf): | | Ligatures and Kerning |
| trailing double quotes in strings: | | Strings |
| trailing spaces in string definitions and appendments: | | Strings |
| trailing spaces on text lines: | | Breaking |
| translations of characters: | | Character Translations |
| transparent characters: | | Using Symbols |
| transparent dummy character (\)): | | Dummy Characters |
| transparent output (cf, trf): | | I/O |
| transparent output (\!, \?): | | Diversions |
| transparent output, incompatibilities with AT&T troff: | | Other Differences |
| trap: | | Deferring Output |
| trap, changing location (ch): | | Page Location Traps |
| trap, distance to next vertical position, register (.t): | | Page Location Traps |
| trap, diversion, setting (dt): | | Diversion Traps |
| trap, end-of-input, setting (em): | | End-of-input Traps |
| trap, implicit: | | The Implicit Page Trap |
| trap, input line, clearing (it, itc): | | Input Line Traps |
| trap, input line, setting (it, itc): | | Input Line Traps |
| trap, planting: | | Traps |
| trap, springing: | | Traps |
| traps: | | Traps |
| traps, and diversions: | | Page Location Traps |
| traps, blank line: | | Blank Line Traps |
| traps, diversion: | | Diversion Traps |
| traps, end-of-input: | | End-of-input Traps |
| traps, input line: | | Input Line Traps |
| traps, input line, and interrupted lines (itc): | | Input Line Traps |
| traps, leading space: | | Leading Space Traps |
| traps, page location: | | Page Location Traps |
| traps, page location, dumping (ptr): | | Debugging |
| traps, page location, listing (ptr): | | Debugging |
| traps, sprung by bp request (.pe): | | Page Location Traps |
| traps, vertical position: | | Vertical Position Traps |
| trf request, and copy mode: | | I/O |
| trf request, and invalid characters: | | I/O |
| trf request, causing implicit break: | | Manipulating Filling and Adjustment |
| trin request, and asciify: | | Diversions |
| troff mode: | | troff and nroff Modes |
| troff output: | | gtroff Output |
| truncated vertical space register (.trunc): | | Page Location Traps |
| truncating division: | | Numeric Expressions |
| TTY, conditional output for: | | Operators in Conditionals |
| tutorial for macro users: | | Tutorial for Macro Users |
| type size: | | Manipulating Type Size and Vertical Spacing |
| type size registers (.s, .ps): | | Changing the Type Size |
| type size registers, last-requested (.psr, .sr): | | Using Fractional Type Sizes |
| type sizes, changing (ps, \s): | | Changing the Type Size |
| type sizes, fractional: | | Using Fractional Type Sizes |
| type sizes, fractional: | | Other Differences |
| typeface: | | Using Fonts |
| TZ, environment variable: | | Environment |
|
| U | | |
|---|
| u scaling unit: | | Measurements |
| uf request, and font styles: | | Font Families |
| ul glyph, and cflags: | | Using Symbols |
| ul request, and font translations: | | Selecting Fonts |
| Ultrix-specific man macros: | | Optional man extensions |
| unadjustable and unbreakable space (\SP): | | Page Motions |
| unary arithmetic operators: | | Numeric Expressions |
| unbreakable and unadjustable space (\SP): | | Page Motions |
| unbreakable space (\~): | | Manipulating Filling and Adjustment |
| undefined identifiers: | | Identifiers |
| undefined request: | | Comments |
| underline font (uf): | | Artificial Fonts |
| underlining (ul): | | Artificial Fonts |
| underlining, continuous (cu): | | Artificial Fonts |
| unformatting diversions (asciify): | | Diversions |
| unformatting horizontal space: | | Punning Names |
| Unicode: | | Identifiers |
| Unicode: | | Using Symbols |
| unit, scaling, c: | | Measurements |
| unit, scaling, f: | | Colors |
| unit, scaling, i: | | Measurements |
| unit, scaling, m: | | Measurements |
| unit, scaling, M: | | Measurements |
| unit, scaling, n: | | Measurements |
| unit, scaling, p: | | Measurements |
| unit, scaling, P: | | Measurements |
| unit, scaling, s: | | Using Fractional Type Sizes |
| unit, scaling, u: | | Measurements |
| unit, scaling, v: | | Measurements |
| unit, scaling, z: | | Using Fractional Type Sizes |
| units of measurement: | | Measurements |
| units, basic: | | Page Geometry |
| units, basic, conversion to: | | Measurements |
| units, default: | | Default Units |
| units, machine: | | Page Geometry |
| unnamed glyphs: | | Using Symbols |
| unnamed glyphs, accessing with \N: | | Font Description File Format |
| unsafe mode: | | Groff Options |
| unsafe mode: | | Macro Directories |
| unsafe mode: | | Built-in Registers |
| unsafe mode: | | I/O |
| unsafe mode: | | I/O |
| unsafe mode: | | I/O |
| unsafe mode: | | I/O |
| unstyled font: | | Using Fonts |
| up-casing a string (stringup): | | Strings |
| uppercasing a string (stringup): | | Strings |
| upright glyph, correction after oblique glyph (\/): | | Italic Corrections |
| upright glyph, correction before oblique glyph (\,): | | Italic Corrections |
| URLs, breaking (\:): | | Manipulating Hyphenation |
| user’s macro tutorial: | | Tutorial for Macro Users |
| user’s tutorial for macros: | | Tutorial for Macro Users |
| using escape sequences: | | Using Escape Sequences |
| using symbols: | | Using Symbols |
| UTF-8 output encoding: | | Groff Options |
|
| V | | |
|---|
| v scaling unit: | | Measurements |
| valid numeric expression: | | Numeric Expressions |
| value, incrementing without changing the register: | | Auto-increment |
| variables in environment: | | Environment |
| vee: | | Page Geometry |
| vee scaling unit (v): | | Measurements |
| version number, major, register (.x): | | Built-in Registers |
| version number, minor, register (.y): | | Built-in Registers |
| vertical drawing position (nl): | | Page Control |
| vertical line drawing (\L): | | Drawing Geometric Objects |
| vertical line spacing register (.v): | | Changing the Vertical Spacing |
| vertical line spacing, changing (vs): | | Changing the Vertical Spacing |
| vertical line spacing, effective value: | | Changing the Vertical Spacing |
| vertical motion (\v): | | Page Motions |
| vertical motion quantum: | | DESC File Format |
| vertical page location, marking (mk): | | Page Motions |
| vertical page location, returning to marked (rt): | | Page Motions |
| vertical position in diversion register (.d): | | Diversions |
| vertical position trap enable register (.vpt): | | Vertical Position Traps |
| vertical position traps: | | Vertical Position Traps |
| vertical position traps, enabling (vpt): | | Vertical Position Traps |
| vertical position, drawing (nl): | | Page Control |
| vertical resolution: | | DESC File Format |
| vertical space unit (v): | | Measurements |
| vertical spacing: | | Page Geometry |
| vertical spacing: | | Manipulating Type Size and Vertical Spacing |
| vertical spacing (introduction): | | Basics |
|
| W | | |
|---|
| warning categories: | | Warnings |
| warning level (warn): | | Debugging |
| warnings: | | Debugging |
| warnings: | | Warnings |
| what is groff?: | | What Is groff? |
| while: | | while |
| while request, and font translations: | | Selecting Fonts |
| while request, and the ‘!’ operator: | | Numeric Expressions |
| while request, confusing with br: | | while |
| while request, operators to use with: | | Operators in Conditionals |
| widow: | | Page Control |
| widow: | | Page Control |
| width escape (\w): | | Page Motions |
| width, of last glyph (.w): | | Environments |
| word space size register (.ss): | | Manipulating Filling and Adjustment |
| word, definition of: | | Filling |
| write request, and copy mode: | | I/O |
| writec request, and copy mode: | | I/O |
| writem request, and copy mode: | | I/O |
| writing macros: | | Writing Macros |
| writing to file (write, writec): | | I/O |
|
| Y | | |
|---|
| year, current, register (year, yr): | | Built-in Registers |
|
| Z | | |
|---|
| z scaling unit: | | Using Fractional Type Sizes |
| zero-width printing (\z, \Z): | | Page Motions |
| zero-width printing (\z, \Z): | | Page Motions |
| zoom factor of a font (fzoom): | | Selecting Fonts |
|