gtbl(1) | User Commands | gtbl(1) |
gtbl - prepare tables for groff documents
gtbl |
[-C] [file ...] |
gtbl |
--help |
gtbl |
-v |
gtbl |
--version |
The GNU implementation of tbl is part of the groff(1) document formatting system. gtbl is a gtroff(1) preprocessor that translates descriptions of tables embedded in roff(7) input files into the language understood by gtroff. It copies the contents of each file to the standard output stream, except that lines between .TS and .TE are interpreted as table descriptions. While GNU tbl's input syntax is highly compatible with AT&T tbl, the output GNU tbl produces cannot be processed by AT&T troff; GNU troff (or a troff implementing any GNU extensions employed) must be used. Normally, gtbl is not executed directly by the user, but invoked by specifying the -t option to groff(1). If no file operands are given on the command line, or if file is “-”, gtbl reads the standard input stream.
gtbl expects to find table descriptions between input lines that begin with .TS (table start) and .TE (table end). Each such table region encloses one or more table descriptions. Within a table region, table descriptions beyond the first must each be preceded by an input line beginning with .T&. This mechanism does not start a new table region; all table descriptions are treated as part of their .TS/.TE enclosure, even if they are boxed or have column headings that repeat on subsequent pages (see below).
(Experienced roff users should observe that gtbl is not a roff language interpreter: the default control character must be used, and no spaces or tabs are permitted between the control character and the macro name. These gtbl input tokens remain as-is in the output, where they become ordinary macro calls. Macro packages often define TS, T&, and TE macros to handle issues of table placement on the page. gtbl produces groff code to define these macros as empty if their definitions do not exist when the formatter encounters a table region.)
Each table region may begin with region options, and must contain one or more table definitions; each table definition contains a format specification followed by one or more input lines (rows) of entries. These entries comprise the table data.
The line immediately following the .TS token may specify region options, keywords that influence the interpretation or rendering of the region as a whole or all table entries within it indiscriminately. They must be separated by commas, spaces, or tabs. Those that require a parenthesized argument permit spaces and tabs between the option's name and the opening parenthesis. Options accumulate and cannot be unset within a region once declared; if an option that takes a parameter is repeated, the last occurrence controls. If present, the set of region options must be terminated with a semicolon (;).
Any of the allbox, box, doublebox, frame, and doubleframe region options makes a table “boxed” for the purpose of later discussion.
The table format specification is mandatory: it determines the number of columns in the table and directs how the entries within it are to be typeset. The format specification is a series of column descriptors. Each descriptor encodes a classifier followed by zero or more modifiers. Classifiers are letters (recognized case-insensitively) or punctuation symbols; modifiers consist of or begin with letters or numerals. Spaces, tabs, newlines, and commas separate descriptors. Newlines and commas are special; they apply the descriptors following them to a subsequent row of the table. (This enables column headings to be centered or emboldened while the table entries for the data are not, for instance.) We term the resulting group of column descriptors a row definition. Within a row definition, separation between column descriptors (by spaces or tabs) is often optional; only some modifiers, described below, make separation necessary.
Each column descriptor begins with a mandatory classifier, a character that selects from one of several arrangements. Some determine the positioning of table entries within a rectangular cell: centered, left-aligned, numeric (aligned to a configurable decimal separator), and so on. Others perform special operations like drawing lines or spanning entries from adjacent cells in the table. Except for “|”, any classifier can be followed by one or more modifiers; some of these accept an argument, which in GNU tbl can be parenthesized. Modifiers select fonts, set the type size, and perform other tasks described below.
The format specification can occupy multiple input lines, but must conclude with a dot “.” followed by a newline. Each row definition is applied in turn to one row of the table. The last row definition is applied to rows of table data in excess of the row definitions.
For clarity in this document's examples, we shall write classifiers in uppercase and modifiers in lowercase. Thus, “CbCb,LR.” defines two rows of two columns. The first row's entries are centered and boldfaced; the second and any further rows' first and second columns are left- and right-aligned, respectively.
The row definition with the most column descriptors determines the number of columns in the table; any row definition with fewer is implicitly extended on the right-hand side with L classifiers as many times as necessary to make the table rectangular.
The L, R, and C classifiers are the easiest to understand and use.
To change the table format within a gtbl region, use the .T& token at the start of a line. It is followed by a format specification and table data, but not region options. The quantity of columns in a new table format thus introduced cannot increase relative to the previous table format; in that case, you must end the table region and start another. If that will not serve because the region uses box options or the columns align in an undesirable manner, you must design the initial table format specification to include the maximum quantity of columns required, and use the S horizontal spanning classifier where necessary to achieve the desired columnar alignment.
Attempting to horizontally span in the first column or vertically span on the first row is an error. Non-rectangular span areas are also not supported.
Any number of modifiers can follow a column classifier. Arguments
to modifiers, where accepted, are case-sensitive. If the same modifier is
applied to a column specifier more than once, or if conflicting modifiers
are applied, only the last occurrence has effect. The
modifier x is mutually exclusive with e
and w, but e is not mutually exclusive
with w; if these are used in combination,
x unsets both e and w, while either
e or w overrides x.
The table data come after the format specification. Each input line corresponds to a table row, except that a backslash at the end of a line of table data continues an entry on the next input line. (Text blocks, discussed below, also spread table entries across multiple input lines.) Table entries within a row are separated in the input by a tab character by default; see the tab region option above. Excess entries in a row of table data (those that have no corresponding column descriptor, not even an implicit one arising from rectangularization of the table) are discarded with a diagnostic message. roff control lines are accepted between rows of table data and within text blocks. If you wish to visibly mark an empty table entry in the document source, populate it with the \& roff dummy character. The table data are interrupted by a line consisting of the .T& input token, and conclude with the line .TE.
Ordinarily, a table entry is typeset rigidly. It is not filled, broken, hyphenated, adjusted, or populated with additional inter-sentence space. gtbl instructs the formatter to measure each table entry as it occurs in the input, updating the width required by its corresponding column. If the z modifier applies to the column, this measurement is ignored; if w applies and its argument is larger than this width, that argument is used instead. In contrast to conventional roff input (within a paragraph, say), changes to text formatting, such as font selection or vertical spacing, do not persist between entries.
Several forms of table entry are interpreted specially.
On occasion, these special tokens may be required as literal table data. To use either _ or = literally and alone in an entry, prefix or suffix it with the roff dummy character \&. To express \_, \=, or \R, use a roff escape sequence to interpolate the backslash (\e or \[rs]). A reliable way to emplace the \^ glyph sequence within a table entry is to use a pair of groff special character escape sequences (\[rs]\[ha]).
Rows of table entries can be interleaved with groff control lines; these do not count as table data. On such lines the default control character (.) must be used (and not changed); the no-break control character is not recognized. To start the first table entry in a row with a dot, precede it with the roff dummy character \&.
An ordinary table entry's contents can make a column, and therefore the table, excessively wide; the table then exceeds the line length of the page, and becomes ugly or is exposed to truncation by the output device. When a table entry requires more conventional typesetting, breaking across more than one output line (and thereby increasing the height of its row), it can be placed within a text block.
gtbl interprets a table entry beginning with “T{” at the end of an input line not as table data, but as a token starting a text block. Similarly, “T}” at the start of an input line ends a text block; it must also end the table entry. Text block tokens can share an input line with other table data (preceding T{ and following T}). Input lines between these tokens are formatted in a diversion by troff. Text blocks cannot be nested. Multiple text blocks can occur in a table row.
Text blocks are formatted as was the text prior to the table, modified by applicable column descriptors. Specifically, the classifiers A, C, L, N, R, and S determine a text block's alignment within its cell, but not its adjustment. Add na or ad requests to the beginning of a text block to alter its adjustment distinctly from other text in the document. As with other table entries, when a text block ends, any alterations to formatting parameters are discarded. They do not affect subsequent table entries, not even other text blocks.
If w or x modifiers are not specified for all columns of a text block's span, the default length of the text block (more precisely, the line length used to process the text block diversion) is computed as L×C/(N+1), where L is the current line length, C the number of columns spanned by the text block, and N the number of columns in the table. If necessary, you can also control a text block's width by including an ll (line length) request in it prior to any text to be formatted. Because a diversion is used to format the text block, its height and width are subsequently available in the registers dn and dl, respectively.
The register TW stores the width of the table region in basic units; it can't be used within the region itself, but is defined before the .TE token is output so that a groff macro named TE can make use of it. T. is a Boolean-valued register indicating whether the bottom of the table is being processed. The #T register marks the top of the table. Avoid using these names for any other purpose.
gtbl also defines a macro T# to produce the bottom and side lines of a boxed table. While gtbl itself arranges for the output to include a call of this macro at the end of such a table, it can also be used by macro packages to create boxes for multi-page tables by calling it from a page footer macro that is itself called by a trap planted near the bottom of the page. See section “Limitations” below for more on multi-page tables.
GNU tbl internally employs register, string, macro, and diversion names beginning with the numeral 3. A document to be preprocessed with GNU tbl should not use any such identifiers.
gtbl should always be called before geqn(1). (groff(1) automatically arranges preprocessors in the correct order.) Don't call the EQ and EN macros within tables; instead, set up delimiters in your eqn input and use the delim region option so that gtbl will recognize them.
In addition to extensions noted above, GNU tbl removes constraints endured by users of AT&T tbl.
You can embed a table region inside a macro definition. However, since gtbl writes its own macro definitions at the beginning of each table region, it is necessary to call end macros instead of ending macro definitions with “..”. Additionally, the escape character must be disabled.
Not all gtbl features can be exercised from such macros because gtbl is a roff preprocessor: it sees the input earlier than gtroff does. For example, vertically aligning decimal separators fails if the numbers containing them occur as macro or string parameters; the alignment is performed by gtbl itself, which sees only \$1, \$2, and so on, and therefore can't recognize a decimal separator that only appears later when gtroff interpolates a macro or string definition.
Using gtbl macros within conditional input (that is,
contingent upon an if, ie, el, or while request)
can result in misleading line numbers in subsequent diagnostics. gtbl
unconditionally injects its output into the source document, but the
conditional branch containing it may not be taken, and if it is not, the
lf requests that gtbl injects to restore the source line
number cannot take effect. Consider copying the input line counter register
c. and restoring its value at a convenient location after applicable
arithmetic.
--help displays a usage message, while -v and --version show version information; all exit afterward.
Multi-page tables, if boxed and/or if you want their column headings repeated after page breaks, require support at the time the document is formatted. A convention for such support has arisen in macro packages such as ms, mm, and me. To use it, follow the .TS token with a space and then “H”; this will be interpreted by the formatter as a TS macro call with an H argument. Then, within the table data, call the TH macro; this informs the macro package where the headings end. If your table has no such heading rows, or you do not desire their repetition, call TH immediately after the table format specification. If a multi-page table is boxed or has repeating column headings, do not enclose it with keep/release macros, or divert it in any other way. Further, the bp request will not cause a page break in a “TS H” table. Define a macro to wrap bp: invoke it normally if there is no current diversion. Otherwise, pass the macro call to the enclosing diversion using the transparent line escape sequence \!; this will “bubble up” the page break to the output device. See section “Examples” below for a demonstration.
Double horizontal rules are not supported by grotty(1); single rules are used instead. grotty also ignores half-line motions, so the u column modifier has no effect. On terminal devices (“nroff mode”), horizontal rules and box borders occupy a full vee of space; this amount is doubled for doublebox tables. Tables using these features thus require more vertical space in nroff mode than in troff mode: write ne requests accordingly. Vertical rules between columns are drawn in the space between columns in nroff mode; using double vertical rules and/or reducing the column separation below the default can make them ugly or overstrike them with table data.
A text block within a table must be able to fit on one page.
Using \a to put leaders in table entries does not work in GNU tbl, except in compatibility mode. This is correct behavior: \a is an uninterpreted leader. You can still use the roff leader character (Control+A) or define a string to use \a as it was designed: to be interpreted only in copy mode.
.ds a \a .TS box center tab(;); Lw(2i)0 L. Population\*a;6,327,119 .TE
Population? | 6,327,119 |
A leading and/or trailing | in a format specification, such as “|LCR|.”, produces an en space between the vertical rules and the content of the adjacent columns. If no such space is desired (so that the rule abuts the content), you can introduce “dummy” columns with zero separation and empty corresponding table entries before and/or after.
.TS center tab(#); R0|L C R0|L. _ #levulose#glucose#dextrose# _ .TE
These dummy columns have zero width and are therefore invisible; unfortunately they usually don't work as intended on terminal devices.
It can be easier to acquire the language of tbl through examples than formal description, especially at first.
.TS box center tab(#); Cb Cb L L. Ability#Application Strength#crushes a tomato Dexterity#dodges a thrown tomato Constitution#eats a month-old tomato without becoming ill Intelligence#knows that a tomato is a fruit Wisdom#chooses \f[I]not\f[] to put tomato in a fruit salad Charisma#sells obligate carnivores tomato-based fruit salads .TE
Ability | Application |
Strength | crushes a tomato |
Dexterity | dodges a thrown tomato |
Constitution | eats a month-old tomato without becoming ill |
Intelligence | knows that a tomato is a fruit |
Wisdom | chooses not to put tomato in a fruit salad |
Charisma | sells obligate carnivores tomato-based fruit salads |
The A and N column classifiers can be easier to grasp in visual rendering than in description.
.TS center tab(;); CbS,LN,AN. Daily energy intake (in MJ) Macronutrients .\" assume 3 significant figures of precision Carbohydrates;4.5 Fats;2.25 Protein;3 .T& LN,AN. Mineral Pu-239;14.6 _ .T& LN. Total;\[ti]24.4 .TE
Daily energy intake (in MJ) | |
Macronutrients | |
Carbohydrates | 4.5 |
Fats | 2.25 |
Protein | 3 |
Mineral | |
Pu-239 | 14.6 |
Total | ~24.4 |
Next, we'll lightly adapt a compact presentation of spanning, vertical alignment, and zero-width column modifiers from the mandoc reference for its tbl interpreter. It rewards close study.
.TS box center tab(:); Lz S | Rt Ld| Cb| ^ ^ | Rz S. left:r l:center: :right .TE
left | r | |
l | center | |
right |
Row staggering is not visually achievable on terminal devices, but a table using it can remain comprehensible nonetheless.
.TS center tab(|); Cf(BI) Cf(BI) Cf(B), C C Cu. n|n\f[B]\[tmu]\f[]n|difference 1|1 2|4|3 3|9|5 4|16|7 5|25|9 6|36|11 .TE
n | n×n | difference |
1 | 1 | |
2 | 4 | 3 |
3 | 9 | 5 |
4 | 16 | 7 |
5 | 25 | 9 |
6 | 36 | 11 |
Some gtbl features cannot be illustrated in the limited environment of a portable man page.
We can define a macro outside of a tbl region that we can call from within it to cause a page break inside a multi-page boxed table. You can choose a different name; be sure to change both occurrences of “BP”.
.de BP . ie '\\n(.z'' .bp \\$1 . el \!.BP \\$1 ..
“Tbl—A Program to Format Tables”, by M. E. Lesk, 1976 (revised 16 January 1979), AT&T Bell Laboratories Computing Science Technical Report No. 49.
The spanning example above was taken from mandoc's man page for its tbl implementation.
groff(1), gtroff(1)
2 July 2023 | groff 1.23.0 |